diff --git a/.gitignore b/.gitignore
index 87b01fe7fa5c..ca9686a3a2b3 100644
--- a/.gitignore
+++ b/.gitignore
@@ -210,6 +210,11 @@ src/jsc/bindings/GeneratedBindings.zig
 # Web Streams rewrite working notes (design docs, spec transcription, review logs).
 # Kept locally for the ongoing work; not part of the source tree.
 /specs/
+/garbage-env
+# compiled-bundler test outputs that land in cwd when tests run from the root
+/entry
+/entry.js.map
+/nosourcemap_entry
 
 # hawk analysis scaffolding (see tools/hawk/); generated per-run, never committed
 src/bun_bin/hawk_root.rs
diff --git a/docs/project/benchmarking.mdx b/docs/project/benchmarking.mdx
index 7cca79fe73fd..1863bdc95c62 100644
--- a/docs/project/benchmarking.mdx
+++ b/docs/project/benchmarking.mdx
@@ -261,13 +261,19 @@ bun --cpu-prof --cpu-prof-dir ./profiles script.js
 
 ## Heap profiling
 
-Generate heap snapshots on exit to analyze memory usage and find memory leaks.
+Write a heap profile on exit to analyze memory usage and find memory leaks.
 
 ```sh terminal icon="terminal"
 bun --heap-prof script.js
 ```
 
-`--heap-prof` writes a V8 `.heapsnapshot` file you can load in Chrome DevTools (Memory tab → Load).
+`--heap-prof` writes a full V8-format heap snapshot on exit, using Node.js's
+diagnostic filename format
+(`Heap.<yyyymmdd>.<hhmmss>.<pid>.<tid>.<seq>.heapprofile`). The content is the
+same as `v8.writeHeapSnapshot()` / `Bun.generateHeapSnapshot("v8")`: load it in
+Chrome DevTools via Memory tab → Load (pick "All Files" or rename to
+`.heapsnapshot` — the extension follows Node's `--heap-prof` filename contract,
+which the harness and tooling key on).
 
 ### Markdown output
 
@@ -282,13 +288,14 @@ bun --heap-prof-md script.js
 ### Options
 
 ```sh terminal icon="terminal"
-bun --heap-prof --heap-prof-name my-snapshot.heapsnapshot script.js
+bun --heap-prof --heap-prof-name my-profile.heapprofile script.js
 bun --heap-prof --heap-prof-dir ./profiles script.js
 ```
 
-| Flag                          | Description                                |
-| ----------------------------- | ------------------------------------------ |
-| `--heap-prof`                 | Generate a V8 `.heapsnapshot` file on exit |
-| `--heap-prof-md`              | Generate a markdown heap profile on exit   |
-| `--heap-prof-name <filename>` | Set output filename                        |
-| `--heap-prof-dir <dir>`       | Set output directory                       |
+| Flag                           | Description                                                                                                                                |
+| ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------ |
+| `--heap-prof`                  | Write a `.heapprofile` file on exit                                                                                                        |
+| `--heap-prof-md`               | Generate a markdown heap profile on exit                                                                                                   |
+| `--heap-prof-name <filename>`  | Set output filename                                                                                                                        |
+| `--heap-prof-dir <dir>`        | Set output directory                                                                                                                       |
+| `--heap-prof-interval <bytes>` | Accepted for Node.js compatibility (the snapshot is taken once at exit; JavaScriptCore has no allocation sampling to apply an interval to) |
diff --git a/docs/runtime/watch-mode.mdx b/docs/runtime/watch-mode.mdx
index 8e1c2f45211e..27d2d8d617ba 100644
--- a/docs/runtime/watch-mode.mdx
+++ b/docs/runtime/watch-mode.mdx
@@ -76,6 +76,12 @@ bun --watch test
   --no-clear-screen`.
 </Note>
 
+<Note>
+  Before each restart, `bun run --watch` runs the handlers your script registered for the kill signal (default
+  `SIGTERM`, matching the signal Node.js sends its watched process). Use **`--watch-kill-signal`** to pick a different
+  signal, e.g. `bun --watch --watch-kill-signal SIGINT index.ts`.
+</Note>
+
 ---
 
 ## `--hot` mode
diff --git a/docs/snippets/cli/run.mdx b/docs/snippets/cli/run.mdx
index 9530cf60fa7d..440f46fff00f 100644
--- a/docs/snippets/cli/run.mdx
+++ b/docs/snippets/cli/run.mdx
@@ -112,6 +112,10 @@ bun run <file or script>
   Automatically restart the process on file change
 </ParamField>
 
+<ParamField path="--watch-kill-signal" type="string" default="SIGTERM">
+  Signal whose handlers run when --watch restarts the process
+</ParamField>
+
 <ParamField path="--hot" type="boolean">
   Enable auto reload in the Bun runtime, test runner, or bundler
 </ParamField>
diff --git a/packages/bun-types/bun.d.ts b/packages/bun-types/bun.d.ts
index 4c756a6d4c31..6a47f7c54350 100644
--- a/packages/bun-types/bun.d.ts
+++ b/packages/bun-types/bun.d.ts
@@ -555,6 +555,18 @@ declare module "bun" {
      * @default true
      */
     ambiguousIsNarrow?: boolean;
+
+    /**
+     * If `true`, measure every Unicode code point individually (East Asian
+     * Width plus emoji presentation, the algorithm Node.js uses for
+     * `console.table` and `util.inspect` alignment), so each member of an
+     * emoji ZWJ sequence is counted: `"👨‍👩‍👧‍👦"` measures 8. If `false`,
+     * emoji sequences and other grapheme clusters count once: `"👨‍👩‍👧‍👦"`
+     * measures 2.
+     *
+     * @default false
+     */
+    perCodePoint?: boolean;
   }
 
   /**
diff --git a/scripts/verify-baseline-static/allowlist-aarch64.txt b/scripts/verify-baseline-static/allowlist-aarch64.txt
index 70a2d22281d5..e6003c64adb5 100644
--- a/scripts/verify-baseline-static/allowlist-aarch64.txt
+++ b/scripts/verify-baseline-static/allowlist-aarch64.txt
@@ -235,6 +235,7 @@ __aarch64_ldset2_acq_rel  [LSE]
 __aarch64_ldset4_acq_rel  [LSE]
 __aarch64_ldset4_rel      [LSE]
 __aarch64_ldset4_relax    [LSE]
+__aarch64_ldset8_rel      [LSE]
 __aarch64_ldset8_acq_rel  [LSE]
 __aarch64_ldset8_relax    [LSE]
 __aarch64_swp1_acq        [LSE]
diff --git a/src/bun_core/Global.rs b/src/bun_core/Global.rs
index b9e3932a4f1e..56cff6a2b82d 100644
--- a/src/bun_core/Global.rs
+++ b/src/bun_core/Global.rs
@@ -281,6 +281,73 @@ macro_rules! __define_signal_code {
 }
 for_each_signal!(__define_signal_code);
 
+impl SignalCode {
+    /// This table uses Linux numbering; returns the current platform's number
+    /// (they differ on macOS/BSD), or `None` when the platform lacks the signal.
+    pub fn platform_number(self) -> Option<i32> {
+        #[cfg(unix)]
+        {
+            use SignalCode as S;
+            Some(match self {
+                S::SIGHUP => libc::SIGHUP,
+                S::SIGINT => libc::SIGINT,
+                S::SIGQUIT => libc::SIGQUIT,
+                S::SIGILL => libc::SIGILL,
+                S::SIGTRAP => libc::SIGTRAP,
+                S::SIGABRT => libc::SIGABRT,
+                S::SIGBUS => libc::SIGBUS,
+                S::SIGFPE => libc::SIGFPE,
+                S::SIGKILL => libc::SIGKILL,
+                S::SIGUSR1 => libc::SIGUSR1,
+                S::SIGSEGV => libc::SIGSEGV,
+                S::SIGUSR2 => libc::SIGUSR2,
+                S::SIGPIPE => libc::SIGPIPE,
+                S::SIGALRM => libc::SIGALRM,
+                S::SIGTERM => libc::SIGTERM,
+                S::SIG16 => return None,
+                S::SIGCHLD => libc::SIGCHLD,
+                S::SIGCONT => libc::SIGCONT,
+                S::SIGSTOP => libc::SIGSTOP,
+                S::SIGTSTP => libc::SIGTSTP,
+                S::SIGTTIN => libc::SIGTTIN,
+                S::SIGTTOU => libc::SIGTTOU,
+                S::SIGURG => libc::SIGURG,
+                S::SIGXCPU => libc::SIGXCPU,
+                S::SIGXFSZ => libc::SIGXFSZ,
+                S::SIGVTALRM => libc::SIGVTALRM,
+                S::SIGPROF => libc::SIGPROF,
+                S::SIGWINCH => libc::SIGWINCH,
+                S::SIGIO => libc::SIGIO,
+                #[cfg(target_os = "linux")]
+                S::SIGPWR => libc::SIGPWR,
+                #[cfg(not(target_os = "linux"))]
+                S::SIGPWR => return None,
+                S::SIGSYS => libc::SIGSYS,
+            })
+        }
+        #[cfg(not(unix))]
+        {
+            // Windows numbering: CRT <signal.h> plus libuv's synthetic SIGHUP/SIGQUIT/SIGKILL/
+            // SIGWINCH (src/jsc/bindings/libuv/uv/win.h). The enum discriminants are Linux numbers
+            // and must not leak here (SIGABRT is 22 on Windows, not 6).
+            use SignalCode as S;
+            match self {
+                S::SIGHUP => Some(1),
+                S::SIGINT => Some(2),
+                S::SIGQUIT => Some(3),
+                S::SIGILL => Some(4),
+                S::SIGABRT => Some(22),
+                S::SIGFPE => Some(8),
+                S::SIGKILL => Some(9),
+                S::SIGSEGV => Some(11),
+                S::SIGTERM => Some(15),
+                S::SIGWINCH => Some(28),
+                _ => None,
+            }
+        }
+    }
+}
+
 // ─── analytics::features (MOVE_DOWN from bun_analytics) ───────────────────
 // Atomic counters so cross-thread `.fetch_add` is sound. Only the
 // counters are tier-0; `builtin_modules` (EnumSet over jsc HardcodedModule)
diff --git a/src/bun_core/env_var.rs b/src/bun_core/env_var.rs
index 9d0cfef32b36..728b3799ef0b 100644
--- a/src/bun_core/env_var.rs
+++ b/src/bun_core/env_var.rs
@@ -157,10 +157,15 @@ new!(pub NODE_CHANNEL_FD: string, "NODE_CHANNEL_FD", {});
 // A string, not a boolean: node suppresses warnings only when the value is
 // exactly "1" (lib/internal/process/pre_execution.js).
 new!(pub NODE_NO_WARNINGS: string, "NODE_NO_WARNINGS", {});
+new!(pub NODE_COMPILE_CACHE: string, "NODE_COMPILE_CACHE", {});
+new!(pub NODE_COMPILE_CACHE_PORTABLE: string, "NODE_COMPILE_CACHE_PORTABLE", {});
+new!(pub NODE_DEBUG_NATIVE: string, "NODE_DEBUG_NATIVE", {});
+new!(pub NODE_DISABLE_COMPILE_CACHE: string, "NODE_DISABLE_COMPILE_CACHE", {});
 // Set by HostProcess.rs when spawning the WebView host subprocess. The
 // child's CLI entrypoint checks this before anything else and hands off to
 // C++ Bun__WebView__hostMain. Never returns — no JSC, no VM.
 new!(pub BUN_INTERNAL_WEBVIEW_HOST: string, "BUN_INTERNAL_WEBVIEW_HOST", {});
+new!(pub NODE_PENDING_DEPRECATION: string, "NODE_PENDING_DEPRECATION", {});
 new!(pub NODE_PRESERVE_SYMLINKS_MAIN: boolean, "NODE_PRESERVE_SYMLINKS_MAIN", { default: false });
 new!(pub NODE_USE_SYSTEM_CA: boolean, "NODE_USE_SYSTEM_CA", { default: false });
 new!(pub npm_lifecycle_event: string, "npm_lifecycle_event", {});
diff --git a/src/bun_core/lib.rs b/src/bun_core/lib.rs
index b5b02253e860..7a6664d9e134 100644
--- a/src/bun_core/lib.rs
+++ b/src/bun_core/lib.rs
@@ -2558,6 +2558,9 @@ pub mod ffi {
     unsafe impl Zeroable for libc::pollfd {}
     // SAFETY: C POD (integer/array/raw-pointer fields only); all-zero is valid.
     #[cfg(unix)]
+    unsafe impl Zeroable for libc::tm {}
+    // SAFETY: C POD (integer/array/raw-pointer fields only); all-zero is valid.
+    #[cfg(unix)]
     unsafe impl Zeroable for libc::Dl_info {}
     // SAFETY: C POD (integer/array/raw-pointer fields only); all-zero is valid.
     #[cfg(unix)]
diff --git a/src/bun_core/util.rs b/src/bun_core/util.rs
index 4bd44f0741ca..705ae0158e99 100644
--- a/src/bun_core/util.rs
+++ b/src/bun_core/util.rs
@@ -4130,6 +4130,34 @@ pub fn intern_argv(v: Vec<&'static ZStr>) -> &'static [&'static ZStr] {
 /// Writes the current working directory into the caller's `PathBuffer` and
 /// returns the NUL-terminated slice on success.
 pub fn getcwd(buf: &mut PathBuffer) -> crate::CrateResult<&ZStr> {
+    let len = getcwd_len(buf)?;
+    Ok(ZStr::from_buf(&buf.0, len))
+}
+
+/// `getcwd` tolerating an unreachable cwd (e.g. deleted while we run): falls
+/// back to the executable's directory like Node's `Environment::GetCwd`, so
+/// startup proceeds and `process.cwd()` surfaces the real error later.
+pub fn getcwd_or_exe_dir(buf: &mut PathBuffer) -> &ZStr {
+    let len = match getcwd_len(buf) {
+        Ok(n) => n,
+        Err(_) => {
+            let dir: &[u8] = self_exe_path()
+                .ok()
+                .and_then(|p| dirname(p.as_bytes()))
+                // Reject a dir that can't fit with its NUL (paths from
+                // /proc/self/exe are not bounded by MAX_PATH_BYTES).
+                .filter(|d| d.len() < buf.0.len())
+                .unwrap_or(if cfg!(windows) { b"C:\\" } else { b"/" });
+            buf.0[..dir.len()].copy_from_slice(dir);
+            buf.0[dir.len()] = 0;
+            dir.len()
+        }
+    };
+    ZStr::from_buf(&buf.0, len)
+}
+
+/// Length-returning core of [`getcwd`]; `buf` holds the NUL-terminated path.
+fn getcwd_len(buf: &mut PathBuffer) -> crate::CrateResult<usize> {
     #[cfg(unix)]
     // SAFETY: `buf` provides `MAX_PATH_BYTES` writable bytes for `getcwd`; on
     // success the returned pointer aliases `buf` and is NUL-terminated, so
@@ -4139,8 +4167,7 @@ pub fn getcwd(buf: &mut PathBuffer) -> crate::CrateResult<&ZStr> {
         if p.is_null() {
             return Err(crate::CrateError::Unexpected);
         }
-        let len = libc::strlen(p);
-        Ok(ZStr::from_buf(&buf.0, len))
+        Ok(libc::strlen(p))
     }
     #[cfg(windows)]
     {
@@ -4176,7 +4203,7 @@ pub fn getcwd(buf: &mut PathBuffer) -> crate::CrateResult<&ZStr> {
             bi += nb;
         }
         out[bi] = 0;
-        Ok(ZStr::from_buf(&buf.0[..], bi))
+        Ok(bi)
     }
     #[cfg(not(any(unix, windows)))]
     {
@@ -4353,14 +4380,25 @@ pub fn maybe_handle_panic_during_process_reload() {
     }
 }
 
-/// Port of `bun.reloadProcess`. Allocator param dropped (uses libc malloc via
-/// `dupe_z`). `may_return == true` → returns on failure; `false` → panics.
-/// macOS posix_spawn path is deferred to bun_spawn (tier-4); tier-0 falls
-/// back to plain `execve` on all POSIX which is correct on Linux/BSD and
-/// best-effort on macOS (CLOEXEC handled by `on_before_reload_process_linux`
-/// hook on Linux; Darwin gets the simpler path until tier-4 wires spawn).
+/// Port of `bun.reloadProcess`. `may_return == true` → returns on failure; `false` → panics.
+/// `on_before_reload_process_posix` clears CLOEXEC on stdio/IPC and resets caught signal
+/// dispositions on all POSIX; the close_range sweep is Linux/BSD only.
 pub fn reload_process(clear_terminal: bool, may_return: bool) {
-    RELOAD_IN_PROGRESS.store(true, AOrdering::Relaxed);
+    // Exactly one thread may perform the reload: the JS thread and the watcher's grace-window
+    // fallback can both reach here, and concurrent execve prep crashes on musl. The swap elects a
+    // winner; a loser parks or returns. A thread that already owns the reload may re-enter.
+    let owns_reload = RELOAD_IN_PROGRESS_ON_CURRENT_THREAD.with(|c| c.get());
+    if !owns_reload && RELOAD_IN_PROGRESS.swap(true, AOrdering::SeqCst) {
+        if may_return {
+            return;
+        }
+        // Park (not pthread_exit): the loser may be the JS main thread, and
+        // running its TLS destructors concurrently with the winner's execve
+        // preparation is the same hazard class the swap exists to avoid.
+        loop {
+            std::thread::sleep(std::time::Duration::from_secs(3600));
+        }
+    }
     RELOAD_IN_PROGRESS_ON_CURRENT_THREAD.with(|c| c.set(true));
 
     if clear_terminal {
@@ -4401,17 +4439,14 @@ pub fn reload_process(clear_terminal: bool, may_return: bool) {
     }
 
     #[cfg(unix)]
-    // SAFETY: the FFI calls below (`on_before_reload_process_linux`, `execve`)
-    // receive only locally-built NUL-terminated argv/envp arrays terminated by
-    // a null pointer; on success `execve` never returns, on failure errno is
-    // read. No borrowed Rust state is observed after the exec.
+    // SAFETY: FFI calls receive only locally-built NUL-terminated argv/envp arrays; on success
+    // `execve` never returns, on failure errno is read. No borrowed Rust state observed after.
     unsafe {
-        #[cfg(any(target_os = "linux", target_os = "android", target_os = "freebsd"))]
         {
             unsafe extern "C" {
-                safe fn on_before_reload_process_linux();
+                safe fn on_before_reload_process_posix();
             }
-            on_before_reload_process_linux();
+            on_before_reload_process_posix();
         }
 
         // We clone argv so that the memory address isn't the same as the libc one.
diff --git a/src/clap/comptime.rs b/src/clap/comptime.rs
index 82b7b02453bb..81a1ae7d846b 100644
--- a/src/clap/comptime.rs
+++ b/src/clap/comptime.rs
@@ -543,6 +543,7 @@ impl<Id> ComptimeClap<Id> {
             diagnostic: opt.diagnostic,
             state: streaming::State::Normal,
             positional: None,
+            short_aliases: opt.short_aliases,
         };
 
         while let Some(arg) = stream.next()? {
diff --git a/src/clap/lib.rs b/src/clap/lib.rs
index ad9651910f29..9e1f9bc8d545 100644
--- a/src/clap/lib.rs
+++ b/src/clap/lib.rs
@@ -374,6 +374,10 @@ impl Default for Help {
 pub struct ParseOptions<'a> {
     pub diagnostic: Option<&'a mut Diagnostic>,
     pub stop_after_positional_at: usize,
+    /// Whole-token rewrites applied only where a token is being classified as a
+    /// flag, never to an option's value or a `--` target. Node keeps its own
+    /// aliases on exactly that branch (node_options-inl.h).
+    pub short_aliases: &'static [(&'static [u8], &'static [u8])],
 }
 
 // Help/usage/error rendering — none of this is on the cold-start hot chain
@@ -455,6 +459,7 @@ pub fn parse<Id: 'static>(
         ParseOptions {
             diagnostic: opt.diagnostic,
             stop_after_positional_at: opt.stop_after_positional_at,
+            short_aliases: opt.short_aliases,
         },
     )?;
     Ok(Args { clap })
@@ -474,6 +479,7 @@ pub fn parse_with_table<Id: 'static>(
         ParseOptions {
             diagnostic: opt.diagnostic,
             stop_after_positional_at: opt.stop_after_positional_at,
+            short_aliases: opt.short_aliases,
         },
     )?;
     Ok(Args { clap })
diff --git a/src/clap/streaming.rs b/src/clap/streaming.rs
index d495f549dba2..d7f59518e819 100644
--- a/src/clap/streaming.rs
+++ b/src/clap/streaming.rs
@@ -62,6 +62,7 @@ pub struct StreamingClap<'p, 'a, Id, ArgIterator> {
     pub(crate) state: State<'a>,
     pub(crate) positional: Option<&'p clap::Param<Id>>,
     pub(crate) diagnostic: Option<&'p mut clap::Diagnostic>,
+    pub(crate) short_aliases: &'static [(&'static [u8], &'static [u8])],
 }
 
 // ArgIterator is the
@@ -301,9 +302,20 @@ where
     }
 
     fn parse_next_arg(&mut self) -> Result<Option<ArgInfo<'a>>, ArgError> {
-        let Some(full_arg) = self.iter.next() else {
+        let Some(mut full_arg) = self.iter.next() else {
             return Ok(None);
         };
+        // Only flag-shaped tokens reach here (option values and `--` targets are pulled straight
+        // off `iter`); restrict rewrites so a mapping never touches `-`/`--` or a positional,
+        // per the contract on `ParseOptions::short_aliases`.
+        if full_arg.starts_with(b"-") && full_arg != b"-" && full_arg != b"--" {
+            for (from, to) in self.short_aliases {
+                if full_arg == *from {
+                    full_arg = to;
+                    break;
+                }
+            }
+        }
         if full_arg == b"--" || full_arg == b"-" {
             return Ok(Some(ArgInfo {
                 arg: full_arg,
@@ -355,6 +367,7 @@ mod tests {
             remain: args_strings,
         };
         let mut c = StreamingClap::<u8, args::SliceIterator> {
+            short_aliases: &[],
             params,
             iter: &mut iter,
             state: State::Normal,
@@ -387,6 +400,7 @@ mod tests {
             remain: args_strings,
         };
         let mut c = StreamingClap::<u8, args::SliceIterator> {
+            short_aliases: &[],
             params,
             iter: &mut iter,
             state: State::Normal,
diff --git a/src/codegen/class-definitions.ts b/src/codegen/class-definitions.ts
index 8262c5d5ad80..7d4d45885d5b 100644
--- a/src/codegen/class-definitions.ts
+++ b/src/codegen/class-definitions.ts
@@ -152,6 +152,11 @@ export class ClassDefinition {
    * The instances of this class are intended to be inside the this of a bound function.
    */
   forBind?: boolean;
+  /**
+   * Parent of the generated prototype object. "Error" puts Error.prototype in
+   * the chain so instances satisfy `instanceof Error`. Default: Object.prototype.
+   */
+  prototypeBase?: "Error";
   /**
    * ## IMPORTANT
    * You _must_ free the pointer to your native class!
diff --git a/src/codegen/generate-classes.ts b/src/codegen/generate-classes.ts
index 597488d29103..2bdc56702971 100644
--- a/src/codegen/generate-classes.ts
+++ b/src/codegen/generate-classes.ts
@@ -1794,7 +1794,13 @@ ${
 
 JSObject* ${name}::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
 {
-    auto *structure = ${prototypeName(typeName)}::createStructure(vm, globalObject, ${obj.forBind ? "globalObject->functionPrototype()" : "globalObject->objectPrototype()"});
+    auto *structure = ${prototypeName(typeName)}::createStructure(vm, globalObject, ${
+      obj.forBind
+        ? "globalObject->functionPrototype()"
+        : obj.prototypeBase === "Error"
+          ? "globalObject->errorPrototype()"
+          : "globalObject->objectPrototype()"
+    });
     structure->setMayBePrototype(true);
     return ${prototypeName(typeName)}::create(vm, globalObject, structure);
 }
diff --git a/src/errno/lib.rs b/src/errno/lib.rs
index a166bc9d8e82..09e327f8bf72 100644
--- a/src/errno/lib.rs
+++ b/src/errno/lib.rs
@@ -45,36 +45,36 @@ macro_rules! __decl_uv_e {
     ( $( $ident:ident = $value:expr => $display:literal ),+ $(,)? ) => {
         $( pub const $ident: i32 = $value; )+
 
-        /// Negated libuv error code (`-UV_E*`) → user-visible name.
-        /// `None` for unmapped values (caller falls back to
-        /// `"Unknown system error N"`). Input is the raw signed value as
-        /// returned to JS — i.e. `-uv_e::FOO`.
+        /// Full (negated code, name) table: libuv-synthetic codes (vendor/libuv/include/uv/errno.h)
+        /// first, then per-OS rows. Consumed by `name()` and node:util `getSystemErrorMap()`.
+        pub static ENTRIES: &[(i32, &'static str)] = &[
+            (-4095, "EOF"),
+            (-4094, "UNKNOWN"),
+            (-3000, "EAI_ADDRFAMILY"),
+            (-3001, "EAI_AGAIN"),
+            (-3002, "EAI_BADFLAGS"),
+            (-3003, "EAI_CANCELED"),
+            (-3004, "EAI_FAIL"),
+            (-3005, "EAI_FAMILY"),
+            (-3006, "EAI_MEMORY"),
+            (-3007, "EAI_NODATA"),
+            (-3008, "EAI_NONAME"),
+            (-3009, "EAI_OVERFLOW"),
+            (-3010, "EAI_SERVICE"),
+            (-3011, "EAI_SOCKTYPE"),
+            (-3013, "EAI_BADHINTS"),
+            (-3014, "EAI_PROTOCOL"),
+            $( (-($ident), $display) ),+
+        ];
+
+        /// Negated libuv error code (`-UV_E*`) → user-visible name. `None` for unmapped values.
+        /// First match wins, mirroring the old `if`-chain's duplicate tolerance (EAGAIN aliases).
         pub fn name(neg_uv_err: i32) -> Option<&'static str> {
-            // Target-independent libuv-synthetic codes (no `uv_e::*` const).
-            // Values from vendor/libuv/include/uv/errno.h.
-            match neg_uv_err {
-                -4095 => return Some("EOF"),
-                -4094 => return Some("UNKNOWN"),
-                -3000 => return Some("EAI_ADDRFAMILY"),
-                -3001 => return Some("EAI_AGAIN"),
-                -3002 => return Some("EAI_BADFLAGS"),
-                -3003 => return Some("EAI_CANCELED"),
-                -3004 => return Some("EAI_FAIL"),
-                -3005 => return Some("EAI_FAMILY"),
-                -3006 => return Some("EAI_MEMORY"),
-                -3007 => return Some("EAI_NODATA"),
-                -3008 => return Some("EAI_NONAME"),
-                -3009 => return Some("EAI_OVERFLOW"),
-                -3010 => return Some("EAI_SERVICE"),
-                -3011 => return Some("EAI_SOCKTYPE"),
-                -3013 => return Some("EAI_BADHINTS"),
-                -3014 => return Some("EAI_PROTOCOL"),
-                _ => {}
+            for &(code, name) in ENTRIES {
+                if code == neg_uv_err {
+                    return Some(name);
+                }
             }
-            // Per-OS rows. `if`-chain (not `match`) because two `$value`s may
-            // resolve to the same integer on some targets (e.g. EAGAIN ==
-            // EWOULDBLOCK), which `match` rejects as an unreachable pattern.
-            $( if neg_uv_err == -($ident) { return Some($display); } )+
             None
         }
     };
diff --git a/src/event_loop/ConcurrentTask.rs b/src/event_loop/ConcurrentTask.rs
index e15d4a72aad8..d566c0245c3c 100644
--- a/src/event_loop/ConcurrentTask.rs
+++ b/src/event_loop/ConcurrentTask.rs
@@ -98,6 +98,7 @@ pub mod task_tag {
         GetAddrInfoRequestTask,
         GetAddrInfoLibuvComplete,
         HotReloadTask,
+        WatchReloadTask,
         ImmediateObject,
         JSBundleCompletionTask,
         JSCDeferredWorkTask,
diff --git a/src/event_loop/lib.rs b/src/event_loop/lib.rs
index cd48a014ae4e..35194cd85e6a 100644
--- a/src/event_loop/lib.rs
+++ b/src/event_loop/lib.rs
@@ -60,6 +60,7 @@ bun_dispatch::link_interface! {
         fn exit();
         fn enqueue_task(task: Task);
         fn enqueue_task_concurrent(task: core::ptr::NonNull<ConcurrentTask::ConcurrentTask>);
+        fn concurrent_poster_end();
         fn env() -> *mut bun_dotenv::Loader;
         fn top_level_dir() -> *const [u8];
         fn create_null_delimited_env_map() -> Result<bun_dotenv::NullDelimitedEnvMap, bun_core::AllocError>;
diff --git a/src/install/PackageManager/CommandLineArguments.rs b/src/install/PackageManager/CommandLineArguments.rs
index a5bdc7f0883d..5b94b3c465c5 100644
--- a/src/install/PackageManager/CommandLineArguments.rs
+++ b/src/install/PackageManager/CommandLineArguments.rs
@@ -1002,6 +1002,7 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/pm#scan<r>.
             clap::ParseOptions {
                 diagnostic: Some(&mut diag),
                 stop_after_positional_at: 0,
+                ..Default::default()
             },
         ) {
             Ok(a) => {
diff --git a/src/js/builtins/CommonJS.ts b/src/js/builtins/CommonJS.ts
index 31d0360d17ba..7e2bf3eaa432 100644
--- a/src/js/builtins/CommonJS.ts
+++ b/src/js/builtins/CommonJS.ts
@@ -149,13 +149,10 @@ export function requireResolve(
   id: string,
   options: { paths?: string[] } = {},
 ) {
-  return $resolveSync(
-    id,
-    typeof this === "string" ? this : (this?.filename ?? this?.id ?? ""),
-    false,
-    true,
-    options ? options.paths : undefined,
-  );
+  // Only `options.paths` extraction happens here; builtin bypass and paths
+  // validation are native (functionImportMeta__resolveSyncPrivate).
+  const paths = typeof options === "object" && options !== null ? options.paths : undefined;
+  return $resolveSync(id, typeof this === "string" ? this : (this?.filename ?? this?.id ?? ""), false, true, paths);
 }
 
 $visibility = "Private";
diff --git a/src/js/builtins/ConsoleObject.ts b/src/js/builtins/ConsoleObject.ts
index 2ee129a587b8..830676866b24 100644
--- a/src/js/builtins/ConsoleObject.ts
+++ b/src/js/builtins/ConsoleObject.ts
@@ -155,19 +155,12 @@ export function createConsoleConstructor(console: typeof globalThis.console) {
   const StringPrototypeRepeat = String.prototype.repeat;
   const StringPrototypeSlice = String.prototype.slice;
   const ObjectPrototypeHasOwnProperty = Object.prototype.hasOwnProperty;
-  const StringPrototypePadStart = String.prototype.padStart;
-  const StringPrototypeSplit = String.prototype.split;
-  const NumberPrototypeToFixed = Number.prototype.toFixed;
   const ArrayPrototypeMap = Array.prototype.map;
   const ArrayPrototypeJoin = Array.prototype.join;
   const ArrayPrototypePush = Array.prototype.push;
 
   const kCounts = Symbol("counts");
 
-  const kSecond = 1000;
-  const kMinute = 60 * kSecond;
-  const kHour = 60 * kMinute;
-
   const internalGetStringWidth = $newCppFunction("stringWidth.cpp", "jsFunctionBunStringWidth", 1);
 
   /**
@@ -762,39 +755,7 @@ export function createConsoleConstructor(console: typeof globalThis.console) {
     return true;
   }
 
-  function pad(value) {
-    return StringPrototypePadStart.$call(`${value}`, 2, "0");
-  }
-
-  function formatTime(ms) {
-    let hours = 0;
-    let minutes = 0;
-    let seconds: string | number = 0;
-
-    if (ms >= kSecond) {
-      if (ms >= kMinute) {
-        if (ms >= kHour) {
-          hours = Math.floor(ms / kHour);
-          ms = ms % kHour;
-        }
-        minutes = Math.floor(ms / kMinute);
-        ms = ms % kMinute;
-      }
-      seconds = ms / kSecond;
-    }
-
-    if (hours !== 0 || minutes !== 0) {
-      ({ 0: seconds, 1: ms } = (StringPrototypeSplit.$call as any)(NumberPrototypeToFixed.$call(seconds, 3), "."));
-      const res = hours !== 0 ? `${hours}:${pad(minutes)}` : minutes;
-      return `${res}:${pad(seconds)}.${ms} (${hours !== 0 ? "h:m" : ""}m:ss.mmm)`;
-    }
-
-    if (seconds !== 0) {
-      return `${NumberPrototypeToFixed.$call(seconds, 3)}s`;
-    }
-
-    return `${Number(NumberPrototypeToFixed.$call(ms, 3))}ms`;
-  }
+  const { formatTime } = require("internal/util/debuglog");
 
   const keyKey = "Key";
   const valuesKey = "Values";
diff --git a/src/js/builtins/Ipc.ts b/src/js/builtins/Ipc.ts
index 00ce544b6e94..ec1c567c253c 100644
--- a/src/js/builtins/Ipc.ts
+++ b/src/js/builtins/Ipc.ts
@@ -117,3 +117,26 @@ export function parseHandle(target, serialized, fd) {
     }
   }
 }
+
+/**
+ * Advanced-mode IPC Buffer tagging; the mechanism lives in
+ * internal/serialization_buffers (shared with node:v8 serialize/deserialize).
+ * Returns null when the message holds no Buffers so the caller keeps the bare
+ * wire format (and its zero-walk ack fast paths).
+ *
+ * @param {unknown} message
+ * @returns {[unknown, unknown[]] | null}
+ */
+export function tagAdvancedBuffers(message) {
+  return require("internal/serialization_buffers").tagBuffers(message);
+}
+
+/**
+ * Receive side of tagAdvancedBuffers.
+ *
+ * @param {unknown} envelope
+ * @returns {unknown}
+ */
+export function restoreAdvancedBuffers(envelope) {
+  return require("internal/serialization_buffers").restoreBuffers(envelope);
+}
diff --git a/src/js/internal-for-testing.ts b/src/js/internal-for-testing.ts
index 195adde6a905..fc2c973a7529 100644
--- a/src/js/internal-for-testing.ts
+++ b/src/js/internal-for-testing.ts
@@ -243,6 +243,217 @@ export const isolatedModuleCacheSourceType: (specifier: string) => string | null
 );
 export const Dequeue = require("internal/fifo");
 
+// node lib/internal/util.js normalizeEncoding: nullish and '' mean utf8, and
+// non-strings are undefined; Bun's Rust binding does not fold 'utf-16le',
+// so the node edge cases are handled here.
+const rustNormalizeEncoding = $newRustFunction("node_util_binding.rs", "normalizeEncoding", 1);
+const nodeKEmptyObject = require("internal/shared").kEmptyObject;
+function nodeNormalizeEncoding(enc) {
+  if (enc == null) return "utf8";
+  if (typeof enc !== "string") return undefined;
+  const lower = enc.toLowerCase();
+  if (lower === "utf-16le") return "utf16le";
+  // The Rust map also accepts Buffer-only names node's normalizeEncoding rejects.
+  if (lower === "buffer" || lower === "utf16-le") return undefined;
+  return rustNormalizeEncoding(enc);
+}
+
+// Verbatim from node lib/internal/util.js (countBinaryOnes/getCIDR).
+function countBinaryOnes(n) {
+  // Count the number of bits set in parallel, which is faster than looping
+  n = n - ((n >>> 1) & 0x55555555);
+  n = (n & 0x33333333) + ((n >>> 2) & 0x33333333);
+  return (((n + (n >>> 4)) & 0xf0f0f0f) * 0x1010101) >>> 24;
+}
+
+function getCIDR(address, netmask, family) {
+  let ones = 0;
+  let split = ".";
+  let range = 10;
+  let groupLength = 8;
+  let hasZeros = false;
+  let lastPos = 0;
+
+  if (family === "IPv6") {
+    split = ":";
+    range = 16;
+    groupLength = 16;
+  }
+
+  for (let i = 0; i < netmask.length; i++) {
+    if (netmask[i] !== split) {
+      if (i + 1 < netmask.length) {
+        continue;
+      }
+      i++;
+    }
+    const part = netmask.slice(lastPos, i);
+    lastPos = i + 1;
+    if (part !== "") {
+      if (hasZeros) {
+        if (part !== "0") {
+          return null;
+        }
+      } else {
+        const binary = parseInt(part, range);
+        const binaryOnes = countBinaryOnes(binary);
+        ones += binaryOnes;
+        if (binaryOnes !== groupLength) {
+          if (binary.toString(2).includes("01")) {
+            return null;
+          }
+          hasZeros = true;
+        }
+      }
+    }
+  }
+
+  return `${address}/${ones}`;
+}
+
+// Verbatim from node lib/internal/util.js assignFunctionName (assert -> throw).
+function assignFunctionName(name, fn, descriptor = nodeKEmptyObject) {
+  if (typeof name !== "string") {
+    const symbolDescription = name.description;
+    if (symbolDescription === undefined) throw new Error("Attempted to name function after descriptionless Symbol");
+    name = `[${symbolDescription}]`;
+  }
+  return Object.defineProperty(fn, "name", {
+    __proto__: null,
+    writable: false,
+    enumerable: false,
+    configurable: true,
+    ...Object.getOwnPropertyDescriptor(fn, "name"),
+    ...descriptor,
+    value: name,
+  });
+}
+
+function nodeIsError(e) {
+  return require("node:util/types").isNativeError(e) || e instanceof Error;
+}
+
+// node's internal WeakReference: a WeakRef that pins the target strongly
+// while its refcount is above zero.
+class WeakReference {
+  #ref;
+  #strong = null;
+  #refCount = 0;
+  constructor(object) {
+    this.#ref = new WeakRef(object);
+  }
+  get() {
+    // Serving from the pinned ref (when held) is equivalent to deref() and
+    // keeps the keepalive member read, not write-only.
+    return this.#strong ?? this.#ref.deref();
+  }
+  incRef() {
+    if (++this.#refCount === 1) this.#strong = this.#ref.deref();
+  }
+  decRef() {
+    if (--this.#refCount === 0) this.#strong = null;
+  }
+}
+
+// node's internal/child_process.getValidStdio, ported verbatim except that
+// bun has no Pipe/TTY/TCP handle wraps: pipe entries get a closeable stand-in
+// handle and wrap detection is omitted (throws ERR_INVALID_ARG_VALUE instead).
+function stdioStringToArray(stdio, channel?) {
+  const options: (string | number)[] = [];
+  switch (stdio) {
+    case "ignore":
+    case "overlapped":
+    case "pipe":
+      options.push(stdio, stdio, stdio);
+      break;
+    case "inherit":
+      options.push(0, 1, 2);
+      break;
+    default:
+      throw $ERR_INVALID_ARG_VALUE("stdio", stdio);
+  }
+  if (channel) options.push(channel);
+  return options;
+}
+
+function makeCodedError(Base: ErrorConstructor, code: string, message: string) {
+  const err = new Base(message) as Error & { code: string };
+  err.code = code;
+  return err;
+}
+
+function nodeGetValidStdio(stdio, sync?) {
+  const { isArrayBufferView } = require("node:util/types");
+  let ipc;
+  let ipcFd;
+
+  if (typeof stdio === "string") {
+    stdio = stdioStringToArray(stdio);
+  } else if (!Array.isArray(stdio)) {
+    throw $ERR_INVALID_ARG_VALUE("stdio", stdio);
+  }
+
+  while (stdio.length < 3) stdio.push(undefined);
+
+  stdio = stdio.reduce(function reduceStdioEntry(acc, stdio, i) {
+    function cleanup() {
+      for (let i = 0; i < acc.length; i++) {
+        if ((acc[i].type === "pipe" || acc[i].type === "ipc") && acc[i].handle) acc[i].handle.close();
+      }
+    }
+
+    stdio ??= i < 3 ? "pipe" : "ignore";
+
+    if (stdio === "ignore") {
+      acc.push({ type: "ignore" });
+    } else if (stdio === "pipe" || stdio === "overlapped" || (typeof stdio === "number" && stdio < 0)) {
+      const a: Record<string, unknown> = {
+        type: stdio === "overlapped" ? "overlapped" : "pipe",
+        readable: i === 0,
+        writable: i !== 0,
+      };
+      // node: `a.handle = new Pipe(PipeConstants.SOCKET)`; bun has no Pipe wrap.
+      if (!sync) a.handle = { close() {} };
+      acc.push(a);
+    } else if (stdio === "ipc") {
+      if (sync || ipc !== undefined) {
+        cleanup();
+        if (!sync) throw $ERR_IPC_ONE_PIPE();
+        else throw makeCodedError(Error, "ERR_IPC_SYNC_FORK", "IPC cannot be used with synchronous forks");
+      }
+      ipc = { close() {} };
+      ipcFd = i;
+      acc.push({ type: "pipe", handle: ipc, ipc: true });
+    } else if (stdio === "inherit") {
+      acc.push({ type: "inherit", fd: i });
+    } else if (typeof stdio === "number") {
+      acc.push({ type: "fd", fd: stdio });
+    } else if (typeof stdio.fd === "number") {
+      const { fd } = stdio;
+      acc.push({ type: "fd", fd });
+    } else if (isArrayBufferView(stdio) || typeof stdio === "string") {
+      if (!sync) {
+        cleanup();
+        const inspected = require("node:util").inspect(stdio);
+        throw makeCodedError(
+          TypeError,
+          "ERR_INVALID_SYNC_FORK_INPUT",
+          `Asynchronous forks do not support Buffer, TypedArray, DataView or string input: ${inspected}`,
+        );
+      }
+    } else {
+      cleanup();
+      throw $ERR_INVALID_ARG_VALUE("stdio", stdio);
+    }
+
+    return acc;
+  }, []);
+
+  return { stdio, ipc, ipcFd };
+}
+
+let cachedInternalChildProcess;
+
 // Userland access to node-internal modules for vendored node tests that
 // declare `// Flags: --expose-internals` (served via the require interceptor
 // in test/js/node/test/common/index.js). Static requires only — the builtin
@@ -250,14 +461,53 @@ export const Dequeue = require("internal/fifo");
 // vendored tests need more internals.
 export const exposedInternals = {
   "internal/streams/add-abort-signal": require("internal/streams/add-abort-signal"),
+  "internal/util/debuglog": require("internal/util/debuglog"),
   "internal/async_context_frame": require("internal/async_context_frame"),
   "internal/async_hooks": require("internal/async_hooks"),
   "internal/webstreams/adapters": require("internal/webstreams_adapters"),
   "internal/dgram": require("internal/dgram"),
+  // Bun's real implementations, under the names node's tests import them by.
+  "internal/validators": require("internal/validators"),
+  "internal/util/inspect": require("internal/util/inspect"),
+  "internal/freelist": require("internal/freelist"),
   // Node's internal/fixed_queue module IS the FixedQueue class.
   "internal/fixed_queue": require("internal/fixed_queue").FixedQueue,
-  "internal/freelist": require("internal/freelist"),
-  "internal/validators": require("internal/validators"),
+  "internal/assert/myers_diff": require("internal/assert/myers_diff"),
+  // Bun's internal/errors only carries aggregateTwoErrors; the ERR_* hierarchy
+  // is native, not a JS `codes` table, so nothing else is exposed here.
+  "internal/errors": require("internal/errors"),
+  // normalizeEncoding wraps the same Rust binding node:crypto and the
+  // webstream adapters call; the rest are node's own JS helpers, ported
+  // verbatim from lib/internal/util.js where Bun has no native equivalent.
+  "internal/util": {
+    normalizeEncoding: nodeNormalizeEncoding,
+    // Bun always has crypto support compiled in.
+    assertCrypto() {},
+    getCIDR,
+    isError: nodeIsError,
+    assignFunctionName,
+    kEnumerableProperty: Object.freeze({ __proto__: null, enumerable: true }),
+    kEmptyObject: nodeKEmptyObject,
+    WeakReference,
+  },
+  // Bun's EventTarget/Event/CustomEvent are the native (global) ones; node
+  // keeps them in internal/event_target. kWeakHandler is Bun's real weak
+  // listener symbol from internal/shared. Bun has no NodeEventTarget.
+  "internal/event_target": {
+    Event: globalThis.Event,
+    CustomEvent: globalThis.CustomEvent,
+    EventTarget: globalThis.EventTarget,
+    kWeakHandler: require("internal/shared").kWeakHandler,
+  },
+  // ChildProcess is the real class exec()/spawn() instantiate, so vendored
+  // tests can monkeypatch its prototype; getValidStdio is ported from node.
+  // A getter so loading this module does not eagerly pull in child_process.
+  get "internal/child_process"() {
+    return (cachedInternalChildProcess ??= {
+      ChildProcess: require("node:child_process").ChildProcess,
+      getValidStdio: nodeGetValidStdio,
+    });
+  },
   "internal/fs/utils": {
     // Both are the REAL parsers the fs entry points use (FileSystemFlags::from_js
     // and args::Rm::from_js), not JS reimplementations -- vendored tests assert
diff --git a/src/js/internal/assert/assertion_error.ts b/src/js/internal/assert/assertion_error.ts
index 1890b9320888..7791919380c3 100644
--- a/src/js/internal/assert/assertion_error.ts
+++ b/src/js/internal/assert/assertion_error.ts
@@ -1,5 +1,6 @@
 "use strict";
 
+const { SafeSet } = require("internal/primordials");
 const { inspect } = require("internal/util/inspect");
 const colors = require("internal/util/colors");
 const { validateObject } = require("internal/validators");
@@ -46,11 +47,14 @@ const kReadableOperator = {
   notDeepEqual: 'Expected "actual" not to be loosely deep-equal to:',
   notIdentical: "Values have same structure but are not reference-equal:",
   notDeepEqualUnequal: "Expected values not to be loosely deep-equal:",
+  partialDeepStrictEqual: "Expected values to be partially and strictly deep-equal:",
 };
 
 const kMaxShortStringLength = 12;
 const kMaxLongStringLength = 512;
 
+const kMethodsWithCustomMessageDiff = new SafeSet(["deepStrictEqual", "strictEqual", "partialDeepStrictEqual"]);
+
 function copyError(source) {
   const target = ObjectAssign({ __proto__: ObjectGetPrototypeOf(source) }, source);
   ObjectDefineProperty(target, "message", {
@@ -184,7 +188,7 @@ function isSimpleDiff(actual, inspectedActual, expected, inspectedExpected) {
   return typeof actual !== "object" || actual === null || typeof expected !== "object" || expected === null;
 }
 
-function createErrDiff(actual, expected, operator, customMessage) {
+function createErrDiff(actual, expected, operator, customMessage, diffType = "simple") {
   operator = checkOperator(actual, expected, operator);
 
   let skipped = false;
@@ -209,7 +213,7 @@ function createErrDiff(actual, expected, operator, customMessage) {
   } else if (inspectedActual === inspectedExpected) {
     // Handles the case where the objects are structurally the same but different references
     operator = "notIdentical";
-    if (inspectedSplitActual.length > 50) {
+    if (inspectedSplitActual.length > 50 && diffType !== "full") {
       message = `${ArrayPrototypeJoin.$call(ArrayPrototypeSlice.$call(inspectedSplitActual, 0, 50), "\n")}\n...}`;
       skipped = true;
     } else {
@@ -271,6 +275,7 @@ class AssertionError extends Error {
       details,
       // Compatibility with older versions.
       stackStartFunction,
+      diff = "simple",
     } = options;
     let { actual, expected } = options;
 
@@ -279,8 +284,8 @@ class AssertionError extends Error {
     Error.stackTraceLimit = 0;
 
     if (message != null) {
-      if (operator === "deepStrictEqual" || operator === "strictEqual") {
-        super(createErrDiff(actual, expected, operator, message));
+      if (kMethodsWithCustomMessageDiff.has(operator)) {
+        super(createErrDiff(actual, expected, operator, message, diff));
       } else {
         super(String(message));
       }
@@ -305,8 +310,8 @@ class AssertionError extends Error {
         expected = copyError(expected);
       }
 
-      if (operator === "deepStrictEqual" || operator === "strictEqual") {
-        super(createErrDiff(actual, expected, operator, message));
+      if (kMethodsWithCustomMessageDiff.has(operator)) {
+        super(createErrDiff(actual, expected, operator, message, diff));
       } else if (operator === "notDeepStrictEqual" || operator === "notStrictEqual") {
         // In case the objects are equal but the operator requires unequal, show
         // the first object and say A equals B
@@ -323,9 +328,8 @@ class AssertionError extends Error {
         }
 
         // Only remove lines in case it makes sense to collapse those.
-        // TODO: Accept env to always show the full error.
         const resLength = res.length;
-        if (resLength > 50) {
+        if (resLength > 50 && diff !== "full") {
           res[46] = `${colors.blue}...${colors.white}`;
           while (res.length > 47) {
             ArrayPrototypePop.$call(res);
@@ -344,15 +348,15 @@ class AssertionError extends Error {
         const knownOperator = kReadableOperator[operator];
         if (operator === "notDeepEqual" && res === other) {
           res = `${knownOperator}\n\n${res}`;
-          if (res.length > 1024) {
+          if (res.length > 1024 && diff !== "full") {
             res = `${StringPrototypeSlice.$call(res, 0, 1021)}...`;
           }
           super(res);
         } else {
-          if (res.length > kMaxLongStringLength) {
+          if (res.length > kMaxLongStringLength && diff !== "full") {
             res = `${StringPrototypeSlice.$call(res, 0, 509)}...`;
           }
-          if (other.length > kMaxLongStringLength) {
+          if (other.length > kMaxLongStringLength && diff !== "full") {
             other = `${StringPrototypeSlice.$call(other, 0, 509)}...`;
           }
           if (operator === "deepEqual") {
@@ -409,6 +413,7 @@ class AssertionError extends Error {
     this.stack; // eslint-disable-line no-unused-expressions
     // Reset the name.
     this.name = "AssertionError";
+    this.diff = diff;
   }
 
   toString() {
diff --git a/src/js/internal/fs/streams.ts b/src/js/internal/fs/streams.ts
index dabec824b251..37c061993518 100644
--- a/src/js/internal/fs/streams.ts
+++ b/src/js/internal/fs/streams.ts
@@ -384,7 +384,10 @@ function WriteStream(this: FSStream, path: string | null, options?: any): void {
   if (fd == null) {
     this[kFs] = customFs || fs;
     this.fd = null;
-    this.path = getValidatedPath(path);
+    // Internal $fastPath callers (writableFromFileSink) discard .path; do not
+    // resolve it - path.resolve("") needs process.cwd(), which throws when
+    // the cwd has been deleted (Node still spawns children in that state).
+    this.path = fastPath ? path : getValidatedPath(path);
     const { flags, mode } = options;
     this.flags = flags === undefined ? "w" : flags;
     this.mode = mode === undefined ? 0o666 : mode;
diff --git a/src/js/internal/serialization_buffers.ts b/src/js/internal/serialization_buffers.ts
new file mode 100644
index 000000000000..e674acb0a994
--- /dev/null
+++ b/src/js/internal/serialization_buffers.ts
@@ -0,0 +1,71 @@
+// Buffer tagging for JSC-serialized transports (advanced IPC, node:v8). JSC has no host-object hook,
+// so we ship a [value, buffers] envelope (identity-aliased) and restore Buffer prototypes on receive.
+// Node ref: https://github.com/nodejs/node/blob/main/lib/internal/child_process/serialization.js
+
+const { Buffer } = require("node:buffer");
+const BufferPrototype = Buffer.prototype;
+const isBuffer = Buffer.isBuffer;
+const ObjectKeys = Object.keys;
+const ObjectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+const ObjectSetPrototypeOf = Object.setPrototypeOf;
+const ObjectPrototypeHasOwnProperty = Object.prototype.hasOwnProperty;
+const SafeSet = Set;
+
+/** Returns null when `value` holds no Buffers, else the [value, buffers] envelope. */
+function tagBuffers(value: unknown): [unknown, unknown[]] | null {
+  let buffers: unknown[] | null = null;
+  let visited: Set<object> | null = null;
+  const stack = [value];
+  while (stack.length !== 0) {
+    const current = stack[stack.length - 1];
+    stack.length--;
+    if (current === null || typeof current !== "object") continue;
+    visited ??= new SafeSet();
+    if (visited.$has(current)) continue;
+    visited.$add(current);
+    if ($isTypedArrayView(current)) {
+      if (isBuffer(current)) $arrayPush((buffers ??= []), current);
+      // Other ArrayBuffer views round-trip with their type already.
+      continue;
+    }
+    if ($isMap(current)) {
+      current.$forEach((entry, key) => {
+        $arrayPush(stack, key);
+        $arrayPush(stack, entry);
+      });
+      continue;
+    }
+    if ($isSet(current)) {
+      current.$forEach(entry => $arrayPush(stack, entry));
+      continue;
+    }
+    // Objects, arrays and errors: the serializer walks own enumerable
+    // properties. Only data properties are descended so no getter runs here.
+    const keys = ObjectKeys(current);
+    for (let i = 0; i < keys.length; i++) {
+      const desc = ObjectGetOwnPropertyDescriptor(current, keys[i]);
+      if (desc && ObjectPrototypeHasOwnProperty.$call(desc, "value")) $arrayPush(stack, desc.value);
+    }
+  }
+  return buffers === null ? null : [value, buffers];
+}
+
+/**
+ * Receive side: restore the Buffer prototype on the envelope's aliased views
+ * and hand back the value. The envelope came off a wire or byte blob, so its
+ * shape is validated before it is trusted.
+ */
+function restoreBuffers(envelope: unknown): unknown {
+  if (!$isJSArray(envelope) || (envelope as unknown[]).length !== 2 || !$isJSArray((envelope as unknown[])[1])) {
+    throw new Error("failed to parse serialized buffer envelope");
+  }
+  const buffers = (envelope as unknown[])[1] as unknown[];
+  for (let i = 0; i < buffers.length; i++) {
+    const view = buffers[i];
+    // Fresh from deserialization: plain Uint8Arrays the sender tagged.
+    if ($isTypedArrayView(view)) ObjectSetPrototypeOf(view, BufferPrototype);
+  }
+  return (envelope as unknown[])[0];
+}
+
+export default { tagBuffers, restoreBuffers };
diff --git a/src/js/internal/shared.ts b/src/js/internal/shared.ts
index d8581d85d2c2..26eba1d3b031 100644
--- a/src/js/internal/shared.ts
+++ b/src/js/internal/shared.ts
@@ -147,6 +147,75 @@ function once(callback, { preserveReturnValue = false } = kEmptyObject) {
 
 const kEmptyObject = ObjectFreeze(Object.create(null));
 
+// Node invokes fs/dns callbacks via InternalMakeCallback, so a throw becomes uncaughtException
+// (not unhandledRejection); Bun runs them from a promise reaction so we reroute the throw.
+// https://github.com/nodejs/node/blob/main/src/api/callback.cc
+const reportUncaughtException = $newCppFunction("BunProcess.cpp", "jsFunctionReportUncaughtException", 1);
+
+// Wrap a node-style callback so a throw inside it takes the uncaught path. The
+// callback keeps its place in the event loop; only the throw is rerouted. The
+// arity switch avoids materializing `arguments` for the shapes fs and dns use.
+function guardCallback(callback) {
+  return function guarded(a, b, c) {
+    try {
+      switch (arguments.length) {
+        case 0:
+          return callback();
+        case 1:
+          return callback(a);
+        case 2:
+          return callback(a, b);
+        case 3:
+          return callback(a, b, c);
+        default:
+          return callback.$apply(undefined, arguments);
+      }
+    } catch (e) {
+      reportUncaughtException(e);
+    }
+  };
+}
+
+const nodeModulesRE = /[\\/]node_modules[\\/]/;
+const ErrorCaptureStackTrace = Error.captureStackTrace;
+function returnStackFrames(_err: unknown, frames: unknown[]) {
+  return frames;
+}
+
+// Port of node's IsInsideNodeModules: first real user frame inside node_modules?
+// Guarded so a tampered Error.* never escapes to callers like url.parse.
+// https://github.com/nodejs/node/blob/main/src/node_util.cc
+function isInsideNodeModules(frameLimit: number): boolean {
+  let prevLimit: unknown, prevPrepare: unknown;
+  let frames: { getFileName(): string | null }[] | undefined;
+  try {
+    prevLimit = Error.stackTraceLimit;
+    prevPrepare = Error.prepareStackTrace;
+    Error.stackTraceLimit = frameLimit;
+    Error.prepareStackTrace = returnStackFrames;
+    const target: { stack?: unknown } = {};
+    ErrorCaptureStackTrace(target, isInsideNodeModules);
+    frames = target.stack as typeof frames;
+  } catch {
+  } finally {
+    try {
+      Error.stackTraceLimit = prevLimit;
+      Error.prepareStackTrace = prevPrepare;
+    } catch {}
+  }
+  if (!$isJSArray(frames)) return false;
+  try {
+    for (const frame of frames) {
+      const filename = frame.getFileName();
+      if (!filename || filename.startsWith("node:") || filename.startsWith("internal:") || filename === "native") {
+        continue;
+      }
+      return nodeModulesRE.test(filename);
+    }
+  } catch {}
+  return false;
+}
+
 // Marks an addEventListener() options object so that dispatch still invokes the
 // listener after an unrelated listener called event.stopImmediatePropagation().
 // `$kResistStopPropagation` is a private symbol the native EventTarget reads, so
@@ -339,6 +408,9 @@ export default {
   ErrnoException,
   once,
   getLazy,
+  guardCallback,
+  isInsideNodeModules,
+  reportUncaughtException,
   resistStopPropagation,
 
   hasObserver,
diff --git a/src/js/internal/streams/end-of-stream.ts b/src/js/internal/streams/end-of-stream.ts
index e704256791c6..cfe3ff8f67f8 100644
--- a/src/js/internal/streams/end-of-stream.ts
+++ b/src/js/internal/streams/end-of-stream.ts
@@ -27,6 +27,7 @@ const PromisePrototypeThen = $Promise.prototype.$then;
 
 let addAbortListener;
 let AsyncResource;
+let enabledHooksExist;
 
 function isRequest(stream) {
   return stream.setHeader && typeof stream.abort === "function";
@@ -42,11 +43,13 @@ function bindAsyncResource(fn, type) {
   };
 }
 
-// Returns true when an AsyncLocalStorage context is currently active, in
-// which case eos() must snapshot it so the callback observes the context
-// from registration time (matching Node's AsyncContextFrame.current()).
+// True when an AsyncLocalStorage context is active (node's
+// AsyncContextFrame.current()) or createHook() hooks are enabled: eos() then
+// binds an AsyncResource so hooks see STREAM_END_OF_STREAM events.
 function hasAsyncContext() {
-  return $getInternalField($asyncContext, 0) !== undefined;
+  if ($getInternalField($asyncContext, 0) !== undefined) return true;
+  enabledHooksExist ??= require("internal/async_hooks").enabledHooksExist;
+  return enabledHooksExist();
 }
 
 /**
diff --git a/src/js/internal/streams/iter/utils.ts b/src/js/internal/streams/iter/utils.ts
index 1e4fd2b41f93..77c1453af41f 100644
--- a/src/js/internal/streams/iter/utils.ts
+++ b/src/js/internal/streams/iter/utils.ts
@@ -4,6 +4,12 @@ const { isUint8Array } = require("node:util/types");
 
 const { validateOneOf } = require("internal/validators");
 
+const ObjectGetPrototypeOf = Object.getPrototypeOf;
+const BufferPrototype = Buffer.prototype;
+// Node pools Buffer allocations smaller than half of Buffer.poolSize
+// (8192 >>> 1 = 4096 by default; see poolSize handling in node lib/buffer.js).
+const kBufferPoolBypassThreshold = Buffer.poolSize >>> 1;
+
 let isError;
 
 // Cached resolved promise to avoid allocating a new one on every sync fast-path.
@@ -112,10 +118,14 @@ function concatBytes(chunks) {
   // otherwise return a copy
   if (chunks.length === 1) {
     const chunk = chunks[0];
-    // If non-zero offset, skip the remaining buffer checks.
+    // Bun's Buffer.from has no shared pool, so emulate Node's split: Buffers below the pool
+    // threshold always copy; anything else covering its backing buffer is returned by identity.
+    // https://github.com/nodejs/node/blob/main/lib/buffer.js (Buffer.poolSize >>> 1)
     if (chunk.byteOffset === 0) {
-      // Works for both ArrayBuffer and SharedArrayBuffer backings.
-      if (chunk.byteLength === chunk.buffer.byteLength) {
+      const isSmallBuffer =
+        chunk.byteLength < kBufferPoolBypassThreshold && ObjectGetPrototypeOf(chunk) === BufferPrototype;
+      if (!isSmallBuffer && chunk.byteLength === chunk.buffer.byteLength) {
+        // Works for both ArrayBuffer and SharedArrayBuffer backings.
         return chunk;
       }
     }
diff --git a/src/js/internal/test/binding.ts b/src/js/internal/test/binding.ts
index 40747ad3a356..3b7919cc436c 100644
--- a/src/js/internal/test/binding.ts
+++ b/src/js/internal/test/binding.ts
@@ -40,6 +40,14 @@ class TestTCPWrap {
   }
 }
 
+const { isInsideNodeModules } = require("internal/shared");
+
+function safeGetenv(name: string) {
+  return process.env[name];
+}
+
+let cachedUvBinding: Record<string, unknown> | undefined;
+
 function internalBinding(name: string) {
   switch (name) {
     case "trace_events":
@@ -49,30 +57,67 @@ function internalBinding(name: string) {
         getCategoryEnabledBuffer: agent.getCategoryEnabledBuffer,
       };
     case "constants":
-      return {
-        trace: {
-          TRACE_EVENT_PHASE_NESTABLE_ASYNC_BEGIN: 98,
-          TRACE_EVENT_PHASE_NESTABLE_ASYNC_END: 101,
-        },
-      };
+      // The real thing: os/fs/crypto/zlib/trace sections, same object node's
+      // internalBinding("constants") exposes (ProcessBindingConstants.cpp).
+      return $processBindingConstants;
     case "quic":
       return require("internal/quic/binding");
-    // libuv error codes, the UDP handle wrap, and the minimal TCP wrap the
-    // vendored dgram tests consume.
-    case "uv":
-      // process.binding("uv") carries libuv's own codes on every platform
-      // (including Windows' synthetic ones), same as node's uv binding.
-      return process.binding("uv");
+    case "uv": {
+      // Add getErrorMessage (which node's uv binding exposes) derived from the same native uv_e
+      // table so messages can never diverge. Cached: node returns a stable object.
+      // https://github.com/nodejs/node/blob/main/src/uv.cc
+      if (cachedUvBinding === undefined) {
+        const errmap: Map<number, [string, string]> = require("node:util").getSystemErrorMap();
+        cachedUvBinding = {
+          ...process.binding("uv"),
+          getErrorMessage: function getErrorMessage(n: number) {
+            const entry = errmap.get(n);
+            return entry !== undefined ? entry[1] : `Unknown system error ${n}`;
+          },
+        };
+      }
+      return cachedUvBinding;
+    }
+    // node's credentials binding: without setuid/setgid mismatch handling,
+    // safeGetenv degenerates to a plain env read (same as node run normally).
+    case "credentials":
+      return { safeGetenv };
+    case "buffer": {
+      const { kMaxLength, kStringMaxLength } = require("node:buffer");
+      return { kMaxLength, kStringMaxLength };
+    }
     case "udp_wrap":
       return { UDP: require("internal/dgram").UDP };
     case "tcp_wrap":
       return { TCP: TestTCPWrap, constants: { SOCKET: 0, SERVER: 1 } };
+    case "util":
+      return { isInsideNodeModules };
     case "cares_wrap":
       // Only the pure IP-normalizer the vendored tls/dns tests reach for; the
       // resolver surface lives in node:dns.
       return { canonicalizeIP: require("bun:internal-for-testing").canonicalizeIP };
-    default:
-      throw new Error(`internalBinding("${name}") is not implemented in Bun`);
+    // The icu-era binding node exposed until nodejs/node#55156; vendored
+    // tests like test-icu-punycode still consume it.
+    case "icu": {
+      const icu = $cpp("NodeURL.cpp", "Bun::createNodeICUBinding");
+      // Node asked ICU's converter registry; answer from the runtime's
+      // encoding registry instead.
+      icu.hasConverter = function hasConverter(label: string) {
+        try {
+          new TextDecoder(label);
+          return true;
+        } catch {
+          return false;
+        }
+      };
+      return icu;
+    }
+    default: {
+      const err = new Error(`internalBinding("${name}") is not implemented in Bun`);
+      // node reports unknown/restricted bindings with this code.
+      (err as Error & { code: string }).code = "ERR_INVALID_MODULE";
+      throw err;
+    }
   }
 }
 
diff --git a/src/js/internal/util/comparisons.ts b/src/js/internal/util/comparisons.ts
new file mode 100644
index 000000000000..6ed38ed6c6bc
--- /dev/null
+++ b/src/js/internal/util/comparisons.ts
@@ -0,0 +1,9 @@
+// Deep-strict-equality helpers shared by node:assert and node:util.
+"use strict";
+
+// Native comparator: node semantics including [[Prototype]] identity.
+// Third arg truthy = skipPrototype (Assert class option, node's
+// kStrictWithoutPrototypes mode). node v26.3.0 exposes fn.length === 3.
+const isDeepStrictEqual = $newCppFunction("NodeUtilTypesModule.cpp", "jsFunctionIsDeepStrictEqual", 3);
+
+export default { isDeepStrictEqual };
diff --git a/src/js/internal/util/debuglog.ts b/src/js/internal/util/debuglog.ts
new file mode 100644
index 000000000000..57dd62fa14a1
--- /dev/null
+++ b/src/js/internal/util/debuglog.ts
@@ -0,0 +1,50 @@
+// Timing formatter shared by console.timeEnd/timeLog. Port of node v26.3.0
+// lib/internal/util/debuglog.js formatTime, with the prototype methods
+// captured at module load for tamper resistance.
+const kSecond = 1000;
+const kMinute = 60 * kSecond;
+const kHour = 60 * kMinute;
+
+const StringPrototypePadStart = String.prototype.padStart;
+const StringPrototypeSplit = String.prototype.split;
+const NumberPrototypeToFixed = Number.prototype.toFixed;
+const MathFloor = Math.floor;
+const NumberCtor = Number;
+
+function pad(value) {
+  return StringPrototypePadStart.$call(`${value}`, 2, "0");
+}
+
+function formatTime(ms: number) {
+  let hours = 0;
+  let minutes = 0;
+  let seconds: string | number = 0;
+
+  if (ms >= kSecond) {
+    if (ms >= kMinute) {
+      if (ms >= kHour) {
+        hours = MathFloor(ms / kHour);
+        ms = ms % kHour;
+      }
+      minutes = MathFloor(ms / kMinute);
+      ms = ms % kMinute;
+    }
+    seconds = ms / kSecond;
+  }
+
+  if (hours !== 0 || minutes !== 0) {
+    ({ 0: seconds, 1: ms } = StringPrototypeSplit.$call(NumberPrototypeToFixed.$call(seconds, 3), ".") as any);
+    const res = hours !== 0 ? `${hours}:${pad(minutes)}` : minutes;
+    return `${res}:${pad(seconds)}.${ms} (${hours !== 0 ? "h:m" : ""}m:ss.mmm)`;
+  }
+
+  if (seconds !== 0) {
+    return `${NumberPrototypeToFixed.$call(seconds, 3)}s`;
+  }
+
+  return `${NumberCtor(NumberPrototypeToFixed.$call(ms, 3))}ms`;
+}
+
+export default {
+  formatTime,
+};
diff --git a/src/js/internal/util/inspect.js b/src/js/internal/util/inspect.js
index e533c88c101d..e9055ab3caed 100644
--- a/src/js/internal/util/inspect.js
+++ b/src/js/internal/util/inspect.js
@@ -338,10 +338,6 @@ const validateObject = (value, name, allowArray = false) => {
     throw new codes.ERR_INVALID_ARG_TYPE(name, "Object", value);
 };
 
-function isURL(value) {
-  return typeof value.href === "string" && value instanceof URL;
-}
-
 const SymbolToPrimitive = Symbol.toPrimitive;
 
 const builtInObjects = new SafeSet(
@@ -1626,11 +1622,6 @@ function formatRaw(ctx, value, recurseTimes, typedArray) {
       if (keys.length === 0 && protoProps === undefined) {
         return base;
       }
-    } else if (isURL(value) && !(recurseTimes > ctx.depth && ctx.depth !== null)) {
-      base = value.href;
-      if (keys.length === 0 && protoProps === undefined) {
-        return base;
-      }
     } else {
       if (keys.length === 0 && protoProps === undefined) {
         if (isExternal(value)) {
@@ -2905,20 +2896,40 @@ function formatWithOptionsInternal(inspectOptions, args) {
   }
   return str;
 }
-const stripANSI = Bun.stripANSI;
 const internalGetStringWidth = $newCppFunction("stringWidth.cpp", "jsFunctionBunStringWidth", 1);
 /**
  * Returns the number of columns required to display the given string.
  */
+const kPerCodePointWidthOptions = { __proto__: null, perCodePoint: true, countAnsiEscapeCodes: true };
+
 function getStringWidth(str, removeControlChars = true) {
   if (removeControlChars) str = stripVTControlCharacters(str);
   str = StringPrototypeNormalize(str, "NFC");
-  return internalGetStringWidth(str);
-}
+  // node measures per code point, not grapheme clusters; ANSI was already stripped above.
+  // https://github.com/nodejs/node/blob/main/src/node_i18n.cc (GetColumnWidth)
+  return internalGetStringWidth(str, kPerCodePointWidthOptions);
+}
+
+// node's ansi matcher (from chalk/ansi-regex): only complete sequences are stripped —
+// Bun.stripANSI also eats bare/invalid ESC/CSI prefixes, which node keeps.
+// https://github.com/nodejs/node/blob/main/lib/internal/util/inspect.js
+const ansi = new RegExp(
+  "[\\u001B\\u009B][[\\]()#;?]*" +
+    "(?:(?:(?:(?:;[-a-zA-Z\\d\\/\\#&.:=?%@~_]+)*" +
+    "|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/\\#&.:=?%@~_]*)*)?" +
+    "(?:\\u0007|\\u001B\\u005C|\\u009C))" +
+    "|(?:(?:\\d{1,4}(?:;\\d{0,4})*)?" +
+    "[\\dA-PR-TZcf-nq-uy=><~]))",
+  "g",
+);
 
 function stripVTControlCharacters(str) {
   if (typeof str !== "string") throw new codes.ERR_INVALID_ARG_TYPE("str", "string", str);
-  return stripANSI(str);
+  // All ANSI escape sequences start with ESC (7-bit) or CSI (8-bit).
+  if (StringPrototypeIndexOf(str, "\u001B") === -1 && StringPrototypeIndexOf(str, "\u009B") === -1) {
+    return str;
+  }
+  return RegExpPrototypeSymbolReplace(ansi, str, "");
 }
 
 // utils
diff --git a/src/js/node/_tls_wrap.ts b/src/js/node/_tls_wrap.ts
new file mode 100644
index 000000000000..f5604fb2497c
--- /dev/null
+++ b/src/js/node/_tls_wrap.ts
@@ -0,0 +1,14 @@
+// Hardcoded module "node:_tls_wrap"
+// Mirrors node's lib/_tls_wrap.js: re-exports these four from node:tls and
+// emits DEP0192 once when the module is first required.
+
+const { TLSSocket, Server, createServer, connect } = require("node:tls");
+
+process.emitWarning("The _tls_wrap module is deprecated. Use `node:tls` instead.", "DeprecationWarning", "DEP0192");
+
+export default {
+  TLSSocket,
+  Server,
+  createServer,
+  connect,
+};
diff --git a/src/js/node/assert.ts b/src/js/node/assert.ts
index c96c78bff524..6e170654c5dc 100644
--- a/src/js/node/assert.ts
+++ b/src/js/node/assert.ts
@@ -21,48 +21,36 @@
 
 "use strict";
 
-const { SafeMap, SafeSet, SafeWeakSet } = require("internal/primordials");
-const {
-  isKeyObject,
-  isPromise,
-  isRegExp,
-  isMap,
-  isSet,
-  isDate,
-  isWeakSet,
-  isWeakMap,
-  isAnyArrayBuffer,
-} = require("node:util/types");
+const { isPromise, isRegExp } = require("node:util/types");
 const { innerOk } = require("internal/assert/utils");
-const { validateFunction } = require("internal/validators");
+const { validateFunction, validateOneOf } = require("internal/validators");
 
-const ArrayFrom = Array.from;
 const ArrayPrototypeIndexOf = Array.prototype.indexOf;
 const ArrayPrototypeJoin = Array.prototype.join;
 const ArrayPrototypePush = Array.prototype.push;
 const ArrayPrototypeSlice = Array.prototype.slice;
-const ArrayBufferIsView = ArrayBuffer.isView;
+// node's kPartial comparison, fully native (NodeUtilTypesModule.cpp).
+const nodePartialDeepStrictEqual = $newCppFunction("NodeUtilTypesModule.cpp", "jsFunctionPartialDeepStrictEqual", 2);
 const NumberIsNaN = Number.isNaN;
 const ObjectAssign = Object.assign;
+const ObjectDefineProperty = Object.defineProperty;
 const ObjectIs = Object.is;
 const ObjectKeys = Object.keys;
 const ObjectPrototypeIsPrototypeOf = Object.prototype.isPrototypeOf;
-const ReflectHas = Reflect.has;
-const ReflectOwnKeys = Reflect.ownKeys;
 const RegExpPrototypeExec = RegExp.prototype.exec;
 const StringPrototypeIndexOf = String.prototype.indexOf;
 const StringPrototypeSlice = String.prototype.slice;
 const StringPrototypeSplit = String.prototype.split;
-const SymbolIterator = Symbol.iterator;
 
 type nodeAssert = typeof import("node:assert");
 
+const kOptions = Symbol("options");
+
+const { isDeepStrictEqual } = require("internal/util/comparisons");
+
 function isDeepEqual(a, b) {
   return Bun.deepEquals(a, b, false);
 }
-function isDeepStrictEqual(a, b) {
-  return Bun.deepEquals(a, b, true);
-}
 
 var _inspect;
 function lazyInspect() {
@@ -90,12 +78,63 @@ export default assert;
 
 const NO_EXCEPTION_SENTINEL = {};
 
+/**
+ * @class Assert
+ * @param {object} [options] - `diff` ('simple'|'full'), `strict` (default true),
+ *   `skipPrototype` (default false).
+ * @throws {ERR_CONSTRUCT_CALL_REQUIRED} If not called with `new`.
+ */
+function Assert(options) {
+  if (!new.target) {
+    throw $ERR_CONSTRUCT_CALL_REQUIRED("Class constructor Assert cannot be invoked without `new`");
+  }
+
+  options = ObjectAssign({ __proto__: null, strict: true, skipPrototype: false }, options);
+
+  const { diff } = options;
+  if (diff !== undefined) {
+    validateOneOf(diff, "options.diff", ["simple", "full"]);
+  }
+
+  loadAssertionError();
+  this.AssertionError = AssertionError;
+  ObjectDefineProperty(this, kOptions, {
+    __proto__: null,
+    value: options,
+    enumerable: false,
+    configurable: false,
+    writable: false,
+  });
+
+  if (options.strict) {
+    this.equal = this.strictEqual;
+    this.deepEqual = this.deepStrictEqual;
+    this.notEqual = this.notStrictEqual;
+    this.notDeepEqual = this.notDeepStrictEqual;
+  }
+}
+
+// Functions compiled as builtins have no automatic `.prototype`; assign one
+// explicitly (same pattern as EventEmitter in node/events.ts).
+Assert.prototype = {};
+ObjectDefineProperty(Assert.prototype, "constructor", {
+  __proto__: null,
+  value: Assert,
+  writable: true,
+  enumerable: false,
+  configurable: true,
+});
+
 // All of the following functions must throw an AssertionError
 // when a corresponding condition is not met, with a message that
 // may be undefined if not provided. All assertion methods provide
 // both the actual and expected values to the assertion error for
 // display purposes.
 
+// DESTRUCTURING WARNING: All Assert.prototype methods use optional chaining
+// (this?.[kOptions]) so that methods destructured from an Assert instance
+// (losing their `this`) fall back to default behavior.
+
 function innerFail(obj) {
   const objMessage = obj.message;
   if (objMessage instanceof Error) throw objMessage;
@@ -150,6 +189,7 @@ function fail(
     operator: operator === undefined ? "fail" : operator,
     stackStartFn: stackStartFn || fail,
     message,
+    diff: this?.[kOptions]?.diff,
   };
   if (AssertionError === undefined) loadAssertionError();
   const err = new AssertionError(errArgs);
@@ -159,10 +199,9 @@ function fail(
   throw err;
 }
 
-assert.fail = fail;
+Assert.prototype.fail = fail;
 
 // The AssertionError is defined in internal/error.
-assert.AssertionError = AssertionError;
 Object.defineProperty(assert, "AssertionError", {
   get() {
     loadAssertionError();
@@ -186,7 +225,10 @@ function ok(value: unknown, message?: string | Error): asserts value;
 function ok(...args: unknown[]): void {
   innerOk(ok, args.length, ...args);
 }
-assert.ok = ok;
+
+Assert.prototype.ok = function ok(...args) {
+  innerOk(ok, args.length, ...args);
+};
 
 /**
  * The equality assertion tests shallow, coercive equality with ==.
@@ -196,7 +238,7 @@ assert.ok = ok;
  * @returns {void}
  */
 /* eslint-disable no-restricted-properties */
-assert.equal = function equal(actual: unknown, expected: unknown, message?: string | Error) {
+Assert.prototype.equal = function equal(actual: unknown, expected: unknown, message?: string | Error) {
   if (arguments.length < 2) {
     throw $ERR_MISSING_ARGS("actual", "expected");
   }
@@ -208,6 +250,7 @@ assert.equal = function equal(actual: unknown, expected: unknown, message?: stri
       message,
       operator: "==",
       stackStartFn: equal,
+      diff: this?.[kOptions]?.diff,
     });
   }
 };
@@ -220,7 +263,7 @@ assert.equal = function equal(actual: unknown, expected: unknown, message?: stri
  * @param {string | Error} [message]
  * @returns {void}
  */
-assert.notEqual = function notEqual(actual, expected, message) {
+Assert.prototype.notEqual = function notEqual(actual, expected, message) {
   if (arguments.length < 2) {
     throw $ERR_MISSING_ARGS("actual", "expected");
   }
@@ -232,6 +275,7 @@ assert.notEqual = function notEqual(actual, expected, message) {
       message,
       operator: "!=",
       stackStartFn: notEqual,
+      diff: this?.[kOptions]?.diff,
     });
   }
 };
@@ -243,7 +287,7 @@ assert.notEqual = function notEqual(actual, expected, message) {
  * @param {string | Error} [message]
  * @returns {void}
  */
-assert.deepEqual = function deepEqual(actual, expected, message) {
+Assert.prototype.deepEqual = function deepEqual(actual, expected, message) {
   if (arguments.length < 2) {
     throw $ERR_MISSING_ARGS("actual", "expected");
   }
@@ -254,6 +298,7 @@ assert.deepEqual = function deepEqual(actual, expected, message) {
       message,
       operator: "deepEqual",
       stackStartFn: deepEqual,
+      diff: this?.[kOptions]?.diff,
     });
   }
 };
@@ -265,7 +310,7 @@ assert.deepEqual = function deepEqual(actual, expected, message) {
  * @param {string | Error} [message]
  * @returns {void}
  */
-assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
+Assert.prototype.notDeepEqual = function notDeepEqual(actual, expected, message) {
   if (arguments.length < 2) {
     throw $ERR_MISSING_ARGS("actual", "expected");
   }
@@ -276,6 +321,7 @@ assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
       message,
       operator: "notDeepEqual",
       stackStartFn: notDeepEqual,
+      diff: this?.[kOptions]?.diff,
     });
   }
 };
@@ -289,17 +335,18 @@ assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
  * @param {string | Error} [message]
  * @returns {void}
  */
-assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {
+Assert.prototype.deepStrictEqual = function deepStrictEqual(actual, expected, message) {
   if (arguments.length < 2) {
     throw $ERR_MISSING_ARGS("actual", "expected");
   }
-  if (!isDeepStrictEqual(actual, expected)) {
+  if (!isDeepStrictEqual(actual, expected, this?.[kOptions]?.skipPrototype)) {
     innerFail({
       actual,
       expected,
       message,
       operator: "deepStrictEqual",
       stackStartFn: deepStrictEqual,
+      diff: this?.[kOptions]?.diff,
     });
   }
 };
@@ -312,18 +359,19 @@ assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {
  * @param {string | Error} [message]
  * @returns {void}
  */
-assert.notDeepStrictEqual = notDeepStrictEqual;
+Assert.prototype.notDeepStrictEqual = notDeepStrictEqual;
 function notDeepStrictEqual(actual, expected, message) {
   if (arguments.length < 2) {
     throw $ERR_MISSING_ARGS("actual", "expected");
   }
-  if (isDeepStrictEqual(actual, expected)) {
+  if (isDeepStrictEqual(actual, expected, this?.[kOptions]?.skipPrototype)) {
     innerFail({
       actual,
       expected,
       message,
       operator: "notDeepStrictEqual",
       stackStartFn: notDeepStrictEqual,
+      diff: this?.[kOptions]?.diff,
     });
   }
 }
@@ -335,7 +383,7 @@ function notDeepStrictEqual(actual, expected, message) {
  * @param {string | Error} [message]
  * @returns {void}
  */
-assert.strictEqual = function strictEqual(actual, expected, message) {
+Assert.prototype.strictEqual = function strictEqual(actual, expected, message) {
   if (arguments.length < 2) {
     throw $ERR_MISSING_ARGS("actual", "expected");
   }
@@ -346,6 +394,7 @@ assert.strictEqual = function strictEqual(actual, expected, message) {
       message,
       operator: "strictEqual",
       stackStartFn: strictEqual,
+      diff: this?.[kOptions]?.diff,
     });
   }
 };
@@ -357,7 +406,7 @@ assert.strictEqual = function strictEqual(actual, expected, message) {
  * @param {string | Error} [message]
  * @returns {void}
  */
-assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
+Assert.prototype.notStrictEqual = function notStrictEqual(actual, expected, message) {
   if (arguments.length < 2) {
     throw $ERR_MISSING_ARGS("actual", "expected");
   }
@@ -368,158 +417,11 @@ assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
       message,
       operator: "notStrictEqual",
       stackStartFn: notStrictEqual,
+      diff: this?.[kOptions]?.diff,
     });
   }
 };
 
-function isSpecial(obj) {
-  return obj == null || typeof obj !== "object" || Error.isError(obj) || isRegExp(obj) || isDate(obj);
-}
-
-const typesToCallDeepStrictEqualWith = [isKeyObject, isWeakSet, isWeakMap, Buffer.isBuffer];
-const SafeSetPrototypeIterator = SafeSet.prototype[SymbolIterator];
-const SafeMapPrototypeIterator = SafeMap.prototype[SymbolIterator];
-const SafeMapPrototypeHas = SafeMap.prototype.has;
-const SafeMapPrototypeGet = SafeMap.prototype.get;
-
-/**
- * Compares two objects or values recursively to check if they are equal.
- * @param {any} actual - The actual value to compare.
- * @param {any} expected - The expected value to compare.
- * @param {Set} [comparedObjects=new Set()] - Set to track compared objects for handling circular references.
- * @returns {boolean} - Returns `true` if the actual value matches the expected value, otherwise `false`.
- * @example
- * compareBranch({a: 1, b: 2, c: 3}, {a: 1, b: 2}); // true
- */
-function compareBranch(actual, expected, comparedObjects?) {
-  if (actual === expected) {
-    return actual !== 0 || ObjectIs(actual, expected);
-  }
-
-  // Check for Map object equality (subset check for partialDeepStrictEqual)
-  if (isMap(actual) && isMap(expected)) {
-    if (expected.size > actual.size) {
-      return false; // `expected` can't be a subset if it has more elements
-    }
-
-    return withCycleGuard(actual, expected, comparedObjects, compareBranchMap);
-  }
-
-  // Check for ArrayBuffer object equality
-  if (
-    ArrayBufferIsView(actual) ||
-    isAnyArrayBuffer(actual) ||
-    ArrayBufferIsView(expected) ||
-    isAnyArrayBuffer(expected)
-  ) {
-    return Bun.deepEquals(actual, expected, true);
-  }
-
-  for (const type of typesToCallDeepStrictEqualWith) {
-    if (type(actual) || type(expected)) {
-      return isDeepStrictEqual(actual, expected);
-    }
-  }
-
-  // Check for Set object equality
-  if (isSet(actual) && isSet(expected)) {
-    if (expected.size > actual.size) {
-      return false; // `expected` can't be a subset if it has more elements
-    }
-
-    const actualArray = ArrayFrom(SafeSetPrototypeIterator.$call(actual));
-    const expectedIterator = SafeSetPrototypeIterator.$call(expected);
-    const usedIndices = new SafeSet();
-
-    expectedIteration: for (const expectedItem of expectedIterator) {
-      for (let actualIdx = 0; actualIdx < actualArray.length; actualIdx++) {
-        if (!usedIndices.has(actualIdx) && isDeepStrictEqual(actualArray[actualIdx], expectedItem)) {
-          usedIndices.add(actualIdx);
-          continue expectedIteration;
-        }
-      }
-      return false;
-    }
-
-    return true;
-  }
-
-  // The expected array must match a subsequence of the actual array, in order,
-  // with each element compared partially (Node's partialArrayEquiv).
-  if ($isArray(actual) && $isArray(expected)) {
-    if (expected.length > actual.length) {
-      return false;
-    }
-
-    return withCycleGuard(actual, expected, comparedObjects, compareBranchArray);
-  }
-
-  // Comparison done when at least one of the values is not an object
-  if (isSpecial(actual) || isSpecial(expected)) {
-    return isDeepStrictEqual(actual, expected);
-  }
-
-  return withCycleGuard(actual, expected, comparedObjects, compareBranchObject);
-}
-
-// Path-scoped cycle detection tracking each side separately: a cycle is accepted
-// only when actual and expected each cycle back on their own side together.
-function withCycleGuard(actual, expected, comparedObjects, body) {
-  comparedObjects ??= { a: new SafeWeakSet(), b: new SafeWeakSet() };
-  const { a: seenActual, b: seenExpected } = comparedObjects;
-  const hadActual = seenActual.has(actual);
-  const hadExpected = seenExpected.has(expected);
-  if (hadActual && hadExpected) return true;
-  if (hadActual || hadExpected) return false;
-  seenActual.add(actual);
-  seenExpected.add(expected);
-  const result = body(actual, expected, comparedObjects);
-  seenActual.delete(actual);
-  seenExpected.delete(expected);
-  return result;
-}
-
-function compareBranchMap(actual, expected, comparedObjects) {
-  const expectedIterator = SafeMapPrototypeIterator.$call(expected);
-  for (const { 0: key, 1: expectedValue } of expectedIterator) {
-    if (!SafeMapPrototypeHas.$call(actual, key)) {
-      return false;
-    }
-    const actualValue = SafeMapPrototypeGet.$call(actual, key);
-    if (!compareBranch(actualValue, expectedValue, comparedObjects)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-function compareBranchArray(actual, expected, comparedObjects) {
-  let actualPos = 0;
-  for (let i = 0; i < expected.length; i++) {
-    const lastCandidate = actual.length - expected.length + i;
-    while (actualPos <= lastCandidate && !compareBranch(actual[actualPos], expected[i], comparedObjects)) {
-      actualPos++;
-    }
-    if (actualPos > lastCandidate) {
-      return false;
-    }
-    actualPos++;
-  }
-  return true;
-}
-
-function compareBranchObject(actual, expected, comparedObjects) {
-  // Use Reflect.ownKeys() instead of Object.keys() to include symbol properties
-  const keysExpected = ReflectOwnKeys(expected);
-  for (let i = 0; i < keysExpected.length; i++) {
-    const key = keysExpected[i];
-    if (!ReflectHas(actual, key) || !compareBranch(actual[key], expected[key], comparedObjects)) {
-      return false;
-    }
-  }
-  return true;
-}
-
 /**
  * The strict equivalence assertion test between two objects
  * @param {any} actual
@@ -527,19 +429,20 @@ function compareBranchObject(actual, expected, comparedObjects) {
  * @param {string | Error} [message]
  * @returns {void}
  */
-assert.partialDeepStrictEqual = function partialDeepStrictEqual(actual, expected, message) {
+Assert.prototype.partialDeepStrictEqual = function partialDeepStrictEqual(actual, expected, message) {
   // emitExperimentalWarning("assert.partialDeepStrictEqual");
   if (arguments.length < 2) {
     throw $ERR_MISSING_ARGS("actual", "expected");
   }
 
-  if (!compareBranch(actual, expected)) {
+  if (!nodePartialDeepStrictEqual(actual, expected)) {
     innerFail({
       actual,
       expected,
       message,
       operator: "partialDeepStrictEqual",
       stackStartFn: partialDeepStrictEqual,
+      diff: this?.[kOptions]?.diff,
     });
   }
 };
@@ -830,7 +733,10 @@ function expectsNoError(stackStartFn, actual, error, message) {
  * @param {...any} [args]
  * @returns {void}
  */
-assert.throws = function throws(promiseFn: () => Promise<unknown> | Promise<unknown>, ...args: unknown[]): void {
+Assert.prototype.throws = function throws(
+  promiseFn: () => Promise<unknown> | Promise<unknown>,
+  ...args: unknown[]
+): void {
   expectsError(throws, getActual(promiseFn), ...args);
 };
 
@@ -855,8 +761,8 @@ const kQualifiedStackNames = {
     expectsNoError(kQualifiedStackNames["assert.doesNotReject"], await waitForActual(fn), ...args);
   },
 };
-assert.rejects = kQualifiedStackNames["assert.rejects"];
-Object.defineProperty(assert.rejects, "name", { value: "rejects", configurable: true });
+Assert.prototype.rejects = kQualifiedStackNames["assert.rejects"];
+Object.defineProperty(Assert.prototype.rejects, "name", { value: "rejects", configurable: true });
 
 /**
  * Asserts that the function `fn` does not throw an error.
@@ -864,7 +770,7 @@ Object.defineProperty(assert.rejects, "name", { value: "rejects", configurable:
  * @param {...any} [args]
  * @returns {void}
  */
-assert.doesNotThrow = function doesNotThrow(fn: () => Promise<unknown>, ...args: unknown[]): void {
+Assert.prototype.doesNotThrow = function doesNotThrow(fn: () => Promise<unknown>, ...args: unknown[]): void {
   expectsNoError(doesNotThrow, getActual(fn), ...args);
 };
 
@@ -874,15 +780,15 @@ assert.doesNotThrow = function doesNotThrow(fn: () => Promise<unknown>, ...args:
  * @param {...any} [args]
  * @returns {Promise<void>}
  */
-assert.doesNotReject = kQualifiedStackNames["assert.doesNotReject"];
-Object.defineProperty(assert.doesNotReject, "name", { value: "doesNotReject", configurable: true });
+Assert.prototype.doesNotReject = kQualifiedStackNames["assert.doesNotReject"];
+Object.defineProperty(Assert.prototype.doesNotReject, "name", { value: "doesNotReject", configurable: true });
 
 /**
  * Throws `value` if the value is not `null` or `undefined`.
  * @param {any} err
  * @returns {void}
  */
-assert.ifError = function ifError(err: unknown): void {
+Assert.prototype.ifError = function ifError(err: unknown): void {
   if (err !== null && err !== undefined) {
     let message = "ifError got unwanted exception: ";
     const errMessage = typeof err === "object" ? err.message : undefined;
@@ -905,6 +811,7 @@ assert.ifError = function ifError(err: unknown): void {
       operator: "ifError",
       message,
       stackStartFn: ifError,
+      diff: this?.[kOptions]?.diff,
     });
 
     // Make sure we actually have a stack trace!
@@ -943,9 +850,10 @@ assert.ifError = function ifError(err: unknown): void {
 
 function internalMatch(string, regexp, message, fn) {
   if (!isRegExp(regexp)) {
-    throw $ERR_INVALID_ARG_TYPE("regexp", "RegExp", regexp);
+    // List form so the message renders "an instance of RegExp" like node.
+    throw $ERR_INVALID_ARG_TYPE("regexp", ["RegExp"], regexp);
   }
-  const match = fn === assert.match;
+  const match = fn === Assert.prototype.match;
   if (typeof string !== "string" || (RegExpPrototypeExec.$call(regexp, string) !== null) !== match) {
     if (message instanceof Error) {
       throw message;
@@ -982,7 +890,7 @@ function internalMatch(string, regexp, message, fn) {
  * @param {string | Error} [message]
  * @returns {void}
  */
-assert.match = function match(string, regexp, message) {
+Assert.prototype.match = function match(string, regexp, message) {
   internalMatch(string, regexp, message, match);
 };
 
@@ -993,7 +901,7 @@ assert.match = function match(string, regexp, message) {
  * @param {string | Error} [message]
  * @returns {void}
  */
-assert.doesNotMatch = function doesNotMatch(string, regexp, message) {
+Assert.prototype.doesNotMatch = function doesNotMatch(string, regexp, message) {
   internalMatch(string, regexp, message, doesNotMatch);
 };
 
@@ -1023,6 +931,29 @@ function strict(...args) {
   innerOk(strict, args.length, ...args);
 }
 
+for (const name of [
+  "ok",
+  "fail",
+  "equal",
+  "notEqual",
+  "deepEqual",
+  "notDeepEqual",
+  "deepStrictEqual",
+  "notDeepStrictEqual",
+  "strictEqual",
+  "notStrictEqual",
+  "partialDeepStrictEqual",
+  "match",
+  "doesNotMatch",
+  "throws",
+  "rejects",
+  "doesNotThrow",
+  "doesNotReject",
+  "ifError",
+]) {
+  assert[name] = Assert.prototype[name];
+}
+
 assert.strict = ObjectAssign(strict, assert, {
   equal: assert.strictEqual,
   deepEqual: assert.deepStrictEqual,
@@ -1030,4 +961,7 @@ assert.strict = ObjectAssign(strict, assert, {
   notDeepEqual: assert.notDeepStrictEqual,
 });
 
+assert.strict.Assert = Assert;
 assert.strict.strict = assert.strict;
+
+assert.Assert = Assert;
diff --git a/src/js/node/crypto.ts b/src/js/node/crypto.ts
index 4bb4d60b49df..6e9711ae111c 100644
--- a/src/js/node/crypto.ts
+++ b/src/js/node/crypto.ts
@@ -1,6 +1,7 @@
 // Hardcoded module "node:crypto"
 const StringDecoder = require("node:string_decoder").StringDecoder;
 const LazyTransform = require("internal/streams/lazy_transform");
+const { guardCallback } = require("internal/shared");
 const { defineCustomPromisifyArgs } = require("internal/promisify");
 const Writable = require("internal/streams/writable");
 const { CryptoHasher } = Bun;
@@ -149,9 +150,11 @@ function pbkdf2(password, salt, iterations, keylen, digest, callback) {
 
   const promise = _pbkdf2(password, salt, iterations, keylen, digest, callback);
   if (callback) {
+    // Guarded so a throw inside the callback is an uncaughtException, as in node.
+    const cb = guardCallback(callback);
     promise.then(
-      result => callback(null, result),
-      err => callback(err),
+      result => cb(null, result),
+      err => cb(err),
     );
     return;
   }
diff --git a/src/js/node/dns.ts b/src/js/node/dns.ts
index 563c277afde8..053a3dab1202 100644
--- a/src/js/node/dns.ts
+++ b/src/js/node/dns.ts
@@ -2,6 +2,7 @@
 const dns = Bun.dns;
 const utilPromisifyCustomSymbol = Symbol.for("nodejs.util.promisify.custom");
 const { isIP } = require("internal/net/isIP");
+const { guardCallback } = require("internal/shared");
 const {
   validateFunction,
   validateArray,
@@ -212,6 +213,8 @@ function validateOrderOption(options) {
   }
 }
 
+// Validates and returns the callback wrapped by guardCallback.
+// Callers must use the return value, not the argument.
 function validateResolve(hostname, callback) {
   if (typeof hostname !== "string") {
     throw $ERR_INVALID_ARG_TYPE("hostname", "string", hostname);
@@ -220,6 +223,8 @@ function validateResolve(hostname, callback) {
   if (typeof callback !== "function") {
     throw $ERR_INVALID_ARG_TYPE("callback", "function", callback);
   }
+
+  return guardCallback(callback);
 }
 
 function validateLocalAddresses(first, second) {
@@ -314,6 +319,7 @@ function lookup(hostname, options, callback) {
     return;
   }
 
+  callback = guardCallback(callback);
   dns
     .lookup(hostname, options)
     .then(res => {
@@ -357,6 +363,7 @@ function lookupService(address, port, callback) {
   validateString(address);
   validatePort(port, "port");
 
+  callback = guardCallback(callback);
   dns.lookupService(address, +port).then(
     results => {
       callback(null, ...results);
@@ -401,7 +408,7 @@ var InternalResolver = class Resolver {
       throw $ERR_INVALID_ARG_TYPE("rrtype", "string", rrtype);
     }
 
-    validateResolve(hostname, callback);
+    callback = validateResolve(hostname, callback);
 
     Resolver.#getResolver(this)
       .resolve(hostname, rrtype)
@@ -429,7 +436,7 @@ var InternalResolver = class Resolver {
       options = null;
     }
 
-    validateResolve(hostname, callback);
+    callback = validateResolve(hostname, callback);
 
     Resolver.#getResolver(this)
       .resolve(hostname, "A")
@@ -449,7 +456,7 @@ var InternalResolver = class Resolver {
       options = null;
     }
 
-    validateResolve(hostname, callback);
+    callback = validateResolve(hostname, callback);
 
     Resolver.#getResolver(this)
       .resolve(hostname, "AAAA")
@@ -464,7 +471,7 @@ var InternalResolver = class Resolver {
   }
 
   resolveAny(hostname, callback) {
-    validateResolve(hostname, callback);
+    callback = validateResolve(hostname, callback);
 
     Resolver.#getResolver(this)
       .resolveAny(hostname)
@@ -479,7 +486,7 @@ var InternalResolver = class Resolver {
   }
 
   resolveCname(hostname, callback) {
-    validateResolve(hostname, callback);
+    callback = validateResolve(hostname, callback);
 
     Resolver.#getResolver(this)
       .resolveCname(hostname)
@@ -494,7 +501,7 @@ var InternalResolver = class Resolver {
   }
 
   resolveMx(hostname, callback) {
-    validateResolve(hostname, callback);
+    callback = validateResolve(hostname, callback);
 
     Resolver.#getResolver(this)
       .resolveMx(hostname)
@@ -509,7 +516,7 @@ var InternalResolver = class Resolver {
   }
 
   resolveNaptr(hostname, callback) {
-    validateResolve(hostname, callback);
+    callback = validateResolve(hostname, callback);
 
     Resolver.#getResolver(this)
       .resolveNaptr(hostname)
@@ -524,7 +531,7 @@ var InternalResolver = class Resolver {
   }
 
   resolveNs(hostname, callback) {
-    validateResolve(hostname, callback);
+    callback = validateResolve(hostname, callback);
 
     Resolver.#getResolver(this)
       .resolveNs(hostname)
@@ -539,7 +546,7 @@ var InternalResolver = class Resolver {
   }
 
   resolvePtr(hostname, callback) {
-    validateResolve(hostname, callback);
+    callback = validateResolve(hostname, callback);
 
     Resolver.#getResolver(this)
       .resolvePtr(hostname)
@@ -554,7 +561,7 @@ var InternalResolver = class Resolver {
   }
 
   resolveSrv(hostname, callback) {
-    validateResolve(hostname, callback);
+    callback = validateResolve(hostname, callback);
 
     Resolver.#getResolver(this)
       .resolveSrv(hostname)
@@ -572,6 +579,7 @@ var InternalResolver = class Resolver {
     if (typeof callback !== "function") {
       throw $ERR_INVALID_ARG_TYPE("callback", "function", callback);
     }
+    callback = guardCallback(callback);
 
     Resolver.#getResolver(this)
       .resolveCaa(hostname)
@@ -589,6 +597,7 @@ var InternalResolver = class Resolver {
     if (typeof callback !== "function") {
       throw $ERR_INVALID_ARG_TYPE("callback", "function", callback);
     }
+    callback = guardCallback(callback);
 
     Resolver.#getResolver(this)
       .resolveTxt(hostname)
@@ -605,6 +614,7 @@ var InternalResolver = class Resolver {
     if (typeof callback !== "function") {
       throw $ERR_INVALID_ARG_TYPE("callback", "function", callback);
     }
+    callback = guardCallback(callback);
 
     Resolver.#getResolver(this)
       .resolveSoa(hostname)
@@ -622,6 +632,7 @@ var InternalResolver = class Resolver {
     if (typeof callback !== "function") {
       throw $ERR_INVALID_ARG_TYPE("callback", "function", callback);
     }
+    callback = guardCallback(callback);
 
     Resolver.#getResolver(this)
       .reverse(ip)
diff --git a/src/js/node/fs.ts b/src/js/node/fs.ts
index d3e1ce3f98dd..3e1569eb188c 100644
--- a/src/js/node/fs.ts
+++ b/src/js/node/fs.ts
@@ -23,12 +23,22 @@ function lazyGlob() {
   return (_lazyGlob ??= require("internal/fs/glob"));
 }
 
+const { guardCallback } = require("internal/shared");
+
+// guardCallback reroutes a throw inside the user callback to the
+// uncaughtException path instead of rejecting the internal promise chain.
+function wrapFsCallback(callback) {
+  return guardCallback(callback);
+}
+
+// Validates and returns the wrapped callback.
+// Callers must use the return value, not the argument.
 function ensureCallback(callback) {
   if (!$isCallable(callback)) {
     throw $ERR_INVALID_ARG_TYPE("cb", "function", callback);
   }
 
-  return callback;
+  return wrapFsCallback(callback);
 }
 
 // Micro-optimization: avoid creating a new function for every call
@@ -52,7 +62,7 @@ var access = function access(path, mode, callback) {
       mode = undefined;
     }
 
-    ensureCallback(callback);
+    callback = ensureCallback(callback);
     fs.access(path, mode).then(callback, callback);
   },
   appendFile = function appendFile(path, data, options, callback) {
@@ -61,12 +71,13 @@ var access = function access(path, mode, callback) {
       options = undefined;
     }
 
-    ensureCallback(callback);
+    callback = ensureCallback(callback);
 
     fs.appendFile(path, data, options).then(nullcallback(callback), callback);
   },
   close = function close(fd, callback) {
     if ($isCallable(callback)) {
+      callback = wrapFsCallback(callback);
       fs.close(fd).then(() => callback(null), callback);
     } else if (callback === undefined) {
       fs.close(fd).then(() => {});
@@ -80,7 +91,7 @@ var access = function access(path, mode, callback) {
       options = undefined;
     }
 
-    ensureCallback(callback);
+    callback = ensureCallback(callback);
     // route through promises.rm for the JS-side ERR_FS_EISDIR validation
     promises.rm(path, options).then(nullcallback(callback), callback);
   },
@@ -103,12 +114,12 @@ var access = function access(path, mode, callback) {
       mode = 0;
     }
 
-    ensureCallback(callback);
+    callback = ensureCallback(callback);
 
     fs.copyFile(src, dest, mode).then(nullcallback(callback), callback);
   },
   exists = function exists(path, callback) {
-    ensureCallback(callback);
+    callback = ensureCallback(callback);
 
     try {
       fs.exists.$apply(fs, [path]).then(
@@ -120,22 +131,22 @@ var access = function access(path, mode, callback) {
     }
   },
   chown = function chown(path, uid, gid, callback) {
-    ensureCallback(callback);
+    callback = ensureCallback(callback);
 
     fs.chown(path, uid, gid).then(nullcallback(callback), callback);
   },
   chmod = function chmod(path, mode, callback) {
-    ensureCallback(callback);
+    callback = ensureCallback(callback);
 
     fs.chmod(path, mode).then(nullcallback(callback), callback);
   },
   fchmod = function fchmod(fd, mode, callback) {
-    ensureCallback(callback);
+    callback = ensureCallback(callback);
 
     fs.fchmod(fd, mode).then(nullcallback(callback), callback);
   },
   fchown = function fchown(fd, uid, gid, callback) {
-    ensureCallback(callback);
+    callback = ensureCallback(callback);
 
     fs.fchown(fd, uid, gid).then(nullcallback(callback), callback);
   },
@@ -145,12 +156,13 @@ var access = function access(path, mode, callback) {
       options = undefined;
     }
 
+    callback = wrapFsCallback(callback);
     fs.fstat(fd, options).then(function (stats) {
       callback(null, stats);
     }, callback);
   },
   fsync = function fsync(fd, callback) {
-    ensureCallback(callback);
+    callback = ensureCallback(callback);
 
     fs.fsync(fd).then(nullcallback(callback), callback);
   },
@@ -160,30 +172,30 @@ var access = function access(path, mode, callback) {
       len = 0;
     }
 
-    ensureCallback(callback);
+    callback = ensureCallback(callback);
 
     fs.ftruncate(fd, len).then(nullcallback(callback), callback);
   },
   futimes = function futimes(fd, atime, mtime, callback) {
-    ensureCallback(callback);
+    callback = ensureCallback(callback);
 
     fs.futimes(fd, atime, mtime).then(nullcallback(callback), callback);
   },
   lchmod =
     constants.O_SYMLINK !== undefined
       ? function lchmod(path, mode, callback) {
-          ensureCallback(callback);
+          callback = ensureCallback(callback);
 
           fs.lchmod(path, mode).then(nullcallback(callback), callback);
         }
       : undefined, // lchmod is only available on macOS
   lchown = function lchown(path, uid, gid, callback) {
-    ensureCallback(callback);
+    callback = ensureCallback(callback);
 
     fs.lchown(path, uid, gid).then(nullcallback(callback), callback);
   },
   link = function link(existingPath, newPath, callback) {
-    ensureCallback(callback);
+    callback = ensureCallback(callback);
 
     fs.link(existingPath, newPath).then(nullcallback(callback), callback);
   },
@@ -193,7 +205,7 @@ var access = function access(path, mode, callback) {
       options = undefined;
     }
 
-    ensureCallback(callback);
+    callback = ensureCallback(callback);
 
     fs.mkdir(path, options).then(nullcallback(callback), callback);
   },
@@ -203,7 +215,7 @@ var access = function access(path, mode, callback) {
       options = undefined;
     }
 
-    ensureCallback(callback);
+    callback = ensureCallback(callback);
 
     fs.mkdtemp(prefix, options).then(function (folder) {
       callback(null, folder);
@@ -219,14 +231,14 @@ var access = function access(path, mode, callback) {
       mode = undefined;
     }
 
-    ensureCallback(callback);
+    callback = ensureCallback(callback);
 
     fs.open(path, flags, mode).then(function (fd) {
       callback(null, fd);
     }, callback);
   },
   fdatasync = function fdatasync(fd, callback) {
-    ensureCallback(callback);
+    callback = ensureCallback(callback);
 
     fs.fdatasync(fd).then(nullcallback(callback), callback);
   },
@@ -269,6 +281,7 @@ var access = function access(path, mode, callback) {
     if (!callback) {
       throw $ERR_INVALID_ARG_TYPE("callback", "function", callback);
     }
+    callback = wrapFsCallback(callback);
     fs.read(fd, buffer, offset, length, position).then(
       bytesRead => void callback(null, bytesRead, buffer),
       err => callback(err),
@@ -283,7 +296,7 @@ var access = function access(path, mode, callback) {
     // to the string signature. Use Node's predicate, like writeSync below.
     if (types.isArrayBufferView(buffer)) {
       callback ||= position || length || offsetOrOptions;
-      ensureCallback(callback);
+      callback = ensureCallback(callback);
 
       if (typeof offsetOrOptions === "object") {
         ({
@@ -314,7 +327,7 @@ var access = function access(path, mode, callback) {
     // Node validates the encoding (synchronously) before the callback.
     validateEncoding(buffer, length);
     callback = position;
-    ensureCallback(callback);
+    callback = ensureCallback(callback);
 
     fs.write(fd, buffer, offsetOrOptions, length).then(wrapper, callback);
   },
@@ -324,7 +337,7 @@ var access = function access(path, mode, callback) {
       options = undefined;
     }
 
-    ensureCallback(callback);
+    callback = ensureCallback(callback);
 
     fs.readdir(path, options).then(function (files) {
       callback(null, files);
@@ -332,7 +345,7 @@ var access = function access(path, mode, callback) {
   },
   readFile = function readFile(path, options, callback) {
     callback ||= options;
-    ensureCallback(callback);
+    callback = ensureCallback(callback);
 
     fs.readFile(path, options).then(function (data) {
       callback(null, data);
@@ -340,7 +353,7 @@ var access = function access(path, mode, callback) {
   },
   writeFile = function writeFile(path, data, options, callback) {
     callback ||= options;
-    ensureCallback(callback);
+    callback = ensureCallback(callback);
 
     fs.writeFile(path, data, options).then(nullcallback(callback), callback);
   },
@@ -350,14 +363,14 @@ var access = function access(path, mode, callback) {
       options = undefined;
     }
 
-    ensureCallback(callback);
+    callback = ensureCallback(callback);
 
     fs.readlink(path, options).then(function (linkString) {
       callback(null, linkString);
     }, callback);
   },
   rename = function rename(oldPath, newPath, callback) {
-    ensureCallback(callback);
+    callback = ensureCallback(callback);
 
     fs.rename(oldPath, newPath).then(nullcallback(callback), callback);
   },
@@ -367,7 +380,7 @@ var access = function access(path, mode, callback) {
       options = undefined;
     }
 
-    ensureCallback(callback);
+    callback = ensureCallback(callback);
 
     fs.lstat(path, options).then(function (stats) {
       callback(null, stats);
@@ -379,7 +392,7 @@ var access = function access(path, mode, callback) {
       options = undefined;
     }
 
-    ensureCallback(callback);
+    callback = ensureCallback(callback);
 
     const signal = options?.signal;
     if (signal?.aborted) {
@@ -397,7 +410,7 @@ var access = function access(path, mode, callback) {
       options = undefined;
     }
 
-    ensureCallback(callback);
+    callback = ensureCallback(callback);
 
     fs.statfs(path, options).then(function (stats) {
       callback(null, stats);
@@ -405,9 +418,12 @@ var access = function access(path, mode, callback) {
   },
   symlink = function symlink(target, path, type, callback) {
     if (callback === undefined) {
-      callback = type;
-      ensureCallback(callback);
+      callback = ensureCallback(type);
       type = undefined;
+    } else if ($isCallable(callback)) {
+      // Not ensureCallback: node does not validate the 4-argument overload's
+      // callback, and a non-callable one must stay an ignored `.then` handler.
+      callback = wrapFsCallback(callback);
     }
 
     fs.symlink(target, path, type).then(callback, callback);
@@ -426,21 +442,21 @@ var access = function access(path, mode, callback) {
       len = 0;
     }
 
-    ensureCallback(callback);
+    callback = ensureCallback(callback);
     fs.truncate(path, len).then(nullcallback(callback), callback);
   },
   unlink = function unlink(path, callback) {
-    ensureCallback(callback);
+    callback = ensureCallback(callback);
 
     fs.unlink(path).then(nullcallback(callback), callback);
   },
   utimes = function utimes(path, atime, mtime, callback) {
-    ensureCallback(callback);
+    callback = ensureCallback(callback);
 
     fs.utimes(path, atime, mtime).then(nullcallback(callback), callback);
   },
   lutimes = function lutimes(path, atime, mtime, callback) {
-    ensureCallback(callback);
+    callback = ensureCallback(callback);
 
     fs.lutimes(path, atime, mtime).then(nullcallback(callback), callback);
   },
@@ -611,6 +627,7 @@ var access = function access(path, mode, callback) {
     // the eager path check runs on an async stat so the JS thread isn't
     // blocked and the callback never fires synchronously.
     const result = new Dir(1, path, options, kAlreadyValidated);
+    callback = wrapFsCallback(callback);
     // Invoke the callback from process.nextTick so an exception thrown by it
     // surfaces as an uncaught exception instead of rejecting this internal
     // promise chain (same convention as glob() below).
@@ -789,7 +806,7 @@ const realpath: typeof import("node:fs").realpath =
           callback = options;
           options = undefined;
         }
-        ensureCallback(callback);
+        callback = ensureCallback(callback);
 
         fs.realpath(p, options, false).then(function (resolvedPath) {
           callback(null, resolvedPath);
@@ -800,7 +817,7 @@ const realpath: typeof import("node:fs").realpath =
           callback = options;
           options = undefined;
         }
-        ensureCallback(callback);
+        callback = ensureCallback(callback);
         let encoding;
         if (options) {
           if (typeof options === "string") encoding = options;
@@ -940,7 +957,7 @@ realpath.native = function realpath(p, options, callback) {
     options = undefined;
   }
 
-  ensureCallback(callback);
+  callback = ensureCallback(callback);
 
   fs.realpathNative(p, options).then(function (resolvedPath) {
     callback(null, resolvedPath);
@@ -974,7 +991,9 @@ function cp(src, dest, options, callback) {
     options = undefined;
   }
 
-  ensureCallback(callback);
+  if (!$isCallable(callback)) {
+    throw $ERR_INVALID_ARG_TYPE("cb", "function", callback);
+  }
 
   // node's callback form throws synchronously on invalid options/paths
   const { validateCpOptions } = require("internal/fs/cp-sync");
@@ -982,6 +1001,7 @@ function cp(src, dest, options, callback) {
   options = validateCpOptions(options);
   src = getValidatedFsPath(src, "src");
   dest = getValidatedFsPath(dest, "dest");
+  callback = guardCallback(callback);
 
   promises.cp(src, dest, options).then(callOnceWithNull.bind(null, callback), callback);
 }
@@ -1142,6 +1162,7 @@ class Dir {
   read(cb?: (err: Error | null, entry: DirentType) => void): any {
     if (!$isUndefinedOrNull(cb)) {
       validateFunction(cb, "callback");
+      cb = guardCallback(cb);
       // node's callback overload returns undefined (like close(cb) above)
       this.read().then(callOnceWithNullThen.bind(null, cb), cb);
       return;
@@ -1183,6 +1204,7 @@ class Dir {
   close(cb?: (err?: Error) => void) {
     if (!$isUndefinedOrNull(cb)) {
       validateFunction(cb, "callback");
+      cb = guardCallback(cb);
       this.close().then(callOnceWithNull.bind(null, cb), cb);
       return;
     }
diff --git a/src/js/node/url.ts b/src/js/node/url.ts
index e39f66566d63..8cb3115683bc 100644
--- a/src/js/node/url.ts
+++ b/src/js/node/url.ts
@@ -25,10 +25,10 @@
 
 "use strict";
 
-const { URL, URLSearchParams } = globalThis;
-const [domainToASCII, domainToUnicode] = $cpp("NodeURL.cpp", "Bun::createNodeURLBinding");
+const { URL, URLSearchParams, URLPattern } = globalThis;
+const [domainToASCII, domainToUnicode, idnaToASCII] = $cpp("NodeURL.cpp", "Bun::createNodeURLBinding");
 const { urlToHttpOptions } = require("internal/url");
-const { validateString } = require("internal/validators");
+const { validateString, validateObject } = require("internal/validators");
 const ObjectSetPrototypeOf = Object.setPrototypeOf;
 
 function Url() {
@@ -66,14 +66,9 @@ var protocolPattern = /^([a-z0-9.+-]+:)/i,
   unwise = ["{", "}", "|", "\\", "^", "`"].concat(delims),
   // Allowed by RFCs, but cause of XSS attacks.  Always escape these.
   autoEscape = ["'"].concat(unwise),
-  /*
-   * Characters that are never ever allowed in a hostname.
-   * Note that any invalid chars are also handled, but these
-   * are the ones that are *expected* to be seen, so we fast-path
-   * them.
-   */
-  nonHostChars = ["%", "/", "?", ";", "#"].concat(autoEscape),
-  hostEndingChars = ["/", "?", "#"],
+  // Characters never allowed in a hostname (post-IDNA) / bracketed IPv6 hostname.
+  forbiddenHostChars = /[\0\t\n\r #%/:<>?@[\\\]^|]/,
+  forbiddenHostCharsIpv6 = /[\0\t\n\r #%/<>?@\\^|]/,
   hostnameMaxLen = 255,
   // protocols that can allow "unsafe" and "unwise" chars.
   unsafeProtocol = {
@@ -95,18 +90,40 @@ var protocolPattern = /^([a-z0-9.+-]+:)/i,
     ftp: true,
     gopher: true,
     file: true,
+    ws: true,
+    wss: true,
     "http:": true,
     "https:": true,
     "ftp:": true,
     "gopher:": true,
     "file:": true,
+    "ws:": true,
+    "wss:": true,
   };
 
+const { isInsideNodeModules } = require("internal/shared");
+
+let urlParseWarned = false;
+
 function urlParse(
   url: string | URL | typeof Url, // really has unknown type but intellisense is nice
   parseQueryString?: boolean,
   slashesDenoteHost?: boolean,
 ) {
+  // Once-per-process and never from library code, matching node v26.3.0
+  // lib/url.js urlParse. The latch stays unset on suppressed calls so a
+  // later first-party caller still gets the warning, like node.
+  if (!urlParseWarned && !isInsideNodeModules(4)) {
+    urlParseWarned = true;
+    process.emitWarning(
+      "`url.parse()` behavior is not standardized and prone to " +
+        "errors that have security implications. Use the WHATWG URL API " +
+        "instead. CVEs are not issued for `url.parse()` vulnerabilities.",
+      "DeprecationWarning",
+      "DEP0169",
+    );
+  }
+
   if ($isObject(url) && url instanceof Url) return url;
 
   var u = new Url();
@@ -254,62 +271,63 @@ Url.prototype.parse = function parse(url: string, parseQueryString?: boolean, sl
      * http://a@b?@c => user:a host:c path:/?@c
      */
 
-    /*
-     * v0.12 TODO(isaacs): This is not quite how Chrome does things.
-     * Review our test case against browsers more comprehensively.
-     */
-
-    // find the first instance of any hostEndingChars
-    var hostEnd = -1;
-    for (var i = 0; i < hostEndingChars.length; i++) {
-      var hec = rest.indexOf(hostEndingChars[i]);
-      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {
-        hostEnd = hec;
+    let hostEnd = -1;
+    let atSign = -1;
+    let nonHost = -1;
+    for (let i = 0; i < rest.length; ++i) {
+      switch (rest.$charCodeAt(i)) {
+        case Char.TAB:
+        case Char.LINE_FEED:
+        case Char.CARRIAGE_RETURN:
+          // WHATWG URL removes tabs, newlines, and carriage returns. Let's do that too.
+          rest = rest.slice(0, i) + rest.slice(i + 1);
+          i -= 1;
+          break;
+        case Char.SPACE:
+        case Char.DOUBLE_QUOTE:
+        case Char.PERCENT:
+        case Char.SINGLE_QUOTE:
+        case Char.SEMICOLON:
+        case Char.LEFT_ANGLE_BRACKET:
+        case Char.RIGHT_ANGLE_BRACKET:
+        case Char.BACKWARD_SLASH:
+        case Char.CIRCUMFLEX_ACCENT:
+        case Char.GRAVE_ACCENT:
+        case Char.LEFT_CURLY_BRACKET:
+        case Char.VERTICAL_LINE:
+        case Char.RIGHT_CURLY_BRACKET:
+          // Characters that are never ever allowed in a hostname from RFC 2396
+          if (nonHost === -1) nonHost = i;
+          break;
+        case Char.HASH:
+        case Char.FORWARD_SLASH:
+        case Char.QUESTION_MARK:
+          // Find the first instance of any host-ending characters
+          if (nonHost === -1) nonHost = i;
+          hostEnd = i;
+          break;
+        case Char.AT:
+          // At this point, either we have an explicit point where the
+          // auth portion cannot go past, or the last @ char is the decider.
+          atSign = i;
+          nonHost = -1;
+          break;
       }
+      if (hostEnd !== -1) break;
     }
-
-    /*
-     * at this point, either we have an explicit point where the
-     * auth portion cannot go past, or the last @ char is the decider.
-     */
-    var auth: string | undefined, atSign: number;
-    if (hostEnd === -1) {
-      // atSign can be anywhere.
-      atSign = rest.lastIndexOf("@");
-    } else {
-      /*
-       * atSign must be in auth portion.
-       * http://a@b/c@d => host:b auth:a path:/c@d
-       */
-      atSign = rest.lastIndexOf("@", hostEnd);
-    }
-
-    /*
-     * Now we have a portion which is definitely the auth.
-     * Pull that off.
-     */
+    let authStart = 0;
     if (atSign !== -1) {
-      auth = rest.slice(0, atSign);
-      rest = rest.slice(atSign + 1);
-      this.auth = decodeURIComponent(auth);
-    }
-
-    // the host is the remaining to the left of the first non-host char
-    hostEnd = -1;
-    for (var i = 0; i < nonHostChars.length; i++) {
-      var hec = rest.indexOf(nonHostChars[i]);
-      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {
-        hostEnd = hec;
-      }
+      this.auth = decodeURIComponent(rest.slice(0, atSign));
+      authStart = atSign + 1;
     }
-    // if we still have not hit it, then the entire thing is a host.
-    if (hostEnd === -1) {
-      hostEnd = rest.length;
+    if (nonHost === -1) {
+      this.host = rest.slice(authStart);
+      rest = "";
+    } else {
+      this.host = rest.slice(authStart, nonHost);
+      rest = rest.slice(nonHost);
     }
 
-    this.host = rest.slice(0, hostEnd);
-    rest = rest.slice(hostEnd);
-
     // pull out port.
     this.parseHost();
 
@@ -340,14 +358,29 @@ Url.prototype.parse = function parse(url: string, parseQueryString?: boolean, sl
       this.hostname = this.hostname.toLowerCase();
     }
 
-    /*
-     * IDNA Support: Returns a punycoded representation of "domain".
-     * It only converts parts of the domain name that
-     * have non-ASCII characters, i.e. it doesn't matter if
-     * you call it with a domain that already is ASCII-only.
-     */
-    if (this.hostname) {
-      this.hostname = new URL("http://" + this.hostname).hostname;
+    if (this.hostname !== "") {
+      if (ipv6Hostname) {
+        // IPv6 literals stay as written (Node only lowercases them).
+        if (forbiddenHostCharsIpv6.test(this.hostname)) {
+          throw $ERR_INVALID_URL(url);
+        }
+      } else {
+        /*
+         * IDNA Support: Returns a punycoded representation of "domain".
+         * It only converts parts of the domain name that
+         * have non-ASCII characters, i.e. it doesn't matter if
+         * you call it with a domain that already is ASCII-only.
+         */
+        this.hostname = idnaToASCII(this.hostname);
+
+        /*
+         * Prevent two potential routes of hostname spoofing (see Node):
+         * an empty result or forbidden chars can only come from toASCII.
+         */
+        if (this.hostname === "" || forbiddenHostChars.test(this.hostname)) {
+          throw $ERR_INVALID_URL(url);
+        }
+      }
     }
 
     var p = this.port ? ":" + this.port : "";
@@ -430,6 +463,80 @@ Url.prototype.parse = function parse(url: string, parseQueryString?: boolean, sl
   return this;
 };
 
+// Same as node's lib/url.js noEscapeAuth table (noEscape plus the colon).
+// prettier-ignore
+const noEscapeAuth = new Int8Array([
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x00 - 0x0F
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x10 - 0x1F
+  0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, // 0x20 - 0x2F
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, // 0x30 - 0x3F
+  0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x40 - 0x4F
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, // 0x50 - 0x5F
+  0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 0x60 - 0x6F
+  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, // 0x70 - 0x7F
+]);
+
+const hexTable = new Array(256);
+for (let i = 0; i < 256; ++i) hexTable[i] = "%" + ((i < 16 ? "0" : "") + i.toString(16)).toUpperCase();
+
+// Port of node's internal/querystring encodeStr, used for auth encoding.
+function encodeStr(str: string, noEscapeTable: Int8Array, hexTable: string[]) {
+  const len = str.length;
+  if (len === 0) return "";
+
+  let out = "";
+  let lastPos = 0;
+  let i = 0;
+
+  outer: for (; i < len; i++) {
+    let c = str.$charCodeAt(i);
+
+    // ASCII
+    while (c < 0x80) {
+      if (noEscapeTable[c] !== 1) {
+        if (lastPos < i) out += str.slice(lastPos, i);
+        lastPos = i + 1;
+        out += hexTable[c];
+      }
+
+      if (++i === len) break outer;
+
+      c = str.$charCodeAt(i);
+    }
+
+    if (lastPos < i) out += str.slice(lastPos, i);
+
+    // Multi-byte characters ...
+    if (c < 0x800) {
+      lastPos = i + 1;
+      out += hexTable[0xc0 | (c >> 6)] + hexTable[0x80 | (c & 0x3f)];
+      continue;
+    }
+    if (c < 0xd800 || c >= 0xe000) {
+      lastPos = i + 1;
+      out += hexTable[0xe0 | (c >> 12)] + hexTable[0x80 | ((c >> 6) & 0x3f)] + hexTable[0x80 | (c & 0x3f)];
+      continue;
+    }
+    // Surrogate pair
+    ++i;
+
+    if (i >= len) throw $ERR_INVALID_URI();
+
+    const c2 = str.$charCodeAt(i) & 0x3ff;
+
+    lastPos = i + 1;
+    c = 0x10000 + (((c & 0x3ff) << 10) | c2);
+    out +=
+      hexTable[0xf0 | (c >> 18)] +
+      hexTable[0x80 | ((c >> 12) & 0x3f)] +
+      hexTable[0x80 | ((c >> 6) & 0x3f)] +
+      hexTable[0x80 | (c & 0x3f)];
+  }
+  if (lastPos === 0) return str;
+  if (lastPos < len) return out + str.slice(lastPos);
+  return out;
+}
+
 function isIpv6Hostname(hostname: string) {
   return (
     hostname.$charCodeAt(0) === Char.LEFT_SQUARE_BRACKET &&
@@ -465,8 +572,8 @@ function getHostname(self, rest, hostname: string, url) {
 }
 
 // format a parsed object into a url string
-declare function urlFormat(urlObject: string | URL | Url): string;
-function urlFormat(urlObject: unknown) {
+declare function urlFormat(urlObject: string | URL | Url, options?: object): string;
+function urlFormat(urlObject: unknown, options?: unknown) {
   /*
    * ensure it's an object, and not a string url.
    * If it's an obj, this is a no-op.
@@ -478,6 +585,33 @@ function urlFormat(urlObject: unknown) {
     // NOTE: $isObject returns true for functions
   } else if (typeof urlObject !== "object" || urlObject === null) {
     throw $ERR_INVALID_ARG_TYPE("urlObject", ["Object", "string"], urlObject);
+  } else if (urlObject instanceof URL) {
+    let fragment = true;
+    let unicode = false;
+    let search = true;
+    let auth = true;
+
+    if (options) {
+      validateObject(options, "options");
+
+      if ((options as any).fragment != null) {
+        fragment = Boolean((options as any).fragment);
+      }
+
+      if ((options as any).unicode != null) {
+        unicode = Boolean((options as any).unicode);
+      }
+
+      if ((options as any).search != null) {
+        search = Boolean((options as any).search);
+      }
+
+      if ((options as any).auth != null) {
+        auth = Boolean((options as any).auth);
+      }
+    }
+
+    return formatWhatwgURL(urlObject, fragment, unicode, search, auth);
   }
 
   if (!(urlObject instanceof Url)) {
@@ -486,11 +620,47 @@ function urlFormat(urlObject: unknown) {
   return urlObject.format();
 }
 
+// Mirrors Node's internal WHATWG URL formatter (bindingUrl.format).
+function formatWhatwgURL(url: URL, fragment: boolean, unicode: boolean, search: boolean, auth: boolean) {
+  const href = url.href;
+  // With everything kept, the serialization is exactly the href.
+  if (fragment && !unicode && search && auth) return href;
+  let ret = url.protocol;
+  // file:/// and foo:// have an empty-but-present host; the href carries
+  // the authority marker the components can't express.
+  if (href.startsWith(ret + "//")) {
+    ret += "//";
+    const hasUsername = url.username !== "";
+    const hasPassword = url.password !== "";
+    if (auth && (hasUsername || hasPassword)) {
+      if (hasUsername) ret += url.username;
+      if (hasPassword) ret += ":" + url.password;
+      ret += "@";
+    }
+    // On ToUnicode failure ada keeps the host as-is; never erase it.
+    ret += unicode ? domainToUnicode(url.hostname) || url.hostname : url.hostname;
+    const { port } = url;
+    if (port !== "") ret += ":" + port;
+  } else if (url.pathname.startsWith("//")) {
+    // URL Standard section 4.5 step 3: null host + empty first path segment
+    // gets a /. guard so the output does not re-parse as an authority.
+    ret += "/.";
+  }
+  ret += url.pathname;
+  // .search/.hash return "" for both null and empty-string components, but the href serializer
+  // emits the bare "?"/"#" for empty-but-present; derive presence from the href like node does.
+  // https://url.spec.whatwg.org/#url-serializing
+  const hashAt = href.indexOf("#");
+  const queryEnd = hashAt === -1 ? href.length : hashAt;
+  if (search) ret += url.search || (href[queryEnd - 1] === "?" ? "?" : "");
+  if (fragment) ret += url.hash || (hashAt !== -1 ? "#" : "");
+  return ret;
+}
+
 Url.prototype.format = function format() {
   var auth: string = this.auth || "";
   if (auth) {
-    auth = encodeURIComponent(auth);
-    auth = auth.replace(/%3A/i, ":");
+    auth = encodeStr(auth, noEscapeAuth, hexTable);
     auth += "@";
   }
 
@@ -500,12 +670,17 @@ Url.prototype.format = function format() {
     host = "",
     query = "";
 
+  if (protocol && protocol.substr(-1) !== ":") {
+    protocol += ":";
+  }
+
   const thisHost = this.host;
   let thisHostname;
   if (thisHost) {
     host = auth + thisHost;
   } else if ((thisHostname = this.hostname)) {
-    host = auth + (thisHostname.indexOf(":") === -1 ? thisHostname : "[" + thisHostname + "]");
+    host =
+      auth + (thisHostname.includes(":") && !isIpv6Hostname(thisHostname) ? "[" + thisHostname + "]" : thisHostname);
     const thisPort = this.port;
     if (thisPort) {
       host += ":" + thisPort;
@@ -519,21 +694,21 @@ Url.prototype.format = function format() {
 
   var search = this.search || (query && "?" + query) || "";
 
-  if (protocol && protocol.substr(-1) !== ":") {
-    protocol += ":";
-  }
-
   /*
    * only the slashedProtocols get the //.  Not mailto:, xmpp:, etc.
    * unless they had them to begin with.
    */
-  if (this.slashes || ((!protocol || slashedProtocol[protocol]) && host.length > 0)) {
-    host = "//" + (host || "");
-    if (pathname && pathname.charAt(0) !== "/") {
-      pathname = "/" + pathname;
+  const { slashes } = this;
+  if (slashes || slashedProtocol[protocol]) {
+    if (slashes || host) {
+      if (pathname && pathname.charAt(0) !== "/") {
+        pathname = "/" + pathname;
+      }
+      host = "//" + host;
+    } else if (protocol.startsWith("file")) {
+      // Node special-cases hostless file: URLs to keep the // marker.
+      host = "//";
     }
-  } else if (!host) {
-    host = "";
   }
 
   if (hash && hash.charAt(0) !== "#") {
@@ -936,10 +1111,181 @@ const enum Char {
   PERCENT = 37,              // %
   LEFT_SQUARE_BRACKET = 91,  // [
   RIGHT_SQUARE_BRACKET = 93, // ]
+  DOUBLE_QUOTE = 34,         // "
+  SINGLE_QUOTE = 39,         // '
+  SEMICOLON = 59,            // ;
+  LEFT_ANGLE_BRACKET = 60,   // <
+  RIGHT_ANGLE_BRACKET = 62,  // >
+  CIRCUMFLEX_ACCENT = 94,    // ^
+  GRAVE_ACCENT = 96,         // `
+  LEFT_CURLY_BRACKET = 123,  // {
+  VERTICAL_LINE = 124,       // |
+  RIGHT_CURLY_BRACKET = 125, // }
 
   // whitespace
-  NO_BREAK_SPACE = 160,             // \u00A0
-  ZERO_WIDTH_NOBREAK_SPACE = 65279, // \uFEFF
+  TAB = 9,                          // \t
+  LINE_FEED = 10,                   // \n
+  CARRIAGE_RETURN = 13,             // \r
+  SPACE = 32,                       // ' '
+  NO_BREAK_SPACE = 160,             //
+  ZERO_WIDTH_NOBREAK_SPACE = 65279, //
+}
+
+const path = require("node:path");
+const isWindows = process.platform === "win32";
+
+// Mirrors the pre-encode table in node's src/node_url.cc EncodePathChars();
+// the URL parser then applies the WHATWG path percent-encode set to the rest.
+const encodePathCharsRe = /[\0\t\n\r "#%?[\\\]^|~]/g;
+const encodePathCharsMap = {
+  __proto__: null,
+  "\0": "%00",
+  "\t": "%09",
+  "\n": "%0A",
+  "\r": "%0D",
+  " ": "%20",
+  '"': "%22",
+  "#": "%23",
+  "%": "%25",
+  "?": "%3F",
+  "[": "%5B",
+  "\\": "%5C",
+  "]": "%5D",
+  "^": "%5E",
+  "|": "%7C",
+  "~": "%7E",
+};
+
+function encodeWindowsPathChar(ch: string) {
+  return ch === "\\" ? "/" : encodePathCharsMap[ch];
+}
+function encodePosixPathChar(ch: string) {
+  return encodePathCharsMap[ch];
+}
+
+// Equivalent of node's bindingUrl.pathToFileURL (src/node_url.cc).
+function createFileURL(filepath: string, windows: boolean, hostname?: string) {
+  let outURL: URL;
+  try {
+    outURL = new URL(
+      "file://" + filepath.replace(encodePathCharsRe, windows ? encodeWindowsPathChar : encodePosixPathChar),
+    );
+  } catch {
+    throw $ERR_INVALID_URL(filepath);
+  }
+  if (hostname !== undefined) {
+    // The WHATWG hostname setter is silent on failure; node throws when ada's
+    // set_hostname() fails. Probe with the parser, which does throw.
+    try {
+      new URL("file://" + hostname + "/");
+    } catch {
+      throw $ERR_INVALID_URL(filepath, hostname);
+    }
+    outURL.hostname = hostname;
+  }
+  return outURL;
+}
+
+function pathToFileURL(filepath: string, options?: { windows?: boolean } | null) {
+  validateString(filepath, "path");
+  const windows = options?.windows ?? isWindows;
+  const isUNC = windows && filepath.startsWith("\\\\");
+  let resolved = isUNC ? filepath : windows ? path.win32.resolve(filepath) : path.posix.resolve(filepath);
+  if (isUNC || (windows && resolved.startsWith("\\\\"))) {
+    // UNC path format: \\server\share\resource
+    // "\\?\UNC\" extended UNC path prefix is ignored.
+    const isExtendedUNC = resolved.startsWith("\\\\?\\UNC\\");
+    const prefixLength = isExtendedUNC ? 8 : 2;
+    const hostnameEndIndex = resolved.indexOf("\\", prefixLength);
+    if (hostnameEndIndex === -1) {
+      throw $ERR_INVALID_ARG_VALUE("path", resolved, "Missing UNC resource path");
+    }
+    if (hostnameEndIndex === prefixLength) {
+      throw $ERR_INVALID_ARG_VALUE("path", resolved, "Empty UNC servername");
+    }
+    const hostname = resolved.slice(prefixLength, hostnameEndIndex);
+    return createFileURL(resolved.slice(hostnameEndIndex), true, hostname);
+  }
+  // path.resolve strips trailing slashes so we must add them back
+  const filePathLast = filepath.charCodeAt(filepath.length - 1);
+  if (
+    (filePathLast === Char.FORWARD_SLASH || (windows && filePathLast === Char.BACKWARD_SLASH)) &&
+    resolved[resolved.length - 1] !== path.sep
+  ) {
+    resolved += "/";
+  }
+  return createFileURL(resolved, windows);
+}
+
+// Ports of node's getPathFromURLWin32/getPathFromURLPosix
+// (lib/internal/url.js), used when the `windows` option is explicit; the
+// host-platform path stays on the native fast path below.
+function getPathFromURLWin32(url: URL): string {
+  const hostname = url.hostname;
+  let pathname = url.pathname;
+  for (let n = 0; n < pathname.length; n++) {
+    if (pathname[n] === "%") {
+      const third = (pathname.codePointAt(n + 2)! | 0x20) as number;
+      if ((pathname[n + 1] === "2" && third === 102) || (pathname[n + 1] === "5" && third === 99)) {
+        throw $ERR_INVALID_FILE_URL_PATH("File URL path must not include encoded \\ or / characters");
+      }
+    }
+  }
+  pathname = pathname.replace(/\//g, "\\");
+  pathname = decodeURIComponent(pathname);
+  if (hostname !== "") {
+    // UNC path: \\hostname\path
+    return `\\\\${domainToUnicode(hostname)}${pathname}`;
+  }
+  const letter = (pathname.codePointAt(1)! | 0x20) as number;
+  const sep = pathname[2];
+  if (letter < 0x61 /* a */ || letter > 0x7a /* z */ || sep !== ":") {
+    throw $ERR_INVALID_FILE_URL_PATH("File URL path must be absolute");
+  }
+  return pathname.slice(1);
+}
+
+function getPathFromURLPosix(url: URL): string {
+  if (url.hostname !== "") {
+    throw $ERR_INVALID_FILE_URL_HOST(`File URL host must be "localhost" or empty on ${process.platform}`);
+  }
+  const pathname = url.pathname;
+  for (let n = 0; n < pathname.length; n++) {
+    if (pathname[n] === "%") {
+      const third = (pathname.codePointAt(n + 2)! | 0x20) as number;
+      if (pathname[n + 1] === "2" && third === 102) {
+        throw $ERR_INVALID_FILE_URL_PATH("File URL path must not include encoded / characters");
+      }
+    }
+  }
+  return decodeURIComponent(pathname);
+}
+
+function fileURLToPath(url: string | URL, options?: { windows?: boolean }) {
+  const windows = options?.windows;
+  if (windows !== undefined && windows !== null) {
+    let parsed: URL;
+    if (typeof url === "string") {
+      parsed = new URL(url);
+    } else if (url instanceof URL) {
+      parsed = url;
+    } else {
+      throw $ERR_INVALID_ARG_TYPE("path", ["string", "URL"], url);
+    }
+    if (parsed.protocol !== "file:") {
+      throw $ERR_INVALID_URL_SCHEME("file");
+    }
+    return windows ? getPathFromURLWin32(parsed) : getPathFromURLPosix(parsed);
+  }
+  try {
+    return Bun.fileURLToPath(url as any);
+  } catch (err: any) {
+    // node attaches the parsed URL as err.input on this code (lib/internal/errors.js).
+    if (err?.code === "ERR_INVALID_FILE_URL_PATH") {
+      err.input = typeof url === "string" ? new URL(url) : url;
+    }
+    throw err;
+  }
 }
 
 // Port of Node.js fileURLToPathBuffer
@@ -1027,8 +1373,11 @@ export default {
   Url,
   URLSearchParams,
   URL,
-  pathToFileURL: Bun.pathToFileURL,
-  fileURLToPath: Bun.fileURLToPath,
+  URLPattern,
+  // The node-parity implementations (UNC/backslash/err.input fidelity), not
+  // the Bun.* globals, which stay unchanged.
+  pathToFileURL,
+  fileURLToPath,
   fileURLToPathBuffer,
   urlToHttpOptions,
   domainToASCII,
diff --git a/src/js/node/util.ts b/src/js/node/util.ts
index b00362b6e81f..df41487dcff3 100644
--- a/src/js/node/util.ts
+++ b/src/js/node/util.ts
@@ -10,11 +10,12 @@ const {
   validateObject,
   validateInteger,
 } = require("internal/validators");
-const { resistStopPropagation } = require("internal/shared");
+const { resistStopPropagation, ErrnoException } = require("internal/shared");
 const { MIMEType, MIMEParams } = require("internal/util/mime");
 const { deprecate } = require("internal/util/deprecate");
 
 const internalErrorName = $newRustFunction("node_util_binding.rs", "internalErrorName", 1);
+const internalErrorEntries = $newRustFunction("node_util_binding.rs", "internalErrorEntries", 0);
 const parseEnv = $newRustFunction("node_util_binding.rs", "parseEnv", 1);
 
 const NumberIsSafeInteger = Number.isSafeInteger;
@@ -32,10 +33,10 @@ function isFunction(value) {
   return typeof value === "function";
 }
 
-const deepEquals = Bun.deepEquals;
-function isDeepStrictEqual(a, b, skipPrototype) {
-  return deepEquals(a, b, true, skipPrototype);
-}
+// Node semantics (includes the [[Prototype]] identity check Bun.deepEquals omits) plus the
+// skipPrototype third argument, which is public API in node v26.3.0 (fn.length === 3).
+// https://github.com/nodejs/node/blob/main/lib/internal/util/comparisons.js
+const { isDeepStrictEqual } = require("internal/util/comparisons");
 
 const parseArgs = $newRustFunction("parse_args.rs", "parseArgs", 1);
 
@@ -408,6 +409,134 @@ function getSystemErrorName(err: any) {
   return internalErrorName(err);
 }
 
+// libuv's uv_strerror() messages keyed by error name (target-independent).
+// The per-target codes come from the native uv_e table (internalErrorEntries).
+const uvErrorMessages = {
+  __proto__: null,
+  E2BIG: "argument list too long",
+  EACCES: "permission denied",
+  EADDRINUSE: "address already in use",
+  EADDRNOTAVAIL: "address not available",
+  EAFNOSUPPORT: "address family not supported",
+  EAGAIN: "resource temporarily unavailable",
+  EAI_ADDRFAMILY: "address family not supported",
+  EAI_AGAIN: "temporary failure",
+  EAI_BADFLAGS: "bad ai_flags value",
+  EAI_BADHINTS: "invalid value for hints",
+  EAI_CANCELED: "request canceled",
+  EAI_FAIL: "permanent failure",
+  EAI_FAMILY: "ai_family not supported",
+  EAI_MEMORY: "out of memory",
+  EAI_NODATA: "no address",
+  EAI_NONAME: "unknown node or service",
+  EAI_OVERFLOW: "argument buffer overflow",
+  EAI_PROTOCOL: "resolved protocol is unknown",
+  EAI_SERVICE: "service not available for socket type",
+  EAI_SOCKTYPE: "socket type not supported",
+  EALREADY: "connection already in progress",
+  EBADF: "bad file descriptor",
+  EBUSY: "resource busy or locked",
+  ECANCELED: "operation canceled",
+  ECHARSET: "invalid Unicode character",
+  ECONNABORTED: "software caused connection abort",
+  ECONNREFUSED: "connection refused",
+  ECONNRESET: "connection reset by peer",
+  EDESTADDRREQ: "destination address required",
+  EEXIST: "file already exists",
+  EFAULT: "bad address in system call argument",
+  EFBIG: "file too large",
+  EHOSTUNREACH: "host is unreachable",
+  EINTR: "interrupted system call",
+  EINVAL: "invalid argument",
+  EIO: "i/o error",
+  EISCONN: "socket is already connected",
+  EISDIR: "illegal operation on a directory",
+  ELOOP: "too many symbolic links encountered",
+  EMFILE: "too many open files",
+  EMSGSIZE: "message too long",
+  ENAMETOOLONG: "name too long",
+  ENETDOWN: "network is down",
+  ENETUNREACH: "network is unreachable",
+  ENFILE: "file table overflow",
+  ENOBUFS: "no buffer space available",
+  ENODEV: "no such device",
+  ENOENT: "no such file or directory",
+  ENOMEM: "not enough memory",
+  ENONET: "machine is not on the network",
+  ENOPROTOOPT: "protocol not available",
+  ENOSPC: "no space left on device",
+  ENOSYS: "function not implemented",
+  ENOTCONN: "socket is not connected",
+  ENOTDIR: "not a directory",
+  ENOTEMPTY: "directory not empty",
+  ENOTSOCK: "socket operation on non-socket",
+  ENOTSUP: "operation not supported on socket",
+  EOVERFLOW: "value too large for defined data type",
+  EPERM: "operation not permitted",
+  EPIPE: "broken pipe",
+  EPROTO: "protocol error",
+  EPROTONOSUPPORT: "protocol not supported",
+  EPROTOTYPE: "protocol wrong type for socket",
+  ERANGE: "result too large",
+  EROFS: "read-only file system",
+  ESHUTDOWN: "cannot send after transport endpoint shutdown",
+  ESPIPE: "invalid seek",
+  ESRCH: "no such process",
+  ETIMEDOUT: "connection timed out",
+  ETXTBSY: "text file is busy",
+  EXDEV: "cross-device link not permitted",
+  UNKNOWN: "unknown error",
+  EOF: "end of file",
+  ENXIO: "no such device or address",
+  EMLINK: "too many links",
+  EHOSTDOWN: "host is down",
+  EREMOTEIO: "remote I/O error",
+  ENOTTY: "inappropriate ioctl for device",
+  EFTYPE: "inappropriate file type or format",
+  EILSEQ: "illegal byte sequence",
+  ESOCKTNOSUPPORT: "socket type not supported",
+  ENODATA: "no data available",
+  EUNATCH: "protocol driver not attached",
+  ENOEXEC: "exec format error",
+};
+
+let uvErrmap: Map<number, [string, string]> | undefined;
+function getUvErrmap() {
+  if (uvErrmap === undefined) {
+    uvErrmap = new Map();
+    const flat = internalErrorEntries();
+    for (let i = 0; i < flat.length; i += 2) {
+      const code = flat[i];
+      const name = flat[i + 1];
+      if (!uvErrmap.has(code)) uvErrmap.set(code, [name, uvErrorMessages[name] ?? name]);
+    }
+  }
+  return uvErrmap;
+}
+
+function getSystemErrorMap() {
+  // Fresh Map with fresh entry arrays: node's binding materialises a new map
+  // per call, and callers may mutate the [name, message] pairs.
+  const copy = new Map();
+  for (const [code, entry] of getUvErrmap()) {
+    copy.set(code, [entry[0], entry[1]]);
+  }
+  return copy;
+}
+
+function getSystemErrorMessage(err: any) {
+  if (typeof err !== "number") throw $ERR_INVALID_ARG_TYPE("err", "number", err);
+  if (err >= 0 || !NumberIsSafeInteger(err)) throw $ERR_OUT_OF_RANGE("err", "a negative integer", err);
+  const entry = getUvErrmap().get(err);
+  return entry !== undefined ? entry[1] : `Unknown system error ${err}`;
+}
+
+function _errnoException(err: any, syscall: string, original?: string) {
+  // ErrnoException validates err via getSystemErrorName (type + range) and
+  // builds node's exact `${syscall} ${code}[ ${original}]` shape.
+  return new ErrnoException(err, syscall, original);
+}
+
 function prepareCallSites(_err, callSites) {
   const result = [];
   for (let i = 0; i < callSites.length; i++) {
@@ -561,7 +690,7 @@ function setTraceSigInt(enable) {
 
 cjs_exports = {
   // This is in order of `node --print 'Object.keys(util)'`
-  // _errnoException,
+  _errnoException,
   // _exceptionWithHostPort,
   _extend,
   callbackify,
@@ -573,9 +702,9 @@ cjs_exports = {
   styleText,
   formatWithOptions,
   getCallSites,
-  // getSystemErrorMap,
+  getSystemErrorMap,
   getSystemErrorName,
-  // getSystemErrorMessage,
+  getSystemErrorMessage,
   inherits,
   inspect,
   isDeepStrictEqual,
diff --git a/src/js/node/v8.ts b/src/js/node/v8.ts
index b58ec65a28a1..5e03eee4584c 100644
--- a/src/js/node/v8.ts
+++ b/src/js/node/v8.ts
@@ -2,7 +2,9 @@
 
 // This is a stub! None of this is actually implemented yet.
 const { hideFromStack, throwNotImplemented } = require("internal/shared");
-const { validateString } = require("internal/validators");
+const { validateString, validateOneOf } = require("internal/validators");
+const { uncurryThis } = require("internal/primordials");
+const { isDataView, isAnyArrayBuffer } = require("node:util/types");
 const jsc: typeof import("bun:jsc") = require("bun:jsc");
 const { isStringOneByteRepresentation, startGCProfiler, stopGCProfiler, discardGCProfiler } = $cpp(
   "NodeV8.cpp",
@@ -10,6 +12,22 @@ const { isStringOneByteRepresentation, startGCProfiler, stopGCProfiler, discardG
 );
 
 const DateNow = Date.now;
+const ObjectGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+const Uint8ArrayCtor = Uint8Array;
+const BufferAllocUnsafe = Buffer.allocUnsafe;
+const TypedArrayProto = Object.getPrototypeOf(Uint8ArrayCtor.prototype);
+const TypedArrayPrototypeGetBuffer = uncurryThis(ObjectGetOwnPropertyDescriptor(TypedArrayProto, "buffer").get);
+const TypedArrayPrototypeGetByteOffset = uncurryThis(ObjectGetOwnPropertyDescriptor(TypedArrayProto, "byteOffset").get);
+const TypedArrayPrototypeGetByteLength = uncurryThis(ObjectGetOwnPropertyDescriptor(TypedArrayProto, "byteLength").get);
+const TypedArrayPrototypeSet = uncurryThis(TypedArrayProto.set);
+const DataViewPrototypeGetBuffer = uncurryThis(ObjectGetOwnPropertyDescriptor(DataView.prototype, "buffer").get);
+const DataViewPrototypeGetByteOffset = uncurryThis(
+  ObjectGetOwnPropertyDescriptor(DataView.prototype, "byteOffset").get,
+);
+const DataViewPrototypeGetByteLength = uncurryThis(
+  ObjectGetOwnPropertyDescriptor(DataView.prototype, "byteLength").get,
+);
+const Uint8ArrayPrototypeSubarray = uncurryThis(Uint8ArrayCtor.prototype.subarray);
 
 function notimpl(message) {
   throwNotImplemented("node:v8 " + message);
@@ -114,8 +132,14 @@ class GCProfiler {
   }
 }
 
+// Node derives this tag from the V8 version, command-line flags, and CPU
+// features; Bun mirrors that with its own version plus the flags recorded by
+// setFlagsFromString, so the tag is stable until the flags change.
+let versionTagFlags = "";
+let versionTag: number | undefined;
 function cachedDataVersionTag() {
-  notimpl("cachedDataVersionTag");
+  versionTag ??= Bun.hash.crc32(`bun ${Bun.version}-${Bun.revision}${versionTagFlags}`);
+  return versionTag;
 }
 var HeapSnapshotReadable_;
 function getHeapSnapshot() {
@@ -158,6 +182,7 @@ function getHeapStatistics() {
     total_physical_size: memory.peak,
     total_available_size: totalmem() - stats.heapSize,
     used_heap_size: stats.heapSize,
+    total_allocated_bytes: stats.heapCapacity,
     heap_size_limit: Math.min(memory.peak * 10, totalmem()),
     malloced_memory: stats.heapSize,
     peak_malloced_memory: memory.peak,
@@ -173,19 +198,114 @@ function getHeapStatistics() {
     external_memory: stats.extraMemorySize,
   };
 }
+// V8 divides its heap into fixed spaces; JSC manages one undivided heap, so
+// the JSC totals are reported under "old_space" and the other V8 space names
+// exist for shape compatibility.
+const kHeapSpaces = [
+  "read_only_space",
+  "new_space",
+  "old_space",
+  "code_space",
+  "shared_space",
+  "trusted_space",
+  "new_large_object_space",
+  "large_object_space",
+  "code_large_object_space",
+  "shared_large_object_space",
+  "shared_trusted_space",
+  "shared_trusted_large_object_space",
+  "trusted_large_object_space",
+];
 function getHeapSpaceStatistics() {
-  notimpl("getHeapSpaceStatistics");
+  const stats = jsc.heapStats();
+  const spaces = [];
+  for (let i = 0; i < kHeapSpaces.length; i++) {
+    const space_name = kHeapSpaces[i];
+    const isHeap = space_name === "old_space";
+    const used = isHeap ? stats.heapSize : 0;
+    const size = isHeap ? stats.heapCapacity : 0;
+    $arrayPush(spaces, {
+      space_name,
+      space_size: size,
+      space_used_size: used,
+      space_available_size: size > used ? size - used : 0,
+      physical_space_size: size,
+    });
+  }
+  return spaces;
 }
+// JSC does not expose a per-category code size breakdown; report zeros rather
+// than invented numbers, like node does for counters V8 is not tracking
+// (e.g. cpu_profiler_metadata_size).
 function getHeapCodeStatistics() {
-  notimpl("getHeapCodeStatistics");
+  return {
+    code_and_metadata_size: 0,
+    bytecode_and_metadata_size: 0,
+    external_script_source_size: 0,
+    cpu_profiler_metadata_size: 0,
+  };
 }
 function setFlagsFromString(flags) {
-  // Validate before reporting the gap: node rejects a non-string argument
-  // regardless of whether the flag itself can be applied.
   validateString(flags, "flags");
-  notimpl("setFlagsFromString");
+  // V8 flags have no JSC equivalent; record them so cachedDataVersionTag
+  // changes like node's does, and otherwise ignore them.
+  versionTagFlags += ` ${flags}`;
+  versionTag = undefined;
 }
+// Bun has no cppgc (Oilpan) C++ heap, so the statistics are always empty;
+// this matches node's shape with nothing allocated through cppgc.
+function getCppHeapStatistics(type = "detailed") {
+  validateOneOf(type, "type", ["brief", "detailed"]);
+  return {
+    committed_size_bytes: 0,
+    resident_size_bytes: 0,
+    used_size_bytes: 0,
+    space_statistics: [],
+    type_names: [],
+    detail_level: type,
+  };
+}
+// Buffer-bearing payloads are framed as MAGIC + version + SSV([value, buffers]) so deserialize
+// can restore Buffer prototypes (see internal/serialization_buffers). Leading 0xFF cannot collide
+// with bare SSV output; Buffer-free payloads stay bare SSV so older readers keep working.
+const kBufferEnvelopeMagic = [0xff, 0x42, 0x55, 0x4e, 0x01]; // 0xFF "BUN" v1
+
+function hasBufferEnvelopeMagic(view) {
+  // In-bounds integer-indexed reads on a typed array never consult the
+  // prototype chain, so the indexing is tamper-proof as-is.
+  if (TypedArrayPrototypeGetByteLength(view) < kBufferEnvelopeMagic.length) return false;
+  for (let i = 0; i < kBufferEnvelopeMagic.length; i++) {
+    if (view[i] !== kBufferEnvelopeMagic[i]) return false;
+  }
+  return true;
+}
+
 function deserialize(value) {
+  let view;
+  if ($isTypedArrayView(value)) {
+    view = new Uint8ArrayCtor(
+      TypedArrayPrototypeGetBuffer(value),
+      TypedArrayPrototypeGetByteOffset(value),
+      TypedArrayPrototypeGetByteLength(value),
+    );
+  } else if (isDataView(value)) {
+    // $isTypedArrayView excludes DataView, whose accessors live on its own
+    // prototype rather than %TypedArray%.prototype.
+    view = new Uint8ArrayCtor(
+      DataViewPrototypeGetBuffer(value),
+      DataViewPrototypeGetByteOffset(value),
+      DataViewPrototypeGetByteLength(value),
+    );
+  } else if (isAnyArrayBuffer(value)) {
+    view = new Uint8ArrayCtor(value);
+  } else {
+    // Let jsc.deserialize validate and reject non-buffer input itself.
+    return jsc.deserialize(value);
+  }
+  if (hasBufferEnvelopeMagic(view)) {
+    const envelope = jsc.deserialize(Uint8ArrayPrototypeSubarray(view, kBufferEnvelopeMagic.length));
+    return require("internal/serialization_buffers").restoreBuffers(envelope);
+  }
   return jsc.deserialize(value);
 }
 function takeCoverage() {
@@ -195,7 +315,15 @@ function stopCoverage() {
   notimpl("stopCoverage");
 }
 function serialize(arg1) {
-  return jsc.serialize(arg1, { binaryType: "nodebuffer" });
+  const tagged = require("internal/serialization_buffers").tagBuffers(arg1);
+  if (tagged === null) {
+    return jsc.serialize(arg1, { binaryType: "nodebuffer" });
+  }
+  const payload = jsc.serialize(tagged, { binaryType: "nodebuffer" });
+  const framed = BufferAllocUnsafe(kBufferEnvelopeMagic.length + TypedArrayPrototypeGetByteLength(payload));
+  for (let i = 0; i < kBufferEnvelopeMagic.length; i++) framed[i] = kBufferEnvelopeMagic[i];
+  TypedArrayPrototypeSet(framed, payload, kBufferEnvelopeMagic.length);
+  return framed;
 }
 
 function getDefaultHeapSnapshotPath() {
@@ -240,6 +368,10 @@ function writeHeapSnapshot(path, _options) {
 function setHeapSnapshotNearHeapLimit() {
   notimpl("setHeapSnapshotNearHeapLimit");
 }
+function throwNotBuildingSnapshot() {
+  throw $ERR_NOT_BUILDING_SNAPSHOT("Operation cannot be invoked when not building startup snapshot");
+}
+
 const promiseHooks = {
     createHook: () => {
       notimpl("createHook");
@@ -258,9 +390,9 @@ const promiseHooks = {
     },
   },
   startupSnapshot = {
-    addDeserializeCallback: () => notimpl("addDeserializeCallback"),
-    addSerializeCallback: () => notimpl("addSerializeCallback"),
-    setDeserializeMainFunction: () => notimpl("setDeserializeMainFunction"),
+    addDeserializeCallback: throwNotBuildingSnapshot,
+    addSerializeCallback: throwNotBuildingSnapshot,
+    setDeserializeMainFunction: throwNotBuildingSnapshot,
     // Bun never builds a V8 startup snapshot, so this is always false, matching
     // Node's behavior during normal execution.
     isBuildingSnapshot: () => false,
@@ -274,6 +406,7 @@ export default {
   getHeapStatistics,
   getHeapSpaceStatistics,
   getHeapCodeStatistics,
+  getCppHeapStatistics,
   setFlagsFromString,
   deserialize,
   takeCoverage,
@@ -291,11 +424,13 @@ export default {
 
 hideFromStack(
   notimpl,
+  throwNotBuildingSnapshot,
   cachedDataVersionTag,
   getHeapSnapshot,
   getHeapStatistics,
   getHeapSpaceStatistics,
   getHeapCodeStatistics,
+  getCppHeapStatistics,
   setFlagsFromString,
   deserialize,
   takeCoverage,
diff --git a/src/js_parser/parse/mod.rs b/src/js_parser/parse/mod.rs
index c32eca6e0e39..7b3519a9ba8a 100644
--- a/src/js_parser/parse/mod.rs
+++ b/src/js_parser/parse/mod.rs
@@ -1488,7 +1488,10 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
                                 if p.current_scope == p.module_scope {
                                     p.module_scope_directive_loc = stmt.loc;
                                 }
-                            } else if str_.eql_comptime(b"use asm") {
+                            } else if str_.eql_comptime(b"use asm") && !p.options.repl_mode {
+                                // In the REPL the directive stays a string
+                                // statement so it evaluates as the result,
+                                // like node ('use asm' prints 'use asm').
                                 skip = true;
                                 stmt.data = js_ast::stmt::Data::SEmpty(S::Empty {});
                             } else {
diff --git a/src/js_parser/repl_transforms.rs b/src/js_parser/repl_transforms.rs
index 90f59f477bbe..06fcfb00fd57 100644
--- a/src/js_parser/repl_transforms.rs
+++ b/src/js_parser/repl_transforms.rs
@@ -37,12 +37,30 @@ impl<'a, const TS: bool, const SCAN: bool> P<'a, TS, SCAN> {
             total_stmts_count += part.stmts.len();
         }
 
+        // A prologue "use strict" was consumed into module-scope strict mode and dropped, but
+        // node's repl still evaluates the directive as a string expression. Reinject it at the
+        // front, like the CJS wrapper's preserve_strict_mode.
+        let reinject_strict = self.module_scope().strict_mode
+            == js_ast::StrictModeKind::ExplicitStrictMode
+            && !(!parts.is_empty()
+                && !parts[0].stmts.is_empty()
+                && matches!(parts[0].stmts[0].data, StmtData::SDirective(_)));
+        total_stmts_count += usize::from(reinject_strict);
+
         if total_stmts_count == 0 {
             return Ok(());
         }
 
         // Collect all statements into a single array
         let mut all_stmts = BumpVec::with_capacity_in(total_stmts_count, bump);
+        if reinject_strict {
+            all_stmts.push(self.s(
+                S::Directive {
+                    value: b"use strict".into(),
+                },
+                self.module_scope_directive_loc,
+            ));
+        }
         for part in parts.iter() {
             for stmt in part.stmts.iter() {
                 all_stmts.push(*stmt);
@@ -507,8 +525,15 @@ impl<'a, const TS: bool, const SCAN: bool> P<'a, TS, SCAN> {
         ));
         let final_slice: &mut [Stmt] = final_stmts.into_bump_slice_mut();
 
-        // Update parts
-        if !parts.is_empty() {
+        // Update parts. Input consisting solely of a consumed "use strict"
+        // prologue arrives with no parts at all — create one so the
+        // reinjected directive's IIFE isn't dropped.
+        if parts.is_empty() {
+            parts.push(js_ast::Part {
+                stmts: bun_ast::StoreSlice::new_mut(final_slice),
+                ..Default::default()
+            });
+        } else {
             parts[0].stmts = bun_ast::StoreSlice::new_mut(final_slice);
             parts.truncate(1);
         }
diff --git a/src/jsc/BunCPUProfiler.rs b/src/jsc/BunCPUProfiler.rs
index dd3979759af4..f854f1aecca7 100644
--- a/src/jsc/BunCPUProfiler.rs
+++ b/src/jsc/BunCPUProfiler.rs
@@ -56,7 +56,10 @@ unsafe extern "C" {
 }
 
 pub fn set_sampling_interval(interval: u32) {
-    Bun__setSamplingInterval(c_int::try_from(interval).expect("int cast"));
+    // Reachable from a Worker's execArgv: 0 stalls the sampler and the process
+    // never exits, and a value past c_int would panic the cast.
+    let clamped = interval.clamp(1, c_int::MAX as u32);
+    Bun__setSamplingInterval(clamped as c_int);
 }
 
 pub fn start_cpu_profiler(vm: &mut VM) {
@@ -181,7 +184,9 @@ fn build_output_path(
         path.join(&[config.dir])
             .map_err(|_| ProfilerError::FilenameTooLong)?;
     }
-    path.append(filename)
+
+    // `join` resolves an absolute --cpu-prof-name where `append` asserts on it.
+    path.join(&[filename])
         .map_err(|_| ProfilerError::FilenameTooLong)?;
 
     Ok(())
@@ -191,28 +196,82 @@ fn generate_default_filename(
     buf: &mut PathBuffer,
     md_format: bool,
 ) -> Result<&[u8], ProfilerError> {
-    // Generate filename like: CPU.{timestamp}.{pid}.cpuprofile (or .md for markdown format)
-    // Use microsecond timestamp for uniqueness
-    let timespec = bun_core::Timespec::now(bun_core::TimespecMockMode::ForceRealTime);
+    let extension: &str = if md_format { ".md" } else { ".cpuprofile" };
+    let mut cursor = std::io::Cursor::new(&mut buf[..]);
+    write_diagnostic_filename(&mut cursor, "CPU", extension)
+        .map_err(|_| ProfilerError::FilenameTooLong)?;
+    let len = usize::try_from(cursor.position()).expect("int cast");
+    Ok(&buf[..len])
+}
+
+/// Node's DiagnosticFilename: `<prefix>.<yyyymmdd>.<hhmmss>.<pid>.<tid>.<seq><extension>`.
+/// https://github.com/nodejs/node/blob/main/src/util.cc (MakeFilename)
+pub(crate) fn write_diagnostic_filename(
+    cursor: &mut dyn std::io::Write,
+    prefix: &str,
+    extension: &str,
+) -> std::io::Result<()> {
     #[cfg(windows)]
     let pid = bun_sys::windows::GetCurrentProcessId();
     #[cfg(not(windows))]
     // SAFETY: getpid() is always safe to call.
     let pid = unsafe { libc::getpid() };
 
-    let epoch_microseconds: u64 = u64::try_from(
-        timespec
-            .sec
-            .wrapping_mul(1_000_000)
-            .wrapping_add(timespec.nsec / 1000),
+    let (year, month, day, hour, minute, second) = local_time_now();
+
+    static SEQ: core::sync::atomic::AtomicU32 = core::sync::atomic::AtomicU32::new(0);
+    let seq = SEQ.fetch_add(1, core::sync::atomic::Ordering::Relaxed) + 1;
+
+    write!(
+        cursor,
+        "{prefix}.{year:04}{month:02}{day:02}.{hour:02}{minute:02}{second:02}.{pid}.0.{seq:03}{extension}"
     )
-    .unwrap();
+}
 
-    let extension: &str = if md_format { ".md" } else { ".cpuprofile" };
+#[cfg(not(windows))]
+pub(crate) fn local_time_now() -> (i32, u32, u32, u32, u32, u32) {
+    let secs = std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .map_or(0, |d| d.as_secs()) as libc::time_t;
+    let mut tm: libc::tm = bun_core::ffi::zeroed();
+    // SAFETY: localtime_r only writes into `tm` and is thread-safe.
+    unsafe { libc::localtime_r(&raw const secs, &raw mut tm) };
+    (
+        tm.tm_year + 1900,
+        (tm.tm_mon + 1) as u32,
+        tm.tm_mday as u32,
+        tm.tm_hour as u32,
+        tm.tm_min as u32,
+        tm.tm_sec as u32,
+    )
+}
 
-    let mut cursor = std::io::Cursor::new(&mut buf[..]);
-    write!(cursor, "CPU.{}.{}{}", epoch_microseconds, pid, extension)
-        .map_err(|_| ProfilerError::FilenameTooLong)?;
-    let len = usize::try_from(cursor.position()).expect("int cast");
-    Ok(&buf[..len])
+#[cfg(windows)]
+pub(crate) fn local_time_now() -> (i32, u32, u32, u32, u32, u32) {
+    #[repr(C)]
+    #[derive(Default)]
+    struct SystemTime {
+        year: u16,
+        month: u16,
+        day_of_week: u16,
+        day: u16,
+        hour: u16,
+        minute: u16,
+        second: u16,
+        milliseconds: u16,
+    }
+    unsafe extern "system" {
+        fn GetLocalTime(system_time: *mut SystemTime);
+    }
+    let mut st = SystemTime::default();
+    // SAFETY: GetLocalTime only writes the out-param (kernel32 SYSTEMTIME layout).
+    unsafe { GetLocalTime(&mut st) };
+    (
+        i32::from(st.year),
+        u32::from(st.month),
+        u32::from(st.day),
+        u32::from(st.hour),
+        u32::from(st.minute),
+        u32::from(st.second),
+    )
 }
diff --git a/src/jsc/BunHeapProfiler.rs b/src/jsc/BunHeapProfiler.rs
index 81a44e92c3d7..3169f067f2ea 100644
--- a/src/jsc/BunHeapProfiler.rs
+++ b/src/jsc/BunHeapProfiler.rs
@@ -1,5 +1,5 @@
 use crate::CrateError as Error;
-use bun_core::{Output, Timespec, TimespecMockMode};
+use bun_core::Output;
 use bun_core::{OwnedString, String as BunString};
 use bun_paths::{AutoAbsPathChecked, PathBuffer, resolve_path};
 use bun_sys::{self as sys, E, Fd, FdDirExt};
@@ -90,12 +90,15 @@ pub(crate) fn generate_and_write_profile(
         }
     }
 
-    // Print message to stderr to let user know where the profile was written
-    bun_core::pretty_errorln!(
-        "Heap profile written to: {}",
-        bstr::BStr::new(path_buf.slice())
-    );
-    Output::flush();
+    // Print where the markdown profile was written; node parity for the
+    // .heapprofile format is silence on success.
+    if config.text_format {
+        bun_core::pretty_errorln!(
+            "Heap profile written to: {}",
+            bstr::BStr::new(path_buf.slice())
+        );
+        Output::flush();
+    }
     Ok(())
 }
 
@@ -111,46 +114,20 @@ fn build_output_path(
         generate_default_filename(&mut filename_buf, config.text_format)?
     };
 
+    // Join directory and filename; `join` resolves absolute segments where
+    // `append` asserts on them (node accepts absolute --heap-prof-dir/-name).
     if !config.dir.is_empty() {
-        path.append(config.dir)?;
+        path.join(&[config.dir])?;
     }
-    path.append(filename)?;
+    path.join(&[filename])?;
     Ok(())
 }
 
 fn generate_default_filename(buf: &mut PathBuffer, text_format: bool) -> Result<&[u8], Error> {
-    // Generate filename like:
-    // - Markdown format: Heap.{timestamp}.{pid}.md
-    // - V8 format: Heap.{timestamp}.{pid}.heapsnapshot
-    let timespec = Timespec::now(TimespecMockMode::ForceRealTime);
-    #[cfg(windows)]
-    let pid: core::ffi::c_uint = bun_sys::windows::GetCurrentProcessId();
-    #[cfg(not(windows))]
-    // SAFETY: getpid() is always safe to call.
-    let pid: core::ffi::c_int = unsafe { libc::getpid() };
-
-    let epoch_microseconds: u64 = u64::try_from(
-        timespec
-            .sec
-            .wrapping_mul(1_000_000)
-            .wrapping_add(timespec.nsec / 1000),
-    )
-    .unwrap();
-
-    let extension: &str = if text_format { "md" } else { "heapsnapshot" };
-
-    // Write into the fixed buffer, then return the written slice
-    use std::io::Write;
-    let buf_slice = buf.as_mut_slice();
-    let total = buf_slice.len();
-    let mut cursor: &mut [u8] = buf_slice;
-    write!(
-        &mut cursor,
-        "Heap.{}.{}.{}",
-        epoch_microseconds, pid, extension
-    )
-    .map_err(|_| crate::CrateError::Sys(bun_errno::SystemErrno::ENOSPC))?;
-    let remaining = cursor.len();
-    let written = total - remaining;
+    let extension: &str = if text_format { ".md" } else { ".heapprofile" };
+    let mut cursor = std::io::Cursor::new(&mut buf[..]);
+    crate::bun_cpu_profiler::write_diagnostic_filename(&mut cursor, "Heap", extension)
+        .map_err(|_| crate::CrateError::Sys(bun_errno::SystemErrno::ENOSPC))?;
+    let written = usize::try_from(cursor.position()).expect("int cast");
     Ok(&buf.as_slice()[..written])
 }
diff --git a/src/jsc/CachedBytecode.rs b/src/jsc/CachedBytecode.rs
index b55fb292deea..c9b2056d4eb0 100644
--- a/src/jsc/CachedBytecode.rs
+++ b/src/jsc/CachedBytecode.rs
@@ -129,7 +129,7 @@ impl bun_alloc::Allocator for CachedBytecode {}
 /// Symbol is definer-prefixed (`__bun_jsc_*`) per LAYERING_AUDIT — the body is
 /// jsc-internal setup, not bundler logic.
 #[unsafe(no_mangle)]
-fn __bun_jsc_generate_cached_bytecode(
+pub(crate) fn __bun_jsc_generate_cached_bytecode(
     format: Format,
     source: &[u8],
     source_provider_url: &mut BunString,
diff --git a/src/jsc/NodeCompileCache.rs b/src/jsc/NodeCompileCache.rs
new file mode 100644
index 000000000000..de8299ea6352
--- /dev/null
+++ b/src/jsc/NodeCompileCache.rs
@@ -0,0 +1,1192 @@
+//! Node-compatible on-disk compile cache (`NODE_COMPILE_CACHE`): entries in a
+//! version-tagged subdir store the post-transpile source + JSC bytecode; the
+//! stored source is byte-compared on load so stale caches recompile normally.
+
+use core::sync::atomic::{AtomicBool, AtomicU8, Ordering};
+
+use bstr::ByteSlice;
+use bun_boringssl::c as boring;
+use bun_collections::{HashMap, IdentityContext};
+use bun_core::String as BunString;
+use bun_core::{Mutex, ZStr, env_var};
+use bun_options_types::Format;
+use bun_paths::{MAX_PATH_BYTES, PathBuffer, SEP};
+use bun_sys::{self as sys, Fd, O};
+
+pub const STATUS_FAILED: i32 = 0;
+pub const STATUS_ENABLED: i32 = 1;
+pub const STATUS_ALREADY_ENABLED: i32 = 2;
+pub const STATUS_DISABLED: i32 = 3;
+
+const MAGIC: u32 = 0xb0bcace2;
+const HASH_SIZE: usize = 32;
+/// `magic u32 | code_size u32 | cache_size u32 | code sha256 | blob sha256`.
+const HEADER_SIZE: usize = 3 * 4 + 2 * HASH_SIZE;
+
+// 0 = not initialized from env yet, 1 = off, 2 = on.
+static ENABLED: AtomicU8 = AtomicU8::new(0);
+static LOG_ENABLED: AtomicBool = AtomicBool::new(false);
+
+static STATE: Mutex<Option<CacheState>> = Mutex::new(None);
+
+struct CacheState {
+    /// `<absolute base dir>/<version tag>` — what `getCompileCacheDir()`
+    /// returns and where entries live.
+    dir: Box<[u8]>,
+    dir_handle: sys::Dir,
+    /// Portable mode: keys use paths relative to `dir`, so the cache
+    /// survives moving the tree (NODE_COMPILE_CACHE_PORTABLE / {portable}).
+    portable: bool,
+    entries: HashMap<u64, Entry, IdentityContext<u64>>,
+}
+
+// SAFETY: `CacheState` is only reached through the global `STATE` mutex; the
+// `sys::Dir` fd is just an integer handle.
+unsafe impl Send for CacheState {}
+
+struct Entry {
+    /// `path.text` of the module (absolute file path).
+    filename: Box<[u8]>,
+    is_cjs: bool,
+    code_hash: [u8; HASH_SIZE],
+    code_size: u32,
+    /// Post-transpile text; `None` when the module never transpiled
+    /// successfully (parse error) — mirrors Node's "not initialized" state.
+    code: Option<Box<[u8]>>,
+    /// Deserialized bytecode blob handed to JSC (the cache was accepted).
+    /// Kept alive for the process — `ZigSourceProvider` wraps it, no copy.
+    blob: Option<AlignedBlob>,
+    persisted: bool,
+}
+
+/// 128-byte-aligned blob. JSC's bytecode decoder reads the blob in place and
+/// requires the same alignment the standalone graph provides (see
+/// StandaloneModuleGraph.rs "Bytecode alignment" note). Either a heap buffer
+/// or a span inside a whole-file mapping.
+struct AlignedBlob {
+    ptr: core::ptr::NonNull<u8>,
+    len: usize,
+    backing: Backing,
+}
+
+enum Backing {
+    Heap,
+    /// `PROT_READ`/`MAP_PRIVATE` mapping of the whole cache file; `ptr` points
+    /// at [`blob_file_offset`] inside it, 128-aligned because the mapping base
+    /// is page-aligned. Safe against entry rewrites: writers go through
+    /// tmpfile + rename, so a replaced file's old inode stays live under the
+    /// mapping.
+    Map {
+        base: core::ptr::NonNull<u8>,
+        map_len: usize,
+    },
+}
+
+// SAFETY: the buffer is plain bytes; ownership is unique to the entry map.
+unsafe impl Send for AlignedBlob {}
+
+/// Blobs displaced by an entry refresh. JSC providers hold raw spans into accepted blobs past the
+/// initial compile, so displaced blobs are retired (leaked), never freed — freeing is a UAF across
+/// the FFI boundary. Bounding this needs a JSC-side provider release hook first, not a cap here.
+static RETIRED_BLOBS: Mutex<Vec<AlignedBlob>> = Mutex::new(Vec::new());
+
+const BLOB_ALIGN: usize = 128;
+
+impl AlignedBlob {
+    /// Uninitialized buffer; caller must fill all `len` bytes before reading.
+    fn new_uninit(len: usize) -> Option<Self> {
+        let layout = core::alloc::Layout::from_size_align(len.max(1), BLOB_ALIGN).ok()?;
+        // SAFETY: layout has non-zero size.
+        let raw = unsafe { std::alloc::alloc(layout) };
+        let ptr = core::ptr::NonNull::new(raw)?;
+        Some(Self {
+            ptr,
+            len,
+            backing: Backing::Heap,
+        })
+    }
+
+    fn as_mut_slice(&mut self) -> &mut [u8] {
+        // SAFETY: `ptr` is valid for `len` bytes for the lifetime of `self`.
+        unsafe { core::slice::from_raw_parts_mut(self.ptr.as_ptr(), self.len) }
+    }
+}
+
+impl Drop for AlignedBlob {
+    fn drop(&mut self) {
+        match self.backing {
+            Backing::Heap => {
+                let layout = core::alloc::Layout::from_size_align(self.len.max(1), BLOB_ALIGN)
+                    .expect("valid");
+                // SAFETY: allocated in `new_uninit` with the identical layout.
+                unsafe { std::alloc::dealloc(self.ptr.as_ptr(), layout) };
+            }
+            Backing::Map { base, map_len } => {
+                let _ = sys::munmap(base.as_ptr(), map_len);
+            }
+        }
+    }
+}
+
+// ──────────────────────────────────────────────────────────────────────────
+// Logging (NODE_DEBUG_NATIVE=COMPILE_CACHE)
+// ──────────────────────────────────────────────────────────────────────────
+
+fn log_str(line: &str) {
+    if !LOG_ENABLED.load(Ordering::Relaxed) {
+        return;
+    }
+    let mut buf = line.as_bytes();
+    while !buf.is_empty() {
+        match sys::write(Fd::stderr(), buf) {
+            Ok(0) | Err(_) => break,
+            Ok(n) => buf = &buf[n..],
+        }
+    }
+}
+
+macro_rules! cclog {
+    ($($arg:tt)*) => {
+        if LOG_ENABLED.load(Ordering::Relaxed) {
+            log_str(&std::format!($($arg)*));
+        }
+    };
+}
+
+fn errno_name(e: &sys::Error) -> &'static str {
+    <&'static str>::from(e.get_errno())
+}
+
+/// Read-log tail for an I/O error; ENOENT uses Node's exact wording.
+fn errno_tail(e: &sys::Error) -> String {
+    if e.get_errno() == sys::E::ENOENT {
+        " no such file or directory\n".to_string()
+    } else {
+        format!(" {}\n", errno_name(e))
+    }
+}
+
+/// Human-readable module name for logs: plain path for CommonJS, `file://`
+/// URL for ESM — matching Node's output.
+fn display_name(filename: &[u8], is_cjs: bool) -> String {
+    if is_cjs {
+        filename.as_bstr().to_string()
+    } else if cfg!(windows) {
+        let mut bytes = Vec::with_capacity(filename.len() + 8);
+        bytes.extend_from_slice(b"file:///");
+        // 0x5C never appears inside a multi-byte UTF-8 sequence, so a byte
+        // swap matches the per-char replacement.
+        bytes.extend(filename.iter().map(|&b| if b == b'\\' { b'/' } else { b }));
+        bytes.as_bstr().to_string()
+    } else {
+        let mut bytes = Vec::with_capacity(filename.len() + 7);
+        bytes.extend_from_slice(b"file://");
+        bytes.extend_from_slice(filename);
+        bytes.as_bstr().to_string()
+    }
+}
+
+fn type_name(is_cjs: bool) -> &'static str {
+    if is_cjs { "CommonJS" } else { "ESM" }
+}
+
+// ──────────────────────────────────────────────────────────────────────────
+// Hashing / keys / version tag
+// ──────────────────────────────────────────────────────────────────────────
+
+fn sha256(bytes: &[u8]) -> [u8; HASH_SIZE] {
+    let mut out = [0u8; HASH_SIZE];
+    // SAFETY: `out` is exactly the 32 bytes SHA256 writes.
+    unsafe { boring::SHA256(bytes.as_ptr(), bytes.len(), out.as_mut_ptr()) };
+    out
+}
+
+/// First 8 digest bytes of `SHA256(type byte || filename)`: the in-memory map
+/// key and the on-disk entry name (16 hex chars).
+fn cache_key(filename: &[u8], is_cjs: bool) -> u64 {
+    let type_byte: [u8; 1] = [is_cjs as u8];
+    let mut ctx = core::mem::MaybeUninit::<boring::SHA256_CTX>::uninit();
+    let mut out = [0u8; HASH_SIZE];
+    // SAFETY: `SHA256_Init` fully initializes the context; updates/final only
+    // read the given byte ranges and write the 32-byte digest.
+    unsafe {
+        boring::SHA256_Init(ctx.as_mut_ptr());
+        boring::SHA256_Update(ctx.as_mut_ptr(), type_byte.as_ptr().cast(), 1);
+        boring::SHA256_Update(ctx.as_mut_ptr(), filename.as_ptr().cast(), filename.len());
+        boring::SHA256_Final(out.as_mut_ptr(), ctx.as_mut_ptr());
+    }
+    u64::from_le_bytes(out[..8].try_into().expect("8 bytes"))
+}
+
+/// Digest rendering for NODE_DEBUG_NATIVE=COMPILE_CACHE lines.
+fn hex(digest: &[u8; HASH_SIZE]) -> String {
+    bun_core::fmt::bytes_to_hex_lower_string(digest)
+}
+
+/// Portable mode keys on the path relative to the cache dir (Node parity).
+/// Falls back to absolute keys when no relative form exists (e.g. different
+/// Windows drives, where `relative` returns `to` unchanged — Node parity).
+fn key_for(state: &CacheState, filename: &[u8], is_cjs: bool) -> u64 {
+    if state.portable {
+        // Thread-local scratch result: consumed before any other resolve call.
+        let rel = bun_paths::resolve_path::relative(&state.dir, filename);
+        if !rel.is_empty() && !bun_paths::is_absolute(rel) {
+            cclog!(
+                "[compile cache] using relative path {} from {}\n",
+                rel.as_bstr(),
+                state.dir.as_bstr()
+            );
+            return cache_key(rel, is_cjs);
+        }
+    }
+    cache_key(filename, is_cjs)
+}
+
+/// `v<bun version>-<arch>-<revision>-<uid>`, mirroring Node's
+/// `$VERSION-$ARCH-$CACHE_VERSION_TAG-$UID` shape. The revision changes with
+/// every Bun build, so a stale JSC bytecode format can never be loaded.
+fn version_tag() -> String {
+    let sha = if bun_core::env::GIT_SHA_SHORT.is_empty() {
+        "dev"
+    } else {
+        bun_core::env::GIT_SHA_SHORT
+    };
+    let arch = std::env::consts::ARCH;
+    let version = bun_core::Global::package_json_version;
+    #[cfg(not(windows))]
+    {
+        format!("v{}-{}-{}-{}", version, arch, sha, sys::c::getuid())
+    }
+    #[cfg(windows)]
+    {
+        format!("v{}-{}-{}", version, arch, sha)
+    }
+}
+
+// ──────────────────────────────────────────────────────────────────────────
+// Enable / init
+// ──────────────────────────────────────────────────────────────────────────
+
+pub struct EnableResult {
+    pub status: i32,
+    pub directory: Option<Vec<u8>>,
+    pub message: Option<String>,
+}
+
+#[inline]
+pub fn is_enabled() -> bool {
+    ENABLED.load(Ordering::Relaxed) == 2
+}
+
+/// `NODE_COMPILE_CACHE_PORTABLE=1` (exact match, like Node).
+fn portable_from_env() -> bool {
+    env_var::NODE_COMPILE_CACHE_PORTABLE::get() == Some(b"1")
+}
+
+/// One-time env-driven initialization; called from the module fetch path.
+/// Cheap after the first call.
+pub fn init_from_env_once() {
+    static ONCE: std::sync::Once = std::sync::Once::new();
+    ONCE.call_once(|| {
+        init_logging();
+        if let Some(dir) = env_var::NODE_COMPILE_CACHE::get_not_empty() {
+            if env_var::NODE_DISABLE_COMPILE_CACHE::get().is_some() {
+                cclog!("[compile cache] Disabled by NODE_DISABLE_COMPILE_CACHE.\n");
+                ENABLED.store(1, Ordering::Relaxed);
+                return;
+            }
+            let _ = enable_with_dir(dir, portable_from_env());
+        } else {
+            ENABLED.store(1, Ordering::Relaxed);
+        }
+    });
+}
+
+fn init_logging() {
+    if let Some(v) = env_var::NODE_DEBUG_NATIVE::get() {
+        let enabled = bun_core::strings::split(v, b",").any(|item| {
+            let item = item.trim_ascii();
+            item.eq_ignore_ascii_case(b"COMPILE_CACHE") || item == b"*"
+        });
+        if enabled {
+            LOG_ENABLED.store(true, Ordering::Relaxed);
+        }
+    }
+}
+
+fn init_logging_once() {
+    static ONCE: std::sync::Once = std::sync::Once::new();
+    ONCE.call_once(init_logging);
+}
+
+/// `module.enableCompileCache(dir | {directory, portable})`. `None` values
+/// resolve like Node: dir from `NODE_COMPILE_CACHE` else the tmpdir default;
+/// portable from `NODE_COMPILE_CACHE_PORTABLE=1`.
+pub fn enable(explicit_dir: Option<&[u8]>, portable: Option<bool>) -> EnableResult {
+    init_logging_once();
+    if env_var::NODE_DISABLE_COMPILE_CACHE::get().is_some() {
+        cclog!("[compile cache] Disabled by NODE_DISABLE_COMPILE_CACHE.\n");
+        // A previously-uninitialized state stays off.
+        let _ = ENABLED.compare_exchange(0, 1, Ordering::Relaxed, Ordering::Relaxed);
+        return EnableResult {
+            status: STATUS_DISABLED,
+            directory: None,
+            message: Some("Disabled by NODE_DISABLE_COMPILE_CACHE".to_string()),
+        };
+    }
+
+    if is_enabled() {
+        return EnableResult {
+            status: STATUS_ALREADY_ENABLED,
+            directory: get_dir(),
+            message: None,
+        };
+    }
+
+    let default_buf: Vec<u8>;
+    let dir: &[u8] = match explicit_dir {
+        // "" resolves to cwd, like Node's path.resolve("").
+        Some(d) => d,
+        None => match env_var::NODE_COMPILE_CACHE::get_not_empty() {
+            Some(d) => d,
+            None => {
+                let tmp = platform_tmp_dir();
+                let mut buf = Vec::with_capacity(tmp.len() + 20);
+                buf.extend_from_slice(tmp);
+                buf.push(SEP);
+                buf.extend_from_slice(b"node-compile-cache");
+                default_buf = buf;
+                &default_buf
+            }
+        },
+    };
+    enable_with_dir(dir, portable.unwrap_or_else(portable_from_env))
+}
+
+/// Node's `os.tmpdir()` order: TEMP -> TMP on Windows, TMPDIR -> TMP ->
+/// TEMP -> /tmp on POSIX; trailing separator stripped.
+fn platform_tmp_dir() -> &'static [u8] {
+    #[cfg(windows)]
+    let candidate = env_var::TEMP::get_not_empty().or_else(env_var::TMP::get_not_empty);
+    #[cfg(not(windows))]
+    let candidate = env_var::TMPDIR::get_not_empty()
+        .or_else(env_var::TMP::get_not_empty)
+        .or_else(env_var::TEMP::get_not_empty);
+    if let Some(dir) = candidate {
+        if dir.len() > 1 && dir[dir.len() - 1] == SEP {
+            return &dir[..dir.len() - 1];
+        }
+        return dir;
+    }
+    #[cfg(windows)]
+    {
+        b"C:\\Windows\\Temp"
+    }
+    #[cfg(not(windows))]
+    {
+        b"/tmp"
+    }
+}
+
+fn enable_with_dir(dir: &[u8], portable: bool) -> EnableResult {
+    let tag = version_tag();
+
+    // Resolve `dir` to an absolute path against the process cwd.
+    let mut abs_buf = PathBuffer::uninit();
+    let mut cwd_buf = PathBuffer::uninit();
+    let abs: &[u8] = if bun_paths::is_absolute(dir) {
+        dir
+    } else {
+        let cwd_len = match sys::getcwd(&mut cwd_buf[..]) {
+            Ok(n) => n,
+            Err(e) => {
+                return EnableResult {
+                    status: STATUS_FAILED,
+                    directory: None,
+                    message: Some(format!(
+                        "Cannot resolve cache directory: {}",
+                        errno_name(&e)
+                    )),
+                };
+            }
+        };
+        bun_paths::resolve_path::join_abs_string_buf_z::<bun_paths::resolve_path::platform::Auto>(
+            &cwd_buf[..cwd_len],
+            &mut abs_buf[..],
+            &[dir],
+        )
+        .as_bytes()
+    };
+    if abs.len() + 1 + tag.len() + 2 > MAX_PATH_BYTES {
+        return EnableResult {
+            status: STATUS_FAILED,
+            directory: None,
+            message: Some("Cannot create cache directory: path too long".to_string()),
+        };
+    }
+
+    let mut tagged: Vec<u8> = Vec::with_capacity(abs.len() + 1 + tag.len());
+    tagged.extend_from_slice(abs);
+    tagged.push(SEP);
+    tagged.extend_from_slice(tag.as_bytes());
+
+    cclog!(
+        "[compile cache] resolved path {} + {} -> {}\n",
+        dir.as_bstr(),
+        tag,
+        tagged.as_bstr()
+    );
+
+    let dir_handle = match sys::Dir::cwd().make_open_path(&tagged, Default::default()) {
+        Ok(d) => d,
+        Err(e) => {
+            let errname = errno_name(&e);
+            cclog!(
+                "[compile cache] creating cache directory {}...{}\n",
+                tagged.as_bstr(),
+                errname
+            );
+            return EnableResult {
+                status: STATUS_FAILED,
+                directory: None,
+                message: Some(format!("Cannot create cache directory: {errname}")),
+            };
+        }
+    };
+    cclog!(
+        "[compile cache] creating cache directory {}...success\n",
+        tagged.as_bstr()
+    );
+
+    let directory = abs.to_vec();
+    {
+        let mut state = STATE.lock();
+        if let Some(existing) = state.as_ref() {
+            // Lost an enable race (env init on another thread vs the API):
+            // keep the installed cache — replacing it would drop live blobs.
+            return EnableResult {
+                status: STATUS_ALREADY_ENABLED,
+                directory: Some(existing.dir.to_vec()),
+                message: None,
+            };
+        }
+        let mut tagged = tagged;
+        if portable {
+            // Resolve symlinks (e.g. macOS /var -> /private/var) so relative
+            // keys match Bun's realpath'd module paths.
+            let mut z_buf = bun_core::PathBuffer::uninit();
+            let mut real_buf = bun_core::PathBuffer::uninit();
+            let tagged_z = bun_paths::resolve_path::z(&tagged, &mut z_buf);
+            if let Ok(real) = sys::realpath(tagged_z, &mut real_buf) {
+                tagged = real.to_vec();
+            }
+        }
+        *state = Some(CacheState {
+            dir: tagged.into_boxed_slice(),
+            dir_handle,
+            portable,
+            entries: HashMap::new(),
+        });
+        ENABLED.store(2, Ordering::Relaxed);
+    }
+
+    EnableResult {
+        status: STATUS_ENABLED,
+        directory: Some(directory),
+        message: None,
+    }
+}
+
+/// The version-tagged cache directory (`module.getCompileCacheDir()`), or
+/// `None` when the cache is not enabled.
+pub fn get_dir() -> Option<Vec<u8>> {
+    if !is_enabled() {
+        return None;
+    }
+    let state = STATE.lock();
+    state.as_ref().map(|s| s.dir.to_vec())
+}
+
+// ──────────────────────────────────────────────────────────────────────────
+// Fetch-time hook (read + validate)
+// ──────────────────────────────────────────────────────────────────────────
+
+/// Module-fetch hook: register/refresh the entry for `filename`; returns the
+/// validated bytecode blob when the on-disk cache matches `code` (post-
+/// transpile text). The pointer stays valid for the process (entry map owns it).
+pub fn fetch(filename: &[u8], is_cjs: bool, code: &[u8]) -> Option<(*mut u8, usize)> {
+    if !is_enabled() || filename.is_empty() || !bun_paths::is_absolute(filename) {
+        return None;
+    }
+    let Ok(code_size) = u32::try_from(code.len()) else {
+        return None;
+    };
+    let code_hash = sha256(code);
+
+    let mut guard = STATE.lock();
+    let state = guard.as_mut()?;
+    let key = key_for(state, filename, is_cjs);
+
+    if let Some(entry) = state.entries.get(&key) {
+        if entry.code_hash == code_hash && entry.code_size == code_size {
+            // Same module, unchanged code (e.g. re-required): reuse.
+            return entry.blob.as_ref().map(|b| (b.ptr.as_ptr(), b.len));
+        }
+    }
+
+    let mut entry = Entry {
+        filename: filename.into(),
+        is_cjs,
+        code_hash,
+        code_size,
+        code: None,
+        blob: None,
+        persisted: false,
+    };
+
+    read_cache_file(state, key, &mut entry, Some(code));
+
+    let result = if entry.blob.is_some() {
+        cclog!(
+            "[compile cache] code cache for {} {} was accepted, keeping the in-memory entry\n",
+            type_name(is_cjs),
+            display_name(filename, is_cjs)
+        );
+        entry.blob.as_ref().map(|b| (b.ptr.as_ptr(), b.len))
+    } else {
+        cclog!(
+            "[compile cache] code cache for {} {} was not initialized, initializing the in-memory entry\n",
+            type_name(is_cjs),
+            display_name(filename, is_cjs)
+        );
+        entry.code = Some(code.into());
+        None
+    };
+    if let Some(old) = state.entries.insert(key, entry) {
+        if let Some(blob) = old.blob {
+            // Never freed; see RETIRED_BLOBS for the invariant.
+            RETIRED_BLOBS.lock().push(blob);
+        }
+    }
+    result
+}
+
+/// Parse-failure hook: mirrors Node registering an entry before compilation.
+/// The entry stays "not initialized" so exit-time persist logs the skip line
+/// (and the cache directory exists with zero entries — Node parity).
+pub fn note_parse_failure(filename: &[u8], is_cjs: bool) {
+    if !is_enabled() || filename.is_empty() || !bun_paths::is_absolute(filename) {
+        return;
+    }
+    let mut guard = STATE.lock();
+    let Some(state) = guard.as_mut() else { return };
+    let key = key_for(state, filename, is_cjs);
+    if state.entries.contains_key(&key) {
+        return;
+    }
+    let mut entry = Entry {
+        filename: filename.into(),
+        is_cjs,
+        code_hash: [0u8; HASH_SIZE],
+        code_size: 0,
+        code: None,
+        blob: None,
+        persisted: false,
+    };
+    // The read is attempted (and logged) like Node; without current code the
+    // stored entry can never validate, so this only populates the log.
+    read_cache_file(state, key, &mut entry, None);
+    entry.blob = None;
+    state.entries.insert(key, entry);
+}
+
+fn cache_basename(key: u64) -> [u8; 16] {
+    let mut out = [0u8; 16];
+    bun_core::fmt::bytes_to_hex_lower(&key.to_be_bytes(), &mut out);
+    out
+}
+
+/// Blob's byte offset in the cache file: header + stored code, padded to the
+/// decoder's 128-byte alignment so a page-aligned mapping keeps the blob
+/// aligned in place.
+fn blob_file_offset(code_size: u32) -> u64 {
+    (HEADER_SIZE as u64 + u64::from(code_size)).next_multiple_of(BLOB_ALIGN as u64)
+}
+
+/// Unmaps on drop unless [`MapGuard::take`]n for a blob that keeps the
+/// mapping alive.
+struct MapGuard(Option<(core::ptr::NonNull<u8>, usize)>);
+
+impl MapGuard {
+    fn take(&mut self) -> Option<(core::ptr::NonNull<u8>, usize)> {
+        self.0.take()
+    }
+}
+
+impl Drop for MapGuard {
+    fn drop(&mut self) {
+        if let Some((base, map_len)) = self.0.take() {
+            let _ = sys::munmap(base.as_ptr(), map_len);
+        }
+    }
+}
+
+fn read_cache_file(state: &CacheState, key: u64, entry: &mut Entry, code: Option<&[u8]>) {
+    let basename = cache_basename(key);
+    let mut line = String::new();
+    if LOG_ENABLED.load(Ordering::Relaxed) {
+        line = format!(
+            "[compile cache] reading cache from {}{}{} for {} {}...",
+            state.dir.as_bstr(),
+            SEP as char,
+            core::str::from_utf8(&basename).expect("hex"),
+            type_name(entry.is_cjs),
+            display_name(&entry.filename, entry.is_cjs)
+        );
+    }
+    // Emits `line` + lazily-built `tail` once the outcome is known.
+    let finish = |line: String, tail: &dyn Fn() -> String| {
+        if LOG_ENABLED.load(Ordering::Relaxed) {
+            log_str(&line);
+            log_str(&tail());
+        }
+    };
+
+    let file = match state
+        .dir_handle
+        .open_file(&basename, O::RDONLY | O::CLOEXEC, 0)
+    {
+        Ok(f) => f,
+        Err(e) => {
+            finish(line, &|| errno_tail(&e));
+            return;
+        }
+    };
+    // `sys::File` closes its fd on drop.
+
+    let total = match file.get_end_pos() {
+        Ok(n) => n as usize,
+        Err(e) => {
+            finish(line, &|| errno_tail(&e));
+            return;
+        }
+    };
+    if total < HEADER_SIZE {
+        finish(line, &|| "reading header failed\n".into());
+        return;
+    }
+
+    // Map the file so an accepted blob is handed to JSC zero-copy; fall back
+    // to a heap read when mmap is unavailable (Windows) or fails.
+    #[cfg(unix)]
+    let (prot, flags) = (libc::PROT_READ, libc::MAP_PRIVATE);
+    #[cfg(not(unix))]
+    let (prot, flags) = (0i32, 0i32);
+    let mut map_guard = MapGuard(
+        sys::mmap(core::ptr::null_mut(), total, prot, flags, file.fd(), 0)
+            .ok()
+            .and_then(core::ptr::NonNull::new)
+            .map(|base| (base, total)),
+    );
+    let heap_contents;
+    let bytes: &[u8] = match &map_guard.0 {
+        // SAFETY: the mapping is `total` bytes and outlives this borrow.
+        Some((base, _)) => unsafe { core::slice::from_raw_parts(base.as_ptr(), total) },
+        None => {
+            let mut contents = vec![0u8; total];
+            match file.pread_all(&mut contents, 0) {
+                Ok(n) if n == total => {}
+                _ => {
+                    finish(line, &|| "reading header failed\n".into());
+                    return;
+                }
+            }
+            heap_contents = contents;
+            &heap_contents
+        }
+    };
+
+    let magic = u32::from_le_bytes(bytes[0..4].try_into().expect("4 bytes"));
+    let code_size = u32::from_le_bytes(bytes[4..8].try_into().expect("4 bytes"));
+    let cache_size = u32::from_le_bytes(bytes[8..12].try_into().expect("4 bytes"));
+    let code_hash: &[u8; HASH_SIZE] = bytes[12..12 + HASH_SIZE].try_into().expect("32 bytes");
+    let cache_hash: &[u8; HASH_SIZE] = bytes[12 + HASH_SIZE..HEADER_SIZE]
+        .try_into()
+        .expect("32 bytes");
+    if LOG_ENABLED.load(Ordering::Relaxed) {
+        line.push_str(&format!(
+            "[{magic} {code_size} {cache_size} {} {}]...",
+            hex(code_hash),
+            hex(cache_hash)
+        ));
+    }
+
+    if magic != MAGIC {
+        finish(line, &|| {
+            format!("magic number mismatch: expected {MAGIC}, actual {magic}\n")
+        });
+        return;
+    }
+    if code_size != entry.code_size {
+        finish(line, &|| {
+            format!(
+                "code size mismatch: expected {}, actual {code_size}\n",
+                entry.code_size
+            )
+        });
+        return;
+    }
+    if code_hash != &entry.code_hash {
+        finish(line, &|| {
+            format!(
+                "code hash mismatch: expected {}, actual {}\n",
+                hex(&entry.code_hash),
+                hex(code_hash)
+            )
+        });
+        return;
+    }
+    let blob_off = blob_file_offset(code_size);
+    let expected_total = blob_off + u64::from(cache_size);
+    if total as u64 != expected_total {
+        finish(line, &|| {
+            format!(
+                "cache size mismatch: expected {cache_size}, actual {}\n",
+                (total as u64).saturating_sub(blob_off)
+            )
+        });
+        return;
+    }
+    let Some(code) = code else {
+        // Parse-failure probe: no current code to compare against.
+        finish(line, &|| {
+            format!(
+                "code hash mismatch: expected 0, actual {}\n",
+                hex(code_hash)
+            )
+        });
+        return;
+    };
+
+    // Stored code: byte-compare against the current post-transpile text so
+    // "accepted" is exact, not merely hash-equal.
+    if &bytes[HEADER_SIZE..HEADER_SIZE + code_size as usize] != code {
+        finish(line, &|| {
+            format!(
+                "code hash mismatch: expected {}, actual {}\n",
+                hex(&entry.code_hash),
+                hex(code_hash)
+            )
+        });
+        return;
+    }
+
+    let blob_bytes = &bytes[blob_off as usize..][..cache_size as usize];
+    let actual_cache_hash = sha256(blob_bytes);
+    if &actual_cache_hash != cache_hash {
+        finish(line, &|| {
+            format!(
+                "cache hash mismatch: expected {}, actual {}\n",
+                hex(cache_hash),
+                hex(&actual_cache_hash)
+            )
+        });
+        return;
+    }
+
+    // The decoder requires the blob 128-aligned. The mapping base is
+    // page-aligned (every supported page size is a multiple of 128) and
+    // `blob_off` is a multiple of 128 by construction, but a miss here would
+    // be a JSC assert or segfault, so verify instead of assuming.
+    let map_is_aligned = map_guard.0.as_ref().is_some_and(|(base, _)| {
+        (base.as_ptr() as usize + blob_off as usize).is_multiple_of(BLOB_ALIGN)
+    });
+    let blob = if map_is_aligned {
+        let (base, map_len) = map_guard.take().expect("checked above");
+        // SAFETY: `blob_off + cache_size == map_len` was just validated.
+        let ptr =
+            unsafe { core::ptr::NonNull::new_unchecked(base.as_ptr().add(blob_off as usize)) };
+        AlignedBlob {
+            ptr,
+            len: cache_size as usize,
+            backing: Backing::Map { base, map_len },
+        }
+    } else {
+        // No mapping, or the blob would be misaligned in it: copy to an
+        // aligned heap buffer instead (map_guard unmaps on return).
+        let Some(mut blob) = AlignedBlob::new_uninit(cache_size as usize) else {
+            finish(line, &|| "allocation failed\n".into());
+            return;
+        };
+        blob.as_mut_slice().copy_from_slice(blob_bytes);
+        blob
+    };
+    finish(line, &|| format!(" success, size={cache_size}\n"));
+    entry.blob = Some(blob);
+}
+
+// ──────────────────────────────────────────────────────────────────────────
+// Persist (exit + flush)
+// ──────────────────────────────────────────────────────────────────────────
+
+/// Bytecode generation runs on one long-lived worker thread with its own JSC
+/// VM (`getVMForBytecodeCache`), mirroring `bun build --bytecode`'s bundler
+/// threads, so only a single extra VM ever exists.
+struct GenJob {
+    format: Format,
+    code: Box<[u8]>,
+    url: Box<[u8]>,
+    resp: std::sync::mpsc::SyncSender<Option<Box<[u8]>>>,
+}
+
+fn generate_bytecode(format: Format, code: &[u8], url: &[u8]) -> Option<Box<[u8]>> {
+    use std::sync::mpsc;
+    static WORKER: Mutex<Option<mpsc::Sender<GenJob>>> = Mutex::new(None);
+
+    let (resp_tx, resp_rx) = mpsc::sync_channel(1);
+    {
+        let mut guard = WORKER.lock();
+        if guard.is_none() {
+            let (tx, rx) = mpsc::channel::<GenJob>();
+            let spawned = std::thread::Builder::new()
+                .name("BunCompileCache".to_string())
+                // JSC parsing of large modules needs a deep stack.
+                .stack_size(16 * 1024 * 1024)
+                .spawn(move || {
+                    for job in rx {
+                        let mut url = BunString::clone_utf8(&job.url);
+                        let result = crate::cached_bytecode::__bun_jsc_generate_cached_bytecode(
+                            job.format, &job.code, &mut url,
+                        );
+                        url.deref();
+                        let _ = job.resp.send(result);
+                    }
+                });
+            match spawned {
+                Ok(_) => *guard = Some(tx),
+                Err(_) => return None,
+            }
+        }
+        let tx = guard.as_ref().expect("set above");
+        if tx
+            .send(GenJob {
+                format,
+                code: code.into(),
+                url: url.into(),
+                resp: resp_tx,
+            })
+            .is_err()
+        {
+            return None;
+        }
+    }
+    resp_rx.recv().ok().flatten()
+}
+
+/// One unit of persist work, snapshotted out of `STATE` so bytecode generation runs with the lock
+/// dropped. `code` is moved out (concurrent `fetch` sees `code: None` and skips). Keys hash
+/// `(is_cjs, filename)` — not content — so Phase 3 re-checks `code_hash` before touching the entry.
+struct PersistJob {
+    key: u64,
+    format: Format,
+    code: Box<[u8]>,
+    filename: Box<[u8]>,
+    is_cjs: bool,
+    code_size: u32,
+    code_hash: [u8; HASH_SIZE],
+}
+
+/// Phase 1 (locked): decide what needs persisting and move the source code
+/// out of the entries.
+fn collect_persist_jobs(state: &mut CacheState) -> Vec<PersistJob> {
+    let mut jobs = Vec::new();
+    let logging = LOG_ENABLED.load(Ordering::Relaxed);
+    for (&key, entry) in state.entries.iter_mut() {
+        let tname = type_name(entry.is_cjs);
+        let name = if logging {
+            display_name(&entry.filename, entry.is_cjs)
+        } else {
+            String::new()
+        };
+        if entry.persisted {
+            cclog!(
+                "[compile cache] skip persisting {tname} {name} because cache was already persisted\n"
+            );
+            continue;
+        }
+        if entry.blob.is_some() {
+            // The on-disk cache was accepted as-is.
+            cclog!("[compile cache] skip persisting {tname} {name} because cache was the same\n");
+            continue;
+        }
+        let Some(code) = entry.code.take() else {
+            cclog!(
+                "[compile cache] skip persisting {tname} {name} because the cache was not initialized\n"
+            );
+            continue;
+        };
+        jobs.push(PersistJob {
+            key,
+            format: if entry.is_cjs {
+                Format::Cjs
+            } else {
+                Format::Esm
+            },
+            code,
+            filename: entry.filename.clone(),
+            is_cjs: entry.is_cjs,
+            code_size: entry.code_size,
+            code_hash: entry.code_hash,
+        });
+    }
+    jobs
+}
+
+/// Phase 3 (locked): write one generated blob to disk. `Ok(())` on success;
+/// on any I/O failure returns `Err(())` and the caller restores the taken
+/// `entry.code` and leaves `persisted` false so a later pass may retry.
+fn write_persist_job_locked(
+    state: &mut CacheState,
+    job: &PersistJob,
+    blob: &[u8],
+) -> Result<(), ()> {
+    let logging = LOG_ENABLED.load(Ordering::Relaxed);
+    let tname = type_name(job.is_cjs);
+    let name = if logging {
+        display_name(&job.filename, job.is_cjs)
+    } else {
+        String::new()
+    };
+
+    let cache_size = blob.len() as u32;
+    let cache_hash = sha256(blob);
+
+    let basename = cache_basename(job.key);
+    let mut tmpname_buf = PathBuffer::uninit();
+    let tmpname_zstr: &ZStr =
+        match bun_resolver::fs::FileSystem::tmpname(&basename, &mut tmpname_buf[..], job.key) {
+            Ok(z) => z,
+            Err(_) => return Err(()),
+        };
+
+    cclog!("[compile cache] Creating temporary file for cache of {name} ({tname})...");
+
+    let mut tmpfile = match sys::Tmpfile::create(state.dir_handle.fd(), tmpname_zstr) {
+        Ok(t) => t,
+        Err(e) => {
+            cclog!("failed. {}\n", errno_name(&e));
+            return Err(());
+        }
+    };
+    let _close = sys::CloseOnDrop::new(tmpfile.fd);
+
+    let tmp_display = if logging {
+        format!(
+            "{}{}{}",
+            state.dir.as_bstr(),
+            SEP as char,
+            tmpname_zstr.as_bytes().as_bstr()
+        )
+    } else {
+        String::new()
+    };
+    cclog!(" -> {tmp_display}\n");
+    cclog!(
+        "[compile cache] writing cache for {tname} {name} to temporary file {tmp_display} [{MAGIC} {} {cache_size} {} {}]...",
+        job.code_size,
+        hex(&job.code_hash),
+        hex(&cache_hash)
+    );
+
+    let mut header_bytes = [0u8; HEADER_SIZE];
+    header_bytes[0..4].copy_from_slice(&MAGIC.to_le_bytes());
+    header_bytes[4..8].copy_from_slice(&job.code_size.to_le_bytes());
+    header_bytes[8..12].copy_from_slice(&cache_size.to_le_bytes());
+    header_bytes[12..12 + HASH_SIZE].copy_from_slice(&job.code_hash);
+    header_bytes[12 + HASH_SIZE..HEADER_SIZE].copy_from_slice(&cache_hash);
+    // ManuallyDrop: the fd is owned by `_close` above.
+    let file = core::mem::ManuallyDrop::new(sys::File::from_fd(tmpfile.fd));
+    let write_all = || -> sys::Maybe<()> {
+        file.pwrite_all(&header_bytes, 0)?;
+        file.pwrite_all(&job.code, HEADER_SIZE as i64)?;
+        // The gap up to the 128-aligned blob offset is a hole (zeros).
+        file.pwrite_all(blob, blob_file_offset(job.code_size) as i64)?;
+        Ok(())
+    };
+    if let Err(e) = write_all() {
+        cclog!("failed: {}\n", errno_name(&e));
+        let _ = sys::unlinkat(state.dir_handle.fd(), tmpname_zstr);
+        return Err(());
+    }
+    cclog!("success\n");
+
+    let mut dest_z = [0u8; 17];
+    dest_z[..16].copy_from_slice(&basename);
+    let dest_zstr = ZStr::from_buf(&dest_z, 16);
+    let final_display = if logging {
+        format!(
+            "{}{}{}",
+            state.dir.as_bstr(),
+            SEP as char,
+            core::str::from_utf8(&basename).expect("hex")
+        )
+    } else {
+        String::new()
+    };
+    cclog!("[compile cache] Renaming {tmp_display} to {final_display}...");
+    if let Err(e) = tmpfile.finish(dest_zstr) {
+        cclog!("failed: {}\n", errno_name(&e));
+        let _ = sys::unlinkat(state.dir_handle.fd(), tmpname_zstr);
+        return Err(());
+    }
+    cclog!("success\n");
+    Ok(())
+}
+
+/// Full persist pass. `STATE` is held only for snapshot and file-write phases; bytecode
+/// generation runs with the lock dropped so concurrent module loads are not stalled.
+fn persist_pass() {
+    // Phase 1: snapshot under the lock.
+    let jobs = {
+        let mut guard = STATE.lock();
+        let Some(state) = guard.as_mut() else { return };
+        collect_persist_jobs(state)
+    };
+
+    // Phase 2: generate bytecode, unlocked.
+    let mut generated: Vec<(PersistJob, Option<Box<[u8]>>)> = Vec::with_capacity(jobs.len());
+    for job in jobs {
+        let blob = generate_bytecode(job.format, &job.code, &job.filename);
+        if blob.is_none() {
+            cclog!(
+                "[compile cache] generating cache for {} {} failed, skipping\n",
+                type_name(job.is_cjs),
+                display_name(&job.filename, job.is_cjs)
+            );
+        }
+        generated.push((job, blob));
+    }
+
+    // Phase 3: write files and update entries under the lock.
+    let mut guard = STATE.lock();
+    let Some(state) = guard.as_mut() else { return };
+    for (job, blob) in generated {
+        let Some(blob) = blob else {
+            // Do not retry on the next persist pass. Skip if the entry now
+            // holds different content (file changed and was re-fetched).
+            if let Some(entry) = state.entries.get_mut(&job.key) {
+                if entry.code_hash == job.code_hash && entry.code_size == job.code_size {
+                    entry.persisted = true;
+                }
+            }
+            continue;
+        };
+        let wrote = write_persist_job_locked(state, &job, &blob);
+        let Some(entry) = state.entries.get_mut(&job.key) else {
+            continue;
+        };
+        if entry.code_hash != job.code_hash || entry.code_size != job.code_size {
+            // The entry was repopulated with different content mid-pass; the
+            // write we just did is stale (the header check corrects it on
+            // the next load) and the taken code must not overwrite the new.
+            continue;
+        }
+        match wrote {
+            Ok(()) => entry.persisted = true,
+            // Keep the source so a later pass can retry, matching the old
+            // in-place behavior for failed writes.
+            Err(()) => {
+                if entry.code.is_none() {
+                    entry.code = Some(job.code);
+                }
+            }
+        }
+    }
+
+    cclog!("[compile cache] Clear deserialized cache.\n");
+    // Drop persisted code copies; blobs stay alive (JSC providers reference
+    // them) and entries stay so unchanged re-fetches keep hitting in memory.
+    for entry in state.entries.values_mut() {
+        if entry.persisted {
+            entry.code = None;
+        }
+    }
+}
+
+/// `module.flushCompileCache()`.
+pub fn flush() {
+    if !is_enabled() {
+        return;
+    }
+    cclog!("[compile cache] module.flushCompileCache() requested.\n");
+    persist_pass();
+    cclog!("[compile cache] module.flushCompileCache() finished.\n");
+}
+
+/// Exit-time persist; runs once, from the main VM's `on_exit`.
+pub fn persist_at_exit() {
+    static DONE: AtomicBool = AtomicBool::new(false);
+    if !is_enabled() || DONE.swap(true, Ordering::Relaxed) {
+        return;
+    }
+    persist_now();
+}
+
+/// Non-latching sibling of [`persist_at_exit`] for paths where the process may survive (e.g. a
+/// self-directed signal that proves non-fatal). Leaves the exit latch unset so a later real exit
+/// still persists modules loaded after this point.
+pub fn persist_now() {
+    if !is_enabled() {
+        return;
+    }
+    persist_pass();
+}
+
+// ──────────────────────────────────────────────────────────────────────────
+// C++ API (NodeModuleModule.cpp)
+// ──────────────────────────────────────────────────────────────────────────
+
+#[unsafe(no_mangle)]
+/// # Safety
+/// `dir` is null or a live `BunString`; both out-params are valid for write.
+pub unsafe extern "C" fn Bun__NodeCompileCache__enable(
+    dir: *const BunString,
+    // -1 = not specified (fall back to NODE_COMPILE_CACHE_PORTABLE).
+    portable: i32,
+    out_directory: *mut BunString,
+    out_message: *mut BunString,
+) -> i32 {
+    // SAFETY: C++ passes null or a live BunString plus valid out-params.
+    let dir_utf8 = unsafe { dir.as_ref() }.map(|d| d.to_utf8());
+    let dir_slice = dir_utf8.as_ref().map(|d| d.slice());
+    let result = enable(
+        dir_slice,
+        if portable < 0 {
+            None
+        } else {
+            Some(portable != 0)
+        },
+    );
+    if let Some(directory) = result.directory {
+        // SAFETY: out-param is valid for write per fn contract.
+        unsafe { *out_directory = BunString::clone_utf8(&directory) };
+    }
+    if let Some(message) = result.message {
+        // SAFETY: out-param is valid for write per fn contract.
+        unsafe { *out_message = BunString::clone_utf8(message.as_bytes()) };
+    }
+    result.status
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn Bun__NodeCompileCache__getDir() -> BunString {
+    match get_dir() {
+        Some(dir) => BunString::clone_utf8(&dir),
+        None => BunString::empty(),
+    }
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn Bun__NodeCompileCache__flush() {
+    flush();
+}
diff --git a/src/jsc/PosixSignalHandle.rs b/src/jsc/PosixSignalHandle.rs
index e02dd7ae934c..c4ae966fabc8 100644
--- a/src/jsc/PosixSignalHandle.rs
+++ b/src/jsc/PosixSignalHandle.rs
@@ -1,4 +1,4 @@
-use core::sync::atomic::{AtomicU8, AtomicU16, Ordering};
+use core::sync::atomic::{AtomicBool, AtomicU8, AtomicU16, AtomicU32, Ordering};
 
 use crate::event_loop::EventLoop;
 use crate::{JSGlobalObject, Task, VirtualMachineRef as VirtualMachine};
@@ -115,6 +115,16 @@ impl PosixSignalHandle {
 extern "C" fn Bun__onPosixSignal(number: i32) {
     #[cfg(unix)]
     {
+        // Watch-mode SIGINT with no JS listener: node's watcher (its own
+        // process, idle loop) exits 0 immediately even when the script is
+        // busy; `_exit` is async-signal-safe, the queued path would not run.
+        if number == i32::from(SIGINT_NUMBER)
+            && WATCH_MODE_KILL_SIGNAL.load(Ordering::Relaxed) != 0
+            && WATCH_SIGINT_LISTENERS.load(Ordering::Acquire) == 0
+        {
+            // SAFETY: `_exit(2)` is async-signal-safe and takes no pointers.
+            unsafe { libc::_exit(0) };
+        }
         let Some(vm) = VirtualMachine::get_main_thread_vm() else {
             return;
         };
@@ -140,12 +150,118 @@ impl Taskable for PosixSignalTask {
 }
 
 unsafe extern "C" {
-    safe fn Bun__onSignalForJS(number: i32, global_object: &JSGlobalObject);
+    /// Returns whether any JS `process.on(<signal>)` listener actually ran.
+    safe fn Bun__onSignalForJS(number: i32, global_object: &JSGlobalObject) -> bool;
+    #[cfg(unix)]
+    safe fn Bun__installWatchModeSignalHandler(number: i32);
+}
+
+/// Nonzero only for `bun run --watch` (RunCommand): the `--watch-kill-signal`
+/// PLATFORM number (default SIGTERM) whose JS handlers are emitted before an
+/// execve reload. Never set for `--hot`, the dev server, or `bun test --watch`.
+static WATCH_MODE_KILL_SIGNAL: AtomicU8 = AtomicU8::new(0);
+
+/// SIGINT is 2 on every supported platform (POSIX and the Windows CRT).
+const SIGINT_NUMBER: u8 = 2;
+
+#[cfg(unix)]
+fn is_uncatchable_signal(number: i32) -> bool {
+    number == libc::SIGKILL || number == libc::SIGSTOP
+}
+#[cfg(not(unix))]
+fn is_uncatchable_signal(_number: i32) -> bool {
+    false
+}
+
+/// True while the pre-reload kill-signal handlers run: `process.exit` inside
+/// one must not stop the reload (node restarts the watched child regardless).
+static IS_EMITTING_WATCH_KILL_SIGNAL: AtomicBool = AtomicBool::new(false);
+
+/// JS listener count for the configured watch kill signal, mirrored here so
+/// the watcher thread can decide between the immediate execve reload and the
+/// event-loop reload that runs those handlers first (see `Task::enqueue`).
+static WATCH_KILL_SIGNAL_LISTENERS: AtomicU32 = AtomicU32::new(0);
+
+/// JS listener count for SIGINT, mirrored for the async-signal-safe fast exit
+/// in `Bun__onPosixSignal` (a busy script must still die on Ctrl+C, like
+/// node's watcher does from its own process).
+static WATCH_SIGINT_LISTENERS: AtomicU32 = AtomicU32::new(0);
+
+/// C++ `onDidChangeListeners` reports every `process.on(<signal>)` listener
+/// count change here (main-thread VM only, platform signal numbers).
+#[unsafe(no_mangle)]
+pub(crate) extern "C" fn Bun__onSignalListenerCountChanged(number: i32, count: i32) {
+    let watch_signal = i32::from(WATCH_MODE_KILL_SIGNAL.load(Ordering::Relaxed));
+    if watch_signal == 0 {
+        return;
+    }
+    let count = count.max(0) as u32;
+    // Uncatchable kill signals never emit, so their listeners must not divert
+    // the reload off the immediate execve path.
+    if number == watch_signal && !is_uncatchable_signal(number) {
+        WATCH_KILL_SIGNAL_LISTENERS.store(count, Ordering::Release);
+    }
+    if number == i32::from(SIGINT_NUMBER) {
+        WATCH_SIGINT_LISTENERS.store(count, Ordering::Release);
+    }
+}
+
+/// Watcher-thread query: only ever true for `bun run --watch` (the count is
+/// mirrored solely when `WATCH_MODE_KILL_SIGNAL` is set).
+pub fn watch_kill_signal_has_listeners() -> bool {
+    WATCH_KILL_SIGNAL_LISTENERS.load(Ordering::Acquire) > 0
+}
+
+/// `bun run --watch` startup: record the kill signal for pre-reload emission
+/// and install a SIGINT handler so the watcher terminates like node's does
+/// (exit 0; works even when SIGINT was inherited as SIG_IGN).
+#[cfg(unix)]
+pub fn enable_watch_mode_signals(kill_signal: bun_core::SignalCode) {
+    // Validated by Arguments.parse, so the platform number always exists.
+    let number = kill_signal.platform_number().unwrap_or(libc::SIGTERM);
+    WATCH_MODE_KILL_SIGNAL.store(number as u8, Ordering::Relaxed);
+    Bun__installWatchModeSignalHandler(libc::SIGINT);
+}
+
+/// Windows has no sigaction to install; only record the signal so the
+/// platform-agnostic pre-reload emit (`emit_watch_kill_signal_before_reload`)
+/// still runs the JS handlers before a watch restart, like unix.
+#[cfg(not(unix))]
+pub fn enable_watch_mode_signals(kill_signal: bun_core::SignalCode) {
+    const SIGTERM: i32 = 15;
+    let number = kill_signal.platform_number().unwrap_or(SIGTERM);
+    WATCH_MODE_KILL_SIGNAL.store(number as u8, Ordering::Relaxed);
+}
+
+pub fn is_emitting_watch_kill_signal() -> bool {
+    IS_EMITTING_WATCH_KILL_SIGNAL.load(Ordering::Relaxed)
+}
+
+/// Runs the JS handlers of the configured `--watch-kill-signal` synchronously,
+/// mirroring node delivering that signal to the watched child before restart.
+/// SIGKILL/SIGSTOP are uncatchable in node, so nothing is emitted for them.
+pub(crate) fn emit_watch_kill_signal_before_reload(global_object: &JSGlobalObject) {
+    let sig = WATCH_MODE_KILL_SIGNAL.load(Ordering::Relaxed);
+    if sig == 0 || is_uncatchable_signal(i32::from(sig)) {
+        return;
+    }
+    // Set once and left set: the caller proceeds straight into reload_process() without yielding,
+    // and the grace-timer thread treats this flag as "JS thread is doing watch-reload work" for
+    // its deadline extension. execve replaces the image, so nothing needs to clear it.
+    IS_EMITTING_WATCH_KILL_SIGNAL.store(true, Ordering::Relaxed);
+    let _ = Bun__onSignalForJS(i32::from(sig), global_object);
 }
 
 impl PosixSignalTask {
     pub fn run_from_js_thread(number: u8, global_object: &JSGlobalObject) {
-        Bun__onSignalForJS(i32::from(number), global_object);
+        let fired = Bun__onSignalForJS(i32::from(number), global_object);
+        // Node parity: in watch mode the watcher exits 0 on SIGINT when the
+        // script has no handler for it (see `enable_watch_mode_signals`).
+        if !fired && number == SIGINT_NUMBER && WATCH_MODE_KILL_SIGNAL.load(Ordering::Relaxed) != 0
+        {
+            bun_core::Output::flush();
+            bun_core::Global::exit(0);
+        }
     }
 }
 
diff --git a/src/jsc/ResolveMessage.rs b/src/jsc/ResolveMessage.rs
index c447995d98b3..0949c21c5906 100644
--- a/src/jsc/ResolveMessage.rs
+++ b/src/jsc/ResolveMessage.rs
@@ -56,6 +56,36 @@ fn import_kind_label(kind: ImportKind) -> &'static [u8] {
     }
 }
 
+/// Host-agnostic bare-specifier check for Node ESM error shaping. Must not vary by host:
+/// relative, separator-led, and ASCII-letter drive forms are path-like; everything else is a
+/// package. Unlike `bun_paths::is_absolute`, the drive byte must be alphabetic.
+fn is_bare_esm_specifier(s: &[u8]) -> bool {
+    let is_sep = |b: u8| b == b'/' || b == b'\\';
+    match s {
+        [] | [b'.'] | [b'.', b'.'] => return false,
+        [b, ..] if is_sep(*b) => return false,
+        [b'.', b, ..] if is_sep(*b) => return false,
+        [b'.', b'.', b, ..] if is_sep(*b) => return false,
+        [d, b':', b, ..] if d.is_ascii_alphabetic() && is_sep(*b) => return false,
+        _ => {}
+    }
+    true
+}
+
+/// First path segment of a bare specifier ("@scope/name" keeps two),
+/// matching Node's ERR_MODULE_NOT_FOUND "Cannot find package '<name>'".
+fn esm_package_name(specifier: &[u8]) -> &[u8] {
+    let slash_after = |from: usize| {
+        bun_core::strings::index_of_char_usize(&specifier[from..], b'/')
+            .map_or(specifier.len(), |i| from + i)
+    };
+    let mut end = slash_after(0);
+    if specifier.starts_with(b"@") && end < specifier.len() {
+        end = slash_after(end + 1);
+    }
+    &specifier[..end]
+}
+
 impl ResolveMessage {
     // `#[JsClass]` emits `ResolveMessageClass__construct` calling this.
     pub fn constructor(
@@ -225,13 +255,12 @@ impl ResolveMessage {
 
     pub(crate) fn to_string_fn(&self, global: &JSGlobalObject) -> JSValue {
         let mut text = Vec::new();
-        if write!(
-            &mut text,
-            "ResolveMessage: {}",
-            bstr::BStr::new(&self.msg.data.text)
-        )
-        .is_err()
-        {
+        // Keep `String(err)` consistent with `err.message`/`err.stack`, which
+        // route through `node_message()` for the reshaped module-not-found
+        // cases.
+        let node_message = self.node_message();
+        let message: &[u8] = node_message.as_deref().unwrap_or(&self.msg.data.text);
+        if write!(&mut text, "ResolveMessage: {}", bstr::BStr::new(message)).is_err() {
             return global.throw_out_of_memory_value();
         }
         let mut str = ZigString::init(&text);
@@ -324,11 +353,120 @@ impl ResolveMessage {
         ))
     }
 
+    /// Module-not-found for a runtime import kind whose `.message` /
+    /// `.requireStack` should match Node.js. Returns `(import_kind, specifier,
+    /// usable_referrer)`; `None` keeps the original Bun-formatted text.
+    fn node_error_shape(&self) -> Option<(ImportKind, &[u8], Option<&[u8]>)> {
+        let bun_ast::Metadata::Resolve(resolve) = &self.msg.metadata else {
+            return None;
+        };
+        match resolve.import_kind {
+            ImportKind::Require
+            | ImportKind::RequireResolve
+            | ImportKind::Stmt
+            | ImportKind::Dynamic => {}
+            _ => return None,
+        }
+        // Fallback paths tag every CrateError as `ModuleNotFound`, so gate on
+        // the formatted text rather than `resolve.err` to leave InvalidURL /
+        // InvalidDataURL / ENAMETOOLONG messages untouched.
+        let text: &[u8] = &self.msg.data.text;
+        if !(text.starts_with(b"Cannot find module '")
+            || text.starts_with(b"Cannot find package '"))
+        {
+            return None;
+        }
+        // `require.resolve('node:missing')` is a plain MODULE_NOT_FOUND in
+        // Node; every other kind reports ERR_UNKNOWN_BUILTIN_MODULE instead.
+        let specifier = resolve.specifier.slice(&self.msg.data.text);
+        if specifier.starts_with(b"node:") && resolve.import_kind != ImportKind::RequireResolve {
+            return None;
+        }
+        let referrer = self
+            .referrer
+            .as_deref()
+            .filter(|r| !r.is_empty() && *r != b"bun:main");
+        Some((resolve.import_kind, specifier, referrer))
+    }
+
+    /// Node's message for a module-not-found error, or `None` when the
+    /// original text should be kept.
+    fn node_message(&self) -> Option<Vec<u8>> {
+        use bstr::BStr;
+        let (kind, specifier, referrer) = self.node_error_shape()?;
+        let mut out = Vec::new();
+        match kind {
+            ImportKind::Require | ImportKind::RequireResolve => {
+                write!(&mut out, "Cannot find module '{}'", BStr::new(specifier)).ok();
+                if let Some(referrer) = referrer {
+                    write!(&mut out, "\nRequire stack:\n- {}", BStr::new(referrer)).ok();
+                }
+            }
+            ImportKind::Stmt | ImportKind::Dynamic => {
+                let referrer = referrer?;
+                if is_bare_esm_specifier(specifier) {
+                    write!(
+                        &mut out,
+                        "Cannot find package '{}' imported from {}",
+                        BStr::new(esm_package_name(specifier)),
+                        BStr::new(referrer),
+                    )
+                    .ok();
+                } else {
+                    write!(
+                        &mut out,
+                        "Cannot find module '{}' imported from {}",
+                        BStr::new(specifier),
+                        BStr::new(referrer),
+                    )
+                    .ok();
+                }
+            }
+            _ => return None,
+        }
+        Some(out)
+    }
+
     #[crate::host_fn(getter)]
     pub fn get_message(this: &Self, global: &JSGlobalObject) -> JsResult<JSValue> {
+        if let Some(text) = this.node_message() {
+            return Ok(ZigString::init_utf8(&text).to_js(global));
+        }
         Ok(ZigString::init_utf8(&this.msg.data.text).to_js(global))
     }
 
+    // Node: MODULE_NOT_FOUND errors carry `requireStack` (the chain of
+    // requiring files; Bun tracks only the direct referrer). CJS kinds only.
+    #[crate::host_fn(getter)]
+    pub fn get_require_stack(this: &Self, global: &JSGlobalObject) -> JsResult<JSValue> {
+        let Some((kind, _, referrer)) = this.node_error_shape() else {
+            return Ok(JSValue::UNDEFINED);
+        };
+        if !matches!(kind, ImportKind::Require | ImportKind::RequireResolve) {
+            return Ok(JSValue::UNDEFINED);
+        }
+        let mut entries: Vec<&[u8]> = Vec::new();
+        if let Some(r) = referrer {
+            entries.push(r);
+        }
+        JSValue::create_array_from_iter(global, entries.iter().copied(), |r| {
+            Ok(ZigString::init_utf8(r).to_js(global))
+        })
+    }
+
+    // A synthesized `name: message` header; Bun does not capture JS frames at
+    // module-resolution time, so there are no `at ...` lines.
+    #[crate::host_fn(getter)]
+    pub fn get_stack(this: &Self, global: &JSGlobalObject) -> JsResult<JSValue> {
+        let mut out = Vec::new();
+        out.extend_from_slice(b"ResolveMessage: ");
+        match this.node_message() {
+            Some(text) => out.extend_from_slice(&text),
+            None => out.extend_from_slice(&this.msg.data.text),
+        }
+        Ok(ZigString::init_utf8(&out).to_js(global))
+    }
+
     #[crate::host_fn(getter)]
     pub fn get_level(this: &Self, global: &JSGlobalObject) -> JsResult<JSValue> {
         Ok(ZigString::init(this.msg.kind.string()).to_js(global))
diff --git a/src/jsc/RuntimeTranspilerCache.rs b/src/jsc/RuntimeTranspilerCache.rs
index 2eee3816433a..3373c1402e99 100644
--- a/src/jsc/RuntimeTranspilerCache.rs
+++ b/src/jsc/RuntimeTranspilerCache.rs
@@ -235,7 +235,7 @@ impl Default for OutputCode {
 }
 
 impl OutputCode {
-    pub(crate) fn byte_slice(&self) -> &[u8] {
+    pub fn byte_slice(&self) -> &[u8] {
         match self {
             OutputCode::Utf8(b) => b,
             OutputCode::String(s) => s.byte_slice(),
diff --git a/src/jsc/VirtualMachine.rs b/src/jsc/VirtualMachine.rs
index b5a58a65b564..cd04a0a67544 100644
--- a/src/jsc/VirtualMachine.rs
+++ b/src/jsc/VirtualMachine.rs
@@ -477,6 +477,34 @@ impl VMHolder {
     extern "C" fn Bun__thisThreadHasVM() -> bool {
         VM.get().is_some()
     }
+
+    /// Node parity: `process.kill(self, sig)` with no JS handler for `sig`
+    /// flushes the CPU and heap profiles before sending the (likely fatal)
+    /// signal, mirroring node's `Kill` binding. Idempotent via `Option::take`.
+    #[unsafe(no_mangle)]
+    pub(crate) extern "C" fn Bun__writeProfilesBeforeSelfKill() {
+        let Some(vm_ptr) = VM.get() else { return };
+        // SAFETY: called on the JS thread that owns this VM (process._kill).
+        let vm = unsafe { &mut *vm_ptr };
+        if let Some(config) = vm.cpu_profiler_config.take() {
+            if let Err(e) =
+                crate::bun_cpu_profiler::stop_and_write_profile(vm.jsc_vm_mut(), &config)
+            {
+                bun_core::Output::err(<&'static str>::from(e), "Failed to write CPU profile", ());
+            }
+        }
+        if let Some(config) = vm.heap_profiler_config.take() {
+            if let Err(e) =
+                crate::bun_heap_profiler::generate_and_write_profile(vm.jsc_vm_mut(), &config)
+            {
+                bun_core::Output::err(e, "Failed to write heap profile", ());
+            }
+        }
+        // Node runs RunAtExit (incl. compile cache) on self-directed fatal signals. Non-latching:
+        // the signal may prove non-fatal, and latching here would no-op the real exit's persist.
+        // https://github.com/nodejs/node/blob/main/src/env.cc (AtExit(FlushCompileCache))
+        crate::node_compile_cache::persist_now();
+    }
 }
 
 #[thread_local]
@@ -1518,6 +1546,12 @@ impl VirtualMachine {
         }
         // `mem::take` above leaves an empty `Vec` (capacity already freed by drop).
         self.has_run_cleanup_hooks = true;
+
+        // Persist the Node compile cache (NODE_COMPILE_CACHE /
+        // module.enableCompileCache()) after user exit handlers ran.
+        if self.is_main_thread() {
+            crate::node_compile_cache::persist_at_exit();
+        }
     }
 
     pub fn global_exit(&mut self) -> ! {
@@ -1603,13 +1637,11 @@ impl VirtualMachine {
             // a terminal state. Ask it to reclaim them now (waits up to 1s).
             bun_http::shutdown_for_exit();
 
-            // The HTTP daemon is parked. Release any task it posted to our
-            // queue before observing `is_shutting_down` (the read is
-            // non-atomic and can lag the JS-thread store) — `FetchTasklet`'s
-            // `on_progress_update` would have dropped the JS-side ref, and
-            // without it the tasklet ⇄ `Box<AsyncHTTP>` cycle leaks. Must
-            // precede `destructOnExit` so `FetchTasklet::deinit` can drop its
-            // JSC `Strong`/`Weak` handles against a live heap.
+            // Release tasks the HTTP daemon posted before observing `is_shutting_down` (else the
+            // tasklet ⇄ `Box<AsyncHTTP>` cycle leaks); must precede `destructOnExit`. Wait for
+            // work-pool fs completions first — they post without a shutdown check, so a post
+            // landing after the drain leaks.
+            self.event_loop_mut().wait_for_concurrent_posters();
             self.event_loop_mut().release_queued_tasks_for_shutdown();
 
             if let Some(rare) = self.rare_data.as_deref_mut() {
@@ -3429,6 +3461,22 @@ impl VirtualMachine {
 
     /// Performs a hot reload: re-evaluates the entry point once any pending entry-point load settles.
     pub(crate) fn reload(&mut self, _: Option<&mut crate::hot_reloader::HotReloadTask>) {
+        if self.hot_reload == HOT_RELOAD_WATCH {
+            // Watch reload replaces the process: never defer on a pending
+            // entry promise (node restarts regardless of child state), and
+            // emit the --watch-kill-signal JS handlers first, like node.
+            crate::posix_signal_handle::emit_watch_kill_signal_before_reload(self.global());
+            let should_clear_terminal =
+                !self.env_loader().has_set_no_clear_terminal_on_reload(
+                    !bun_core::Output::enable_ansi_colors_stdout(),
+                );
+            // execve will not reach on_exit; flush the compile cache here like
+            // node's child does via AtExit(FlushCompileCache) on every restart.
+            crate::node_compile_cache::persist_now();
+            bun_core::Output::flush();
+            bun_core::reload_process(should_clear_terminal, false);
+        }
+
         if let Some(p) = self.pending_internal_promise {
             // SAFETY: `p` is a live JSC heap cell tracked by the VM.
             match crate::JSPromise::status_ptr(p) {
@@ -3451,11 +3499,6 @@ impl VirtualMachine {
         let should_clear_terminal = !self
             .env_loader()
             .has_set_no_clear_terminal_on_reload(!bun_core::Output::enable_ansi_colors_stdout());
-        if self.hot_reload == HOT_RELOAD_WATCH {
-            bun_core::Output::flush();
-            bun_core::reload_process(should_clear_terminal, false);
-        }
-
         if should_clear_terminal {
             bun_core::Output::flush();
             bun_core::Output::disable_buffering();
diff --git a/src/jsc/bindings/BunObject.cpp b/src/jsc/bindings/BunObject.cpp
index 2067f2f9e461..8a022228eb4c 100644
--- a/src/jsc/bindings/BunObject.cpp
+++ b/src/jsc/bindings/BunObject.cpp
@@ -705,16 +705,16 @@ JSC_DEFINE_HOST_FUNCTION(functionBunDeepEquals, (JSGlobalObject * globalObject,
 
     if (strict.isBoolean() && strict.asBoolean()) {
         if (skipPrototype.isBoolean() && skipPrototype.asBoolean()) {
-            bool isEqual = Bun__deepEquals<true, false, true>(globalObject, arg1, arg2, gcBuffer, stack, scope, true);
+            bool isEqual = Bun__deepEquals<true, false, false, true>(globalObject, arg1, arg2, gcBuffer, stack, scope, true);
             RETURN_IF_EXCEPTION(scope, {});
             return JSValue::encode(jsBoolean(isEqual));
         }
 
-        bool isEqual = Bun__deepEquals<true, false>(globalObject, arg1, arg2, gcBuffer, stack, scope, true);
+        bool isEqual = Bun__deepEquals<true, false, false>(globalObject, arg1, arg2, gcBuffer, stack, scope, true);
         RETURN_IF_EXCEPTION(scope, {});
         return JSValue::encode(jsBoolean(isEqual));
     } else {
-        bool isEqual = Bun__deepEquals<false, false>(globalObject, arg1, arg2, gcBuffer, stack, scope, true);
+        bool isEqual = Bun__deepEquals<false, false, false>(globalObject, arg1, arg2, gcBuffer, stack, scope, true);
         RETURN_IF_EXCEPTION(scope, {});
         return JSValue::encode(jsBoolean(isEqual));
     }
diff --git a/src/jsc/bindings/BunProcess.cpp b/src/jsc/bindings/BunProcess.cpp
index 24462959c223..ce39ea85cff8 100644
--- a/src/jsc/bindings/BunProcess.cpp
+++ b/src/jsc/bindings/BunProcess.cpp
@@ -129,6 +129,7 @@ typedef int mode_t;
 #endif
 
 #include <cstring>
+#include "ErrorStackTrace.h"
 extern "C" bool Bun__Node__ProcessNoDeprecation;
 extern "C" bool Bun__Node__ProcessNoWarnings;
 extern "C" bool Bun__Node__ProcessTraceWarnings;
@@ -138,6 +139,8 @@ extern "C" bool Bun__Node__getRedirectWarnings(BunString* out);
 extern "C" size_t Bun__Node__getDisabledWarnings(const uint8_t** bufs, size_t* lens, size_t cap);
 extern "C" bool Bun__getEnvValue(JSC::JSGlobalObject* globalObject, const ZigString* name, ZigString* value);
 extern "C" bool Bun__Node__ProcessThrowDeprecation;
+extern "C" bool Bun__Node__ProcessPendingDeprecation;
+extern "C" void Bun__writeProfilesBeforeSelfKill();
 extern "C" int32_t bun_stdio_tty[3];
 
 namespace Bun {
@@ -1029,7 +1032,9 @@ JSC_DEFINE_HOST_FUNCTION(Process_functionChdir, (JSC::JSGlobalObject * globalObj
     RETURN_IF_EXCEPTION(scope, {});
 
     auto* processObject = defaultGlobalObject(globalObject)->processObject();
-    processObject->setCachedCwd(vm, result.toStringOrNull(globalObject));
+    // Node clears its cwd cache on chdir (does_own_process_state.js) and lets
+    // the next process.cwd() re-query the OS - do not re-populate it here.
+    processObject->clearCachedCwd();
     RELEASE_AND_RETURN(scope, JSC::JSValue::encode(result));
 }
 
@@ -1185,17 +1190,104 @@ static void loadSignalNumberMap()
     });
 }
 
-extern "C" void Bun__onSignalForJS(int signalNumber, Zig::GlobalObject* globalObject)
+static void loadSignalNumberToNameMap()
+{
+    static std::once_flag signalNumberToNameMapOnceFlag;
+    std::call_once(signalNumberToNameMapOnceFlag, [] {
+        auto signalNames = getSignalNames();
+        signalNumberToNameMap = new HashMap<int, String>();
+        signalNumberToNameMap->reserveInitialCapacity(31);
+        signalNumberToNameMap->add(SIGHUP, signalNames[0]);
+        signalNumberToNameMap->add(SIGINT, signalNames[1]);
+        signalNumberToNameMap->add(SIGQUIT, signalNames[2]);
+        signalNumberToNameMap->add(SIGILL, signalNames[3]);
+#ifdef SIGTRAP
+        signalNumberToNameMap->add(SIGTRAP, signalNames[4]);
+#endif
+        signalNumberToNameMap->add(SIGABRT, signalNames[5]);
+#ifdef SIGIOT
+        signalNumberToNameMap->add(SIGIOT, signalNames[6]);
+#endif
+#ifdef SIGBUS
+        signalNumberToNameMap->add(SIGBUS, signalNames[7]);
+#endif
+        signalNumberToNameMap->add(SIGFPE, signalNames[8]);
+        signalNumberToNameMap->add(SIGKILL, signalNames[9]);
+#ifdef SIGUSR1
+        signalNumberToNameMap->add(SIGUSR1, signalNames[10]);
+#endif
+        signalNumberToNameMap->add(SIGSEGV, signalNames[11]);
+#ifdef SIGUSR2
+        signalNumberToNameMap->add(SIGUSR2, signalNames[12]);
+#endif
+#ifdef SIGPIPE
+        signalNumberToNameMap->add(SIGPIPE, signalNames[13]);
+#endif
+#ifdef SIGALRM
+        signalNumberToNameMap->add(SIGALRM, signalNames[14]);
+#endif
+        signalNumberToNameMap->add(SIGTERM, signalNames[15]);
+#ifdef SIGCHLD
+        signalNumberToNameMap->add(SIGCHLD, signalNames[16]);
+#endif
+#ifdef SIGCONT
+        signalNumberToNameMap->add(SIGCONT, signalNames[17]);
+#endif
+#ifdef SIGSTOP
+        signalNumberToNameMap->add(SIGSTOP, signalNames[18]);
+#endif
+#ifdef SIGTSTP
+        signalNumberToNameMap->add(SIGTSTP, signalNames[19]);
+#endif
+#ifdef SIGTTIN
+        signalNumberToNameMap->add(SIGTTIN, signalNames[20]);
+#endif
+#ifdef SIGTTOU
+        signalNumberToNameMap->add(SIGTTOU, signalNames[21]);
+#endif
+#ifdef SIGURG
+        signalNumberToNameMap->add(SIGURG, signalNames[22]);
+#endif
+#ifdef SIGXCPU
+        signalNumberToNameMap->add(SIGXCPU, signalNames[23]);
+#endif
+#ifdef SIGXFSZ
+        signalNumberToNameMap->add(SIGXFSZ, signalNames[24]);
+#endif
+#ifdef SIGVTALRM
+        signalNumberToNameMap->add(SIGVTALRM, signalNames[25]);
+#endif
+#ifdef SIGPROF
+        signalNumberToNameMap->add(SIGPROF, signalNames[26]);
+#endif
+        signalNumberToNameMap->add(SIGWINCH, signalNames[27]);
+#ifdef SIGIO
+        signalNumberToNameMap->add(SIGIO, signalNames[28]);
+#endif
+#ifdef SIGINFO
+        signalNumberToNameMap->add(SIGINFO, signalNames[29]);
+#endif
+#ifdef SIGSYS
+        signalNumberToNameMap->add(SIGSYS, signalNames[30]);
+#endif
+#ifdef SIGBREAK
+        signalNumberToNameMap->add(SIGBREAK, signalNames[31]);
+#endif
+    });
+}
+
+extern "C" bool Bun__onSignalForJS(int signalNumber, Zig::GlobalObject* globalObject)
 {
     Process* process = globalObject->processObject();
 
+    loadSignalNumberToNameMap();
     String signalName = signalNumberToNameMap->get(signalNumber);
     Identifier signalNameIdentifier = Identifier::fromString(JSC::getVM(globalObject), signalName);
     MarkedArgumentBuffer args;
     args.append(jsString(JSC::getVM(globalObject), signalNameIdentifier.string()));
     args.append(jsNumber(signalNumber));
 
-    process->wrapped().emitForBindings(signalNameIdentifier, args);
+    return process->wrapped().emitForBindings(signalNameIdentifier, args);
 }
 
 #if OS(WINDOWS)
@@ -1443,6 +1535,7 @@ extern "C" bool Bun__shouldIgnoreOneDisconnectEventListener(JSC::JSGlobalObject*
 extern "C" void Bun__ensureSignalHandler();
 extern "C" bool Bun__isMainThreadVM();
 extern "C" void Bun__onPosixSignal(int signalNumber);
+extern "C" void Bun__onSignalListenerCountChanged(int signalNumber, int listenerCount);
 
 __attribute__((noinline)) static void forwardSignal(int signalNumber)
 {
@@ -1451,6 +1544,31 @@ __attribute__((noinline)) static void forwardSignal(int signalNumber)
     Bun__onPosixSignal(signalNumber);
 }
 
+// `bun run --watch` keeps this signal's handler installed for the process
+// lifetime (node's watcher process owns SIGINT the same way), so the
+// listener-removal path below must never restore SIG_DFL for it.
+static int watchModeStickySignal = 0;
+
+#if !OS(WINDOWS)
+static void installForwardSignalHandler(int signalNumber)
+{
+    struct sigaction action;
+    memset(&action, 0, sizeof(struct sigaction));
+    action.sa_handler = forwardSignal;
+    sigemptyset(&action.sa_mask);
+    sigaddset(&action.sa_mask, signalNumber);
+    action.sa_flags = SA_RESTART;
+    sigaction(signalNumber, &action, nullptr);
+}
+
+extern "C" void Bun__installWatchModeSignalHandler(int signalNumber)
+{
+    Bun__ensureSignalHandler();
+    watchModeStickySignal = signalNumber;
+    installForwardSignalHandler(signalNumber);
+}
+#endif
+
 extern "C" void Bun__MemoryPressure__install(JSC::JSGlobalObject* global);
 extern "C" void Bun__MemoryPressure__uninstall(JSC::JSGlobalObject* global);
 
@@ -1496,94 +1614,16 @@ static void onDidChangeListeners(EventEmitter& eventEmitter, const Identifier& e
 
         // Signal Handlers
         loadSignalNumberMap();
-        static std::once_flag signalNumberToNameMapOnceFlag;
-        std::call_once(signalNumberToNameMapOnceFlag, [] {
-            auto signalNames = getSignalNames();
-            signalNumberToNameMap = new HashMap<int, String>();
-            signalNumberToNameMap->reserveInitialCapacity(31);
-            signalNumberToNameMap->add(SIGHUP, signalNames[0]);
-            signalNumberToNameMap->add(SIGINT, signalNames[1]);
-            signalNumberToNameMap->add(SIGQUIT, signalNames[2]);
-            signalNumberToNameMap->add(SIGILL, signalNames[3]);
-#ifdef SIGTRAP
-            signalNumberToNameMap->add(SIGTRAP, signalNames[4]);
-#endif
-            signalNumberToNameMap->add(SIGABRT, signalNames[5]);
-#ifdef SIGIOT
-            signalNumberToNameMap->add(SIGIOT, signalNames[6]);
-#endif
-#ifdef SIGBUS
-            signalNumberToNameMap->add(SIGBUS, signalNames[7]);
-#endif
-            signalNumberToNameMap->add(SIGFPE, signalNames[8]);
-            signalNumberToNameMap->add(SIGKILL, signalNames[9]);
-#ifdef SIGUSR1
-            signalNumberToNameMap->add(SIGUSR1, signalNames[10]);
-#endif
-            signalNumberToNameMap->add(SIGSEGV, signalNames[11]);
-#ifdef SIGUSR2
-            signalNumberToNameMap->add(SIGUSR2, signalNames[12]);
-#endif
-#ifdef SIGPIPE
-            signalNumberToNameMap->add(SIGPIPE, signalNames[13]);
-#endif
-#ifdef SIGALRM
-            signalNumberToNameMap->add(SIGALRM, signalNames[14]);
-#endif
-            signalNumberToNameMap->add(SIGTERM, signalNames[15]);
-#ifdef SIGCHLD
-            signalNumberToNameMap->add(SIGCHLD, signalNames[16]);
-#endif
-#ifdef SIGCONT
-            signalNumberToNameMap->add(SIGCONT, signalNames[17]);
-#endif
-#ifdef SIGSTOP
-            signalNumberToNameMap->add(SIGSTOP, signalNames[18]);
-#endif
-#ifdef SIGTSTP
-            signalNumberToNameMap->add(SIGTSTP, signalNames[19]);
-#endif
-#ifdef SIGTTIN
-            signalNumberToNameMap->add(SIGTTIN, signalNames[20]);
-#endif
-#ifdef SIGTTOU
-            signalNumberToNameMap->add(SIGTTOU, signalNames[21]);
-#endif
-#ifdef SIGURG
-            signalNumberToNameMap->add(SIGURG, signalNames[22]);
-#endif
-#ifdef SIGXCPU
-            signalNumberToNameMap->add(SIGXCPU, signalNames[23]);
-#endif
-#ifdef SIGXFSZ
-            signalNumberToNameMap->add(SIGXFSZ, signalNames[24]);
-#endif
-#ifdef SIGVTALRM
-            signalNumberToNameMap->add(SIGVTALRM, signalNames[25]);
-#endif
-#ifdef SIGPROF
-            signalNumberToNameMap->add(SIGPROF, signalNames[26]);
-#endif
-            signalNumberToNameMap->add(SIGWINCH, signalNames[27]);
-#ifdef SIGIO
-            signalNumberToNameMap->add(SIGIO, signalNames[28]);
-#endif
-#ifdef SIGINFO
-            signalNumberToNameMap->add(SIGINFO, signalNames[29]);
-#endif
-#ifdef SIGSYS
-            signalNumberToNameMap->add(SIGSYS, signalNames[30]);
-#endif
-#ifdef SIGBREAK
-            signalNumberToNameMap->add(SIGBREAK, signalNames[31]);
-#endif
-        });
+        loadSignalNumberToNameMap();
 
         if (!signalToContextIdsMap) {
             signalToContextIdsMap = new HashMap<int, SignalHandleValue>();
         }
 
         if (auto signalNumber = signalNameToNumberMap->get(eventName.string())) {
+            int listenerCount = eventEmitter.listenerCount(eventName);
+            // Mirror the count for the watcher thread's --watch-kill-signal check.
+            Bun__onSignalListenerCountChanged(signalNumber, listenerCount);
 #if OS(LINUX)
             // SIGKILL and SIGSTOP cannot be handled, and JSC needs its own signal handler to
             // suspend and resume the JS thread which we must not override.
@@ -1607,18 +1647,7 @@ static void onDidChangeListeners(EventEmitter& eventEmitter, const Identifier& e
                         };
 #if !OS(WINDOWS)
                         Bun__ensureSignalHandler();
-                        struct sigaction action;
-                        memset(&action, 0, sizeof(struct sigaction));
-
-                        // Set the handler in the action struct
-                        action.sa_handler = forwardSignal;
-
-                        // Clear the sa_mask
-                        sigemptyset(&action.sa_mask);
-                        sigaddset(&action.sa_mask, signalNumber);
-                        action.sa_flags = SA_RESTART;
-
-                        sigaction(signalNumber, &action, nullptr);
+                        installForwardSignalHandler(signalNumber);
 #else
                         signal_handle.handle = Bun__UVSignalHandle__init(
                             eventEmitter.scriptExecutionContext()->jsGlobalObject(),
@@ -1632,17 +1661,21 @@ static void onDidChangeListeners(EventEmitter& eventEmitter, const Identifier& e
                         signalToContextIdsMap->set(signalNumber, signal_handle);
                     }
                 } else {
-                    if (signalToContextIdsMap->find(signalNumber) != signalToContextIdsMap->end() && eventEmitter.listenerCount(eventName) == 0) {
-
+                    if (signalToContextIdsMap->find(signalNumber) != signalToContextIdsMap->end() && listenerCount == 0) {
+                        // The watch-mode sticky signal keeps its OS handler installed; only the
+                        // handler teardown is skipped. The map entry is still removed — it is the
+                        // "has JS listeners" source of truth that e.g. self-kill flush consults.
+                        if (signalNumber != watchModeStickySignal) {
 #if !OS(WINDOWS)
-                        if (void (*oldHandler)(int) = signal(signalNumber, SIG_DFL); oldHandler != forwardSignal) {
-                            // Don't uninstall the old handler if it's not the one we installed.
-                            signal(signalNumber, oldHandler);
-                        }
+                            if (void (*oldHandler)(int) = signal(signalNumber, SIG_DFL); oldHandler != forwardSignal) {
+                                // Don't uninstall the old handler if it's not the one we installed.
+                                signal(signalNumber, oldHandler);
+                            }
 #else
-                        SignalHandleValue signal_handle = signalToContextIdsMap->get(signalNumber);
-                        Bun__UVSignalHandle__close(signal_handle.handle);
+                            SignalHandleValue signal_handle = signalToContextIdsMap->get(signalNumber);
+                            Bun__UVSignalHandle__close(signal_handle.handle);
 #endif
+                        }
                         signalToContextIdsMap->remove(signalNumber);
                     }
                 }
@@ -2733,7 +2766,7 @@ static JSValue constructProcessConfigObject(VM& vm, JSObject* processObject)
         Zig::GlobalObject::reportUncaughtExceptionAtEventLoop(globalObject, exception);
         return JSC::jsUndefined();
     }
-    variables->putDirect(vm, JSC::Identifier::fromString(vm, "v8_enable_i8n_support"_s), JSC::jsNumber(1), 0);
+    variables->putDirect(vm, JSC::Identifier::fromString(vm, "v8_enable_i18n_support"_s), JSC::jsNumber(1), 0);
     variables->putDirect(vm, JSC::Identifier::fromString(vm, "enable_lto"_s), JSC::jsBoolean(false), 0);
     // Node 26's common.gypi evaluates enable_thin_lto/lto_jobs conditions; gyp
     // hard-fails on undefined variables, so node-gyp builds need them present.
@@ -3533,6 +3566,32 @@ JSC_DEFINE_HOST_FUNCTION(Process_functionBinding, (JSGlobalObject * jsGlobalObje
     auto throwScope = DECLARE_THROW_SCOPE(vm);
     auto globalObject = uncheckedDowncast<Zig::GlobalObject>(jsGlobalObject);
     auto process = globalObject->processObject();
+
+    if (Bun__Node__ProcessPendingDeprecation && !process->m_warnedProcessBinding) {
+        // Node latches DEP0111 once per Environment via deprecate(). Bun's own builtins call
+        // process.binding() too (node uses internalBinding), so internal callers don't warn/latch.
+        String callerURL;
+        JSC::StackVisitor::visit(callFrame, vm, [&](JSC::StackVisitor& visitor) -> WTF::IterationStatus {
+            if (Zig::isImplementationVisibilityPrivate(visitor))
+                return WTF::IterationStatus::Continue;
+            if (visitor->hasLineAndColumnInfo()) {
+                callerURL = Zig::sourceURL(visitor);
+                return WTF::IterationStatus::Done;
+            }
+            return WTF::IterationStatus::Continue;
+        });
+        bool isInternalCaller = callerURL.startsWith("node:"_s) || callerURL.startsWith("bun:"_s) || callerURL.startsWith("internal"_s);
+        if (!isInternalCaller) {
+            process->m_warnedProcessBinding = true;
+            Process::emitWarning(globalObject,
+                jsString(vm, String("process.binding() is deprecated. Please use public APIs instead."_s)),
+                jsString(vm, String("DeprecationWarning"_s)),
+                jsString(vm, String("DEP0111"_s)),
+                jsUndefined());
+            RETURN_IF_EXCEPTION(throwScope, {});
+        }
+    }
+
     auto moduleName = callFrame->argument(0).toWTFString(globalObject);
     RETURN_IF_EXCEPTION(throwScope, {});
 
@@ -4572,7 +4631,20 @@ JSC_DEFINE_HOST_FUNCTION(Process_functionReallyKill, (JSC::JSGlobalObject * glob
     RETURN_IF_EXCEPTION(scope, {});
 
 #if !OS(WINDOWS)
-    if (pid == getpid()) {
+    int ownPid = getpid();
+#else
+    int ownPid = uv_os_getpid();
+#endif
+    // Node's Kill binding runs RunAtExit for a self-directed unhandled signal, so flush profiles
+    // first. `signalToContextIdsMap` is mutated only on the main thread; workers never set
+    // profiler configs, so skipping the flush there avoids a rehash race.
+    if (signal > 0 && (pid == 0 || pid == -1 || pid == ownPid || pid == -ownPid)
+        && !(Bun__isMainThreadVM() && signalToContextIdsMap && signalToContextIdsMap->contains(signal))) {
+        Bun__writeProfilesBeforeSelfKill();
+    }
+
+#if !OS(WINDOWS)
+    if (pid == ownPid) {
         Bun__suppressCrashOnProcessKillSelfIfDesired();
     }
     int result = kill(pid, signal);
diff --git a/src/jsc/bindings/BunProcess.h b/src/jsc/bindings/BunProcess.h
index 2276ac137ef2..560b16e9dc50 100644
--- a/src/jsc/bindings/BunProcess.h
+++ b/src/jsc/bindings/BunProcess.h
@@ -59,6 +59,10 @@ class Process : public WebCore::JSEventEmitter {
     // function-local static would be shared across worker threads, so a
     // worker's exit would suppress the main thread's 'exit' event.
     bool m_isExiting = false;
+    // DEP0111/DEP0119 latches. Node's deprecate() closures live in each
+    // Environment's own JS, so every worker warns once itself.
+    bool m_warnedProcessBinding = false;
+    bool m_warnedErrname = false;
 
     static constexpr unsigned StructureFlags = Base::StructureFlags | HasStaticPropertyTable;
 
@@ -79,6 +83,7 @@ class Process : public WebCore::JSEventEmitter {
 
     JSString* cachedCwd() { return m_cachedCwd.get(); }
     void setCachedCwd(JSC::VM& vm, JSString* cwd) { m_cachedCwd.set(vm, this, cwd); }
+    void clearCachedCwd() { m_cachedCwd.clear(); }
 
     JSValue getArgv(JSGlobalObject* globalObject);
     void setArgv(JSGlobalObject* globalObject, JSValue argv);
@@ -137,4 +142,9 @@ class Process : public WebCore::JSEventEmitter {
 
 JSC_DECLARE_HOST_FUNCTION(Process_functionDlopen);
 
+// Routes its argument onto the uncaught-exception path. Used by the
+// process.nextTick drain and, via $newCppFunction, by the node-style
+// callback shims in src/js.
+JSC_DECLARE_HOST_FUNCTION(jsFunctionReportUncaughtException);
+
 } // namespace Bun
diff --git a/src/jsc/bindings/DOMURL.cpp b/src/jsc/bindings/DOMURL.cpp
index 88dc5fbf6095..64718d73cf3f 100644
--- a/src/jsc/bindings/DOMURL.cpp
+++ b/src/jsc/bindings/DOMURL.cpp
@@ -26,16 +26,135 @@
 #include "config.h"
 #include "DOMURL.h"
 
+#include "NodeURLHelpers.h"
 #include "URLSearchParams.h"
 
 namespace WebCore {
 
-static inline String redact(const String& input)
+// The WHATWG parser (WebKit) fast-paths all-ASCII hosts without validating
+// xn-- labels; Node's ada rejects invalid punycode in special-scheme hosts.
+static bool hasValidParsedHost(const URL& url)
 {
-    if (input.contains('@'))
-        return "<redacted>"_s;
+    // Cheap accept first: hosts without an invalid xn-- label are always fine.
+    if (Bun::hasValidPunycodeHost(url.host()))
+        return true;
+    // Non-special schemes have opaque hosts and skip IDNA entirely.
+    return !url.hasSpecialScheme();
+}
+
+// Platform ICU may predate Unicode 15.1/16.0 (node v26 uses ada::idna): apply the Unicode 16
+// IDNA delta to the host span only when it contains a delta source code point. Returns a null
+// String when no rewrite is needed (the common path). See NodeURL.cpp for the delta table.
+static String applyIDNADeltaToURLAuthority(const String& urlString, StringView specialBaseScheme = {})
+{
+    // Percent-encoded delta sources are all-ASCII and intentionally excluded; the durable fix
+    // is bundling Unicode-16 ICU data so the parser's own domain-to-ASCII handles it uniformly.
+    if (urlString.is8Bit() || !urlString.length())
+        return {};
+
+    StringView view { urlString };
 
-    return makeString('"', input, '"');
+    // Mirror https://url.spec.whatwg.org/#concept-basic-url-parser steps 1/3 (strip C0/tab/CR/LF)
+    // so an embedded tab in the scheme or `//` run does not defeat the special-scheme match below.
+    auto isTabOrNewline = [](char16_t ch) { return ch == '\t' || ch == '\n' || ch == '\r'; };
+    String stripped;
+    if (view.find(isTabOrNewline) != notFound) {
+        stripped = urlString.removeCharacters(isTabOrNewline);
+        view = stripped;
+    }
+    size_t scan = 0;
+    while (scan < view.length() && (view[scan] <= 0x20))
+        scan++;
+
+    // Only the six special schemes run IDNA (https://url.spec.whatwg.org/#special-scheme). The
+    // special-authority-ignore-slashes state consumes any '/'|'\\' run after ':'; same-scheme-as-base
+    // without "//" enters the relative state (path, not host). Scheme-relative "//" inherits base.
+    auto isSlash = [](char16_t ch) { return ch == '/' || ch == '\\'; };
+    // file: routes through file state/file slash state/file host state: only
+    // exactly two slashes then a non-slash introduce a host; file:///x and
+    // file:/x have an empty host and `x` is a path segment.
+    auto locateAuthority = [&](size_t afterColon, bool isFile) -> size_t {
+        const bool hasDoubleSlash = afterColon + 1 < view.length()
+            && isSlash(view[afterColon]) && isSlash(view[afterColon + 1]);
+        if (isFile) {
+            if (!hasDoubleSlash)
+                return notFound;
+            size_t start = afterColon + 2;
+            if (start < view.length() && isSlash(view[start]))
+                return notFound;
+            return start;
+        }
+        size_t start = afterColon;
+        while (start < view.length() && isSlash(view[start]))
+            start++;
+        return start;
+    };
+    size_t authorityStart = notFound;
+    if (!specialBaseScheme.isEmpty() && scan + 1 < view.length() && isSlash(view[scan]) && isSlash(view[scan + 1])) {
+        authorityStart = locateAuthority(scan, equalLettersIgnoringASCIICase(specialBaseScheme, "file"_s));
+    } else {
+        size_t colon = view.find(':', scan);
+        if (colon != notFound) {
+            auto scheme = view.substring(scan, colon - scan);
+            const bool isFile = equalLettersIgnoringASCIICase(scheme, "file"_s);
+            if (equalLettersIgnoringASCIICase(scheme, "http"_s) || equalLettersIgnoringASCIICase(scheme, "https"_s)
+                || equalLettersIgnoringASCIICase(scheme, "ws"_s) || equalLettersIgnoringASCIICase(scheme, "wss"_s)
+                || equalLettersIgnoringASCIICase(scheme, "ftp"_s) || isFile) {
+                size_t afterColon = colon + 1;
+                const bool hasDoubleSlash = afterColon + 1 < view.length()
+                    && isSlash(view[afterColon]) && isSlash(view[afterColon + 1]);
+                // Same scheme as the base and no "//" → relative-state path,
+                // not an authority; the delta must not touch it.
+                if (!hasDoubleSlash && equalIgnoringASCIICase(scheme, specialBaseScheme))
+                    return {};
+                authorityStart = locateAuthority(afterColon, isFile);
+            }
+        }
+    }
+    if (authorityStart == notFound)
+        return {};
+
+    // The authority ends at the first path/query/fragment terminator;
+    // backslash terminates it for special schemes and never appears in a
+    // valid host, so treating it as a terminator is safe for both kinds.
+    size_t authorityEnd = view.length();
+    for (size_t i = authorityStart; i < view.length(); i++) {
+        char16_t ch = view[i];
+        if (ch == '/' || ch == '?' || ch == '#' || ch == '\\') {
+            authorityEnd = i;
+            break;
+        }
+    }
+
+    // Userinfo is percent-encoded, not IDNA-mapped, in node too: only the
+    // host span after the last '@' gets the delta.
+    size_t hostStart = authorityStart;
+    auto authority = view.substring(authorityStart, authorityEnd - authorityStart);
+    size_t at = authority.reverseFind('@');
+    if (at != notFound)
+        hostStart = authorityStart + at + 1;
+
+    // A '['-prefixed host goes straight to the IPv6 parser and never runs
+    // domain-to-ASCII; leave it untouched so the parser sees the original.
+    if (hostStart < view.length() && view[hostStart] == '[')
+        return {};
+
+    // Port span must stay verbatim: the delta strips ignored-class code points, which would turn
+    // an invalid non-digit port char into a valid port. Last ':' is the port separator here.
+    auto hostAndPort = view.substring(hostStart, authorityEnd - hostStart);
+    size_t portColon = hostAndPort.reverseFind(':');
+    size_t hostEnd = portColon == notFound ? authorityEnd : hostStart + portColon;
+
+    auto hostView = view.substring(hostStart, hostEnd - hostStart);
+    if (!Bun::containsUnicode16IDNADeltaSource(hostView))
+        return {};
+
+    auto mappedHost = Bun::applyUnicode16IDNADelta(hostView.toString());
+    StringBuilder builder;
+    builder.append(view.left(hostStart));
+    builder.append(mappedHost);
+    builder.append(view.substring(hostEnd));
+    return builder.toString();
 }
 
 inline DOMURL::DOMURL(URL&& completeURL)
@@ -45,39 +164,51 @@ inline DOMURL::DOMURL(URL&& completeURL)
     ASSERT(m_url.isValid());
 }
 
+// The Exception message carries the input and its extra the raw base string
+// (null if none was given); the JS error's message stays "Invalid URL" and
+// they surface as `error.input` / `error.base` like Node's ERR_INVALID_URL
+// (see createDOMException).
 ExceptionOr<Ref<DOMURL>> DOMURL::create(const String& url)
 {
-    URL completeURL { url };
-    if (!completeURL.isValid())
-        return Exception { InvalidURLError, makeString(redact(url), " cannot be parsed as a URL."_s) };
+    auto mapped = applyIDNADeltaToURLAuthority(url);
+    URL completeURL { mapped.isNull() ? url : mapped };
+    if (!completeURL.isValid() || !hasValidParsedHost(completeURL))
+        return Exception { InvalidURLError, url };
     return adoptRef(*new DOMURL(WTF::move(completeURL)));
 }
 
-ExceptionOr<Ref<DOMURL>> DOMURL::create(const String& url, const URL& base)
+ExceptionOr<Ref<DOMURL>> DOMURL::create(const String& url, const URL& base, const String& baseInput)
 {
     ASSERT(base.isValid() || base.isNull());
-    URL completeURL { base, url };
-    if (!completeURL.isValid())
-        return Exception { InvalidURLError, makeString(redact(url), " cannot be parsed as a URL."_s) };
+    auto mapped = applyIDNADeltaToURLAuthority(url, base.hasSpecialScheme() ? base.protocol() : StringView {});
+    URL completeURL { base, mapped.isNull() ? url : mapped };
+    if (!completeURL.isValid() || !hasValidParsedHost(completeURL))
+        return Exception { InvalidURLError, url, baseInput };
     return adoptRef(*new DOMURL(WTF::move(completeURL)));
 }
 
 ExceptionOr<Ref<DOMURL>> DOMURL::create(const String& url, const String& base)
 {
-    URL baseURL { base };
-    if (!base.isNull() && !baseURL.isValid())
-        return Exception { InvalidURLError, makeString(redact(url), " cannot be parsed as a URL against "_s, redact(base)) };
-    return create(url, baseURL);
+    auto mappedBase = applyIDNADeltaToURLAuthority(base);
+    URL baseURL { mappedBase.isNull() ? base : mappedBase };
+    if (!base.isNull() && (!baseURL.isValid() || !hasValidParsedHost(baseURL)))
+        return Exception { InvalidURLError, url, base };
+    return create(url, baseURL, base);
 }
 
 DOMURL::~DOMURL() = default;
 
 static URL parseInternal(const String& url, const String& base)
 {
-    URL baseURL { base };
-    if (!base.isNull() && !baseURL.isValid())
+    auto mappedBase = applyIDNADeltaToURLAuthority(base);
+    URL baseURL { mappedBase.isNull() ? base : mappedBase };
+    if (!base.isNull() && (!baseURL.isValid() || !hasValidParsedHost(baseURL)))
+        return {};
+    auto mapped = applyIDNADeltaToURLAuthority(url, baseURL.hasSpecialScheme() ? baseURL.protocol() : StringView {});
+    URL result { baseURL, mapped.isNull() ? url : mapped };
+    if (result.isValid() && !hasValidParsedHost(result))
         return {};
-    return { baseURL, url };
+    return result;
 }
 
 RefPtr<DOMURL> DOMURL::parse(const String& url, const String& base)
@@ -95,10 +226,11 @@ bool DOMURL::canParse(const String& url, const String& base)
 
 ExceptionOr<void> DOMURL::setHref(const String& url)
 {
-    URL completeURL { URL {}, url };
-    if (!completeURL.isValid()) {
+    auto mapped = applyIDNADeltaToURLAuthority(url);
+    URL completeURL { URL {}, mapped.isNull() ? url : mapped };
+    if (!completeURL.isValid() || !hasValidParsedHost(completeURL)) {
 
-        return Exception { InvalidURLError, makeString(redact(url), " cannot be parsed as a URL."_s) };
+        return Exception { InvalidURLError, url };
     }
     m_url = WTF::move(completeURL);
     m_searchParamsDirty = false;
diff --git a/src/jsc/bindings/DOMURL.h b/src/jsc/bindings/DOMURL.h
index 58d48d630696..7389870debbb 100644
--- a/src/jsc/bindings/DOMURL.h
+++ b/src/jsc/bindings/DOMURL.h
@@ -72,7 +72,7 @@ class DOMURL final : public RefCounted<DOMURL>, public CanMakeWeakPtr<DOMURL>, p
     }
 
 private:
-    static ExceptionOr<Ref<DOMURL>> create(const String& url, const URL& base);
+    static ExceptionOr<Ref<DOMURL>> create(const String& url, const URL& base, const String& baseInput);
     DOMURL(URL&& completeURL);
 
     URL fullURL() const final
diff --git a/src/jsc/bindings/ErrorCode.cpp b/src/jsc/bindings/ErrorCode.cpp
index bf25cba86440..6114d1d771e6 100644
--- a/src/jsc/bindings/ErrorCode.cpp
+++ b/src/jsc/bindings/ErrorCode.cpp
@@ -1067,11 +1067,16 @@ JSC::EncodedJSValue INVALID_ARG_VALUE(JSC::ThrowScope& throwScope, JSC::JSGlobal
 // for validateOneOf
 JSC::EncodedJSValue INVALID_ARG_VALUE(JSC::ThrowScope& throwScope, JSC::JSGlobalObject* globalObject, JSC::JSValue name, JSC::JSValue value, WTF::ASCIILiteral reason, JSC::JSArray* oneOf)
 {
-    WTF::StringBuilder builder;
-    builder.append("The argument '"_s);
-    JSValueToStringSafe(globalObject, builder, name);
+    WTF::StringBuilder nameBuilder;
+    JSValueToStringSafe(globalObject, nameBuilder, name);
     RELEASE_RETURN_IF_EXCEPTION(throwScope, {});
+    auto nameString = nameBuilder.toString();
 
+    WTF::StringBuilder builder;
+    builder.append("The "_s);
+    // Node treats dotted names ('options.diff') as properties, plain names as arguments.
+    builder.append(nameString.contains('.') ? "property '"_s : "argument '"_s);
+    builder.append(nameString);
     builder.append("' "_s);
     builder.append(reason);
     unsigned length = oneOf->length();
diff --git a/src/jsc/bindings/ErrorCode.ts b/src/jsc/bindings/ErrorCode.ts
index b36ab04d45ce..d1ce4e83dc24 100644
--- a/src/jsc/bindings/ErrorCode.ts
+++ b/src/jsc/bindings/ErrorCode.ts
@@ -367,6 +367,7 @@ const errors: ErrorCodeMapping = [
   // llhttp reports a missing CRLF after a chunk's data as HPE_STRICT,
   // distinct from a malformed chunk-size line (HPE_INVALID_CHUNK_SIZE).
   ["HPE_STRICT", Error],
+  ["ERR_NOT_BUILDING_SNAPSHOT", Error],
   ["ERR_CANNOT_WATCH_SIGINT", Error],
   ["ERR_INSPECTOR_NOT_AVAILABLE", Error],
   ["ERR_INVALID_REPL_EVAL_CONFIG", TypeError],
diff --git a/src/jsc/bindings/Exception.h b/src/jsc/bindings/Exception.h
index a5b09e9bf40a..c14e1d7ba8b4 100644
--- a/src/jsc/bindings/Exception.h
+++ b/src/jsc/bindings/Exception.h
@@ -35,33 +35,39 @@ namespace WebCore {
 
 class Exception {
 public:
-    explicit Exception(ExceptionCode, String = {});
+    explicit Exception(ExceptionCode, String = {}, String = {});
 
     ExceptionCode code() const { return m_code; }
     const String& message() const { return m_message; }
     String&& releaseMessage() { return WTF::move(m_message); }
+    // Optional secondary payload for codes that need more than one string to
+    // shape the JS error (currently InvalidURLError's `error.base`).
+    const String& extra() const { return m_extra; }
+    String&& releaseExtra() { return WTF::move(m_extra); }
 
     Exception isolatedCopy() const
     {
-        return Exception { m_code, m_message.isolatedCopy() };
+        return Exception { m_code, m_message.isolatedCopy(), m_extra.isolatedCopy() };
     }
 
 private:
     ExceptionCode m_code;
     String m_message;
+    String m_extra;
 };
 
 Exception isolatedCopy(Exception&&);
 
-inline Exception::Exception(ExceptionCode code, String message)
+inline Exception::Exception(ExceptionCode code, String message, String extra)
     : m_code { code }
     , m_message { WTF::move(message) }
+    , m_extra { WTF::move(extra) }
 {
 }
 
 inline Exception isolatedCopy(Exception&& value)
 {
-    return Exception { value.code(), value.releaseMessage().isolatedCopy() };
+    return Exception { value.code(), value.releaseMessage().isolatedCopy(), value.releaseExtra().isolatedCopy() };
 }
 
 }
diff --git a/src/jsc/bindings/IPC.cpp b/src/jsc/bindings/IPC.cpp
index e4a60f60152e..458861018d7d 100644
--- a/src/jsc/bindings/IPC.cpp
+++ b/src/jsc/bindings/IPC.cpp
@@ -36,3 +36,33 @@ extern "C" [[ZIG_EXPORT(zero_is_throw)]] JSC::EncodedJSValue IPCParse(Zig::Globa
     RETURN_IF_EXCEPTION(scope, {});
     return JSC::JSValue::encode(result);
 }
+
+extern "C" [[ZIG_EXPORT(zero_is_throw)]] JSC::EncodedJSValue IPCTagAdvancedBuffers(Zig::GlobalObject* global, JSC::EncodedJSValue message)
+{
+    auto& vm = JSC::getVM(global);
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    JSC::JSFunction* tagFunction = global->m_ipcTagAdvancedBuffersFunction.getInitializedOnMainThread(global);
+    JSC::CallData callData = JSC::getCallData(tagFunction);
+
+    JSC::MarkedArgumentBuffer args;
+    args.append(JSC::JSValue::decode(message));
+
+    auto result = JSC::call(global, tagFunction, callData, JSC::jsUndefined(), args);
+    RETURN_IF_EXCEPTION(scope, {});
+    return JSC::JSValue::encode(result);
+}
+
+extern "C" [[ZIG_EXPORT(zero_is_throw)]] JSC::EncodedJSValue IPCRestoreAdvancedBuffers(Zig::GlobalObject* global, JSC::EncodedJSValue envelope)
+{
+    auto& vm = JSC::getVM(global);
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    JSC::JSFunction* restoreFunction = global->m_ipcRestoreAdvancedBuffersFunction.getInitializedOnMainThread(global);
+    JSC::CallData callData = JSC::getCallData(restoreFunction);
+
+    JSC::MarkedArgumentBuffer args;
+    args.append(JSC::JSValue::decode(envelope));
+
+    auto result = JSC::call(global, restoreFunction, callData, JSC::jsUndefined(), args);
+    RETURN_IF_EXCEPTION(scope, {});
+    return JSC::JSValue::encode(result);
+}
diff --git a/src/jsc/bindings/ImportMetaObject.cpp b/src/jsc/bindings/ImportMetaObject.cpp
index d7225633712d..d01ce5d6802c 100644
--- a/src/jsc/bindings/ImportMetaObject.cpp
+++ b/src/jsc/bindings/ImportMetaObject.cpp
@@ -270,10 +270,20 @@ extern "C" JSC::EncodedJSValue functionImportMeta__resolveSyncPrivate(JSC::JSGlo
             }
         }
 
+        // node resolves builtin ids before validating `paths`, so `require.resolve("node:fs",
+        // { paths: [0] })` must not throw. Only real builtins bypass; "node:nope" still validates.
+        // https://github.com/nodejs/node/blob/main/lib/internal/modules/cjs/loader.js
+        if (!userPathList.isUndefinedOrNull() && moduleName.isString()) {
+            auto builtinCheckStr = moduleName.toWTFString(globalObject);
+            RETURN_IF_EXCEPTION(scope, {});
+            if (Bun::isBuiltinModule(builtinCheckStr))
+                userPathList = jsUndefined();
+        }
+
         if (!userPathList.isUndefinedOrNull()) {
             if (JSArray* userPathListArray = dynamicDowncast<JSArray>(userPathList)) {
                 if (!moduleName.isString()) {
-                    Bun::ERR::INVALID_ARG_TYPE(scope, globalObject, "id"_s, "string"_s, moduleName);
+                    Bun::ERR::INVALID_ARG_TYPE(scope, globalObject, "request"_s, "string"_s, moduleName);
                     scope.release();
                     return {};
                 }
@@ -282,6 +292,12 @@ extern "C" JSC::EncodedJSValue functionImportMeta__resolveSyncPrivate(JSC::JSGlo
                 WTF::Vector<BunString> paths;
                 for (size_t i = 0; i < userPathListArray->length(); ++i) {
                     JSValue path = userPathListArray->getIndex(globalObject, i);
+                    if (scope.exception()) [[unlikely]]
+                        goto cleanup;
+                    if (!path.isString()) {
+                        Bun::ERR::INVALID_ARG_TYPE(scope, globalObject, makeString("paths["_s, i, "]"_s), "string"_s, path);
+                        goto cleanup;
+                    }
                     WTF::String pathStr = path.toWTFString(globalObject);
                     if (scope.exception()) [[unlikely]]
                         goto cleanup;
@@ -304,7 +320,7 @@ extern "C" JSC::EncodedJSValue functionImportMeta__resolveSyncPrivate(JSC::JSGlo
                 }
                 RELEASE_AND_RETURN(scope, result);
             } else {
-                Bun::ERR::INVALID_ARG_VALUE(scope, globalObject, "option.paths"_s, userPathList);
+                Bun::ERR::INVALID_ARG_VALUE(scope, globalObject, "options.paths"_s, userPathList);
                 scope.release();
                 return {};
             }
diff --git a/src/jsc/bindings/JSDOMExceptionHandling.cpp b/src/jsc/bindings/JSDOMExceptionHandling.cpp
index 12310f951bc6..9db6f0f283de 100644
--- a/src/jsc/bindings/JSDOMExceptionHandling.cpp
+++ b/src/jsc/bindings/JSDOMExceptionHandling.cpp
@@ -115,7 +115,7 @@ String retrieveErrorMessage(JSGlobalObject& lexicalGlobalObject, VM& vm, JSValue
     return errorMessage;
 }
 
-JSValue createDOMException(JSGlobalObject* lexicalGlobalObject, ExceptionCode ec, const String& message)
+JSValue createDOMException(JSGlobalObject* lexicalGlobalObject, ExceptionCode ec, const String& message, const String& extra)
 {
     auto& vm = JSC::getVM(lexicalGlobalObject);
     if (vm.hasPendingTerminationException()) [[unlikely]]
@@ -154,8 +154,20 @@ JSValue createDOMException(JSGlobalObject* lexicalGlobalObject, ExceptionCode ec
     case ExceptionCode::InvalidThisError:
         return Bun::createInvalidThisError(lexicalGlobalObject, message.isEmpty() ? "Expected this to be of a different type"_s : message);
 
-    case ExceptionCode::InvalidURLError:
-        return Bun::createError(lexicalGlobalObject, Bun::ErrorCode::ERR_INVALID_URL, message.isEmpty() ? "Invalid URL"_s : message);
+    case ExceptionCode::InvalidURLError: {
+        // Node's ERR_INVALID_URL: plain TypeError (`${err}` has no [code]
+        // suffix), message "Invalid URL" (nodejs/node#38614), the offending
+        // input on `error.input`, and — only when a base argument was passed —
+        // the raw base string on `error.base`. `extra` carries the base; a
+        // null String means the one-arg constructor was used.
+        auto& vm = JSC::getVM(lexicalGlobalObject);
+        auto* error = JSC::createTypeError(lexicalGlobalObject, "Invalid URL"_s);
+        error->putDirect(vm, JSC::Identifier::fromString(vm, "code"_s), JSC::jsString(vm, WTF::String("ERR_INVALID_URL"_s)), 0);
+        error->putDirect(vm, vm.propertyNames->input, JSC::jsString(vm, message));
+        if (!extra.isNull())
+            error->putDirect(vm, JSC::Identifier::fromString(vm, "base"_s), JSC::jsString(vm, extra));
+        return error;
+    }
 
     case ExceptionCode::CryptoOperationFailedError:
         return Bun::createError(lexicalGlobalObject, Bun::ErrorCode::ERR_CRYPTO_OPERATION_FAILED, message.isEmpty() ? "Crypto operation failed"_s : message);
@@ -181,7 +193,7 @@ JSValue createDOMException(JSGlobalObject* lexicalGlobalObject, ExceptionCode ec
 
 JSValue createDOMException(JSGlobalObject& lexicalGlobalObject, Exception&& exception)
 {
-    return createDOMException(&lexicalGlobalObject, exception.code(), exception.releaseMessage());
+    return createDOMException(&lexicalGlobalObject, exception.code(), exception.releaseMessage(), exception.releaseExtra());
 }
 
 void propagateExceptionSlowPath(JSC::JSGlobalObject& lexicalGlobalObject, JSC::ThrowScope& throwScope, Exception&& exception)
diff --git a/src/jsc/bindings/JSDOMExceptionHandling.h b/src/jsc/bindings/JSDOMExceptionHandling.h
index 2f9cf8bb1e77..c6c7bf156a3d 100644
--- a/src/jsc/bindings/JSDOMExceptionHandling.h
+++ b/src/jsc/bindings/JSDOMExceptionHandling.h
@@ -62,7 +62,7 @@ WEBCORE_EXPORT void reportException(JSC::JSGlobalObject*, JSC::JSValue exception
 WEBCORE_EXPORT void reportException(JSC::JSGlobalObject*, JSC::Exception*, CachedScript* = nullptr, bool = false, ExceptionDetails* = nullptr);
 
 JSC::JSValue createDOMException(JSC::JSGlobalObject&, Exception&&);
-JSC::JSValue createDOMException(JSC::JSGlobalObject*, ExceptionCode, const String& = emptyString());
+JSC::JSValue createDOMException(JSC::JSGlobalObject*, ExceptionCode, const String& = emptyString(), const String& extra = String());
 
 // Convert a DOM implementation exception into a JavaScript exception in the execution lexicalGlobalObject.
 WEBCORE_EXPORT void propagateExceptionSlowPath(JSC::JSGlobalObject&, JSC::ThrowScope&, Exception&&);
diff --git a/src/jsc/bindings/NodeURL.cpp b/src/jsc/bindings/NodeURL.cpp
index 09af0674a4e9..394c92f88414 100644
--- a/src/jsc/bindings/NodeURL.cpp
+++ b/src/jsc/bindings/NodeURL.cpp
@@ -1,74 +1,243 @@
 #include "NodeURL.h"
+#include "ErrorCode.h"
+#include "wtf/URL.h"
 #include "wtf/URLParser.h"
 #include <unicode/uidna.h>
 
 namespace Bun {
 
-JSC_DEFINE_HOST_FUNCTION(jsDomainToASCII, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
+// The UTS #46 instances Node used: CheckHyphens and VerifyDnsLength are
+// handled by filtering the corresponding errors after the fact.
+static UIDNA* toASCIIIDNA()
 {
-    auto& vm = JSC::getVM(globalObject);
-    auto scope = DECLARE_THROW_SCOPE(vm);
+    static UIDNA* instance = [] {
+        UErrorCode status = U_ZERO_ERROR;
+        UIDNA* idna = uidna_openUTS46(UIDNA_CHECK_BIDI | UIDNA_CHECK_CONTEXTJ | UIDNA_NONTRANSITIONAL_TO_ASCII, &status);
+        RELEASE_ASSERT(U_SUCCESS(status));
+        return idna;
+    }();
+    return instance;
+}
+
+static UIDNA* toUnicodeIDNA()
+{
+    static UIDNA* instance = [] {
+        UErrorCode status = U_ZERO_ERROR;
+        UIDNA* idna = uidna_openUTS46(UIDNA_NONTRANSITIONAL_TO_UNICODE, &status);
+        RELEASE_ASSERT(U_SUCCESS(status));
+        return idna;
+    }();
+    return instance;
+}
+
+enum class IDNAMode : uint8_t {
+    Default,
+    Lenient,
+};
+
+// Runs a uidna_nameTo* conversion with the U_BUFFER_OVERFLOW_ERROR retry
+// protocol; on completion `status`/`info` hold the final results.
+using UIDNAFunction = int32_t (*)(const UIDNA*, const char16_t*, int32_t, char16_t*, int32_t, UIDNAInfo*, UErrorCode*);
+
+static String runUIDNA(UIDNAFunction convert, const UIDNA* idna, const String& input, UErrorCode& status, UIDNAInfo& info)
+{
+    String domain = input;
+    if (domain.is8Bit())
+        domain.convertTo16Bit();
+    const auto span = domain.span16();
 
-    if (callFrame->argumentCount() < 1) {
-        throwTypeError(globalObject, scope, "domainToASCII needs 1 argument"_s);
+    Vector<char16_t, 256> buffer(256);
+    int32_t length = convert(idna, span.data(), span.size(), buffer.begin(), buffer.size(), &info, &status);
+    if (status == U_BUFFER_OVERFLOW_ERROR) {
+        status = U_ZERO_ERROR;
+        info = UIDNA_INFO_INITIALIZER;
+        buffer.grow(length);
+        length = convert(idna, span.data(), span.size(), buffer.begin(), buffer.size(), &info, &status);
+    }
+    if (U_FAILURE(status))
         return {};
+    return String(std::span { buffer.begin(), static_cast<size_t>(length) });
+}
+
+// Unicode 15.1/16.0 revised the UTS #46 IdnaMappingTable (U+180E/U+206A..U+206F→ignored,
+// U+1E9E→U+00DF, etc.). Node v26 uses ada::idna (Unicode 16) while WebKit's bundled ICU may be
+// older; apply the delta before IDNA so node:url matches node. WPT toascii.json pins this.
+bool containsUnicode16IDNADeltaSource(StringView view)
+{
+    if (view.is8Bit())
+        return false;
+    for (size_t i = 0; i < view.length(); i++) {
+        char16_t u = view[i];
+        // 0xD87E is the shared lead surrogate of the five CJK sources.
+        if (u == 0x04C0 || u == 0x180E || u == 0x1E9E || (u >= 0x206A && u <= 0x206F) || u == 0x2183 || u == 0xD87E)
+            return true;
     }
+    return false;
+}
 
-    auto arg0 = callFrame->argument(0);
-    if (arg0.isUndefined())
-        return JSC::JSValue::encode(jsUndefined());
-    if (arg0.isNull())
-        return JSC::JSValue::encode(jsNull());
-    if (!arg0.isString()) {
-        throwTypeError(globalObject, scope, "the \"domain\" argument must be a string"_s);
-        return {};
+String applyUnicode16IDNADelta(const String& input)
+{
+    StringView view { input };
+    if (!containsUnicode16IDNADeltaSource(view))
+        return input;
+
+    StringBuilder builder;
+    for (char32_t codePoint : view.codePoints()) {
+        switch (codePoint) {
+        case 0x180E:
+        case 0x206A:
+        case 0x206B:
+        case 0x206C:
+        case 0x206D:
+        case 0x206E:
+        case 0x206F:
+            break; // disallowed -> ignored
+        case 0x04C0:
+            builder.append(static_cast<char32_t>(0x04CF));
+            break;
+        case 0x1E9E:
+            builder.append(static_cast<char32_t>(0x00DF));
+            break;
+        case 0x2183:
+            builder.append(static_cast<char32_t>(0x2184));
+            break;
+        case 0x2F868:
+            builder.append(static_cast<char32_t>(0x36FC));
+            break;
+        case 0x2F874:
+            builder.append(static_cast<char32_t>(0x5F33));
+            break;
+        case 0x2F91F:
+            builder.append(static_cast<char32_t>(0x243AB));
+            break;
+        case 0x2F95F:
+            builder.append(static_cast<char32_t>(0x7AEE));
+            break;
+        case 0x2F9BF:
+            builder.append(static_cast<char32_t>(0x45D7));
+            break;
+        default:
+            builder.append(codePoint);
+            break;
+        }
     }
+    return builder.toString();
+}
 
-    auto domain = arg0.toWTFString(globalObject);
-    if (domain.isNull())
-        return JSC::JSValue::encode(jsUndefined());
-
-    // https://url.spec.whatwg.org/#forbidden-host-code-point
-    if (
-        domain.contains(0x0000) || // U+0000 NULL
-        domain.contains(0x0009) || // U+0009 TAB
-        domain.contains(0x000A) || // U+000A LF
-        domain.contains(0x000D) || // U+000D CR
-        domain.contains(0x0020) || // U+0020 SPACE
-        domain.contains(0x0023) || // U+0023 (#)
-        domain.contains(0x002F) || // U+002F (/)
-        domain.contains(0x003A) || // U+003A (:)
-        domain.contains(0x003C) || // U+003C (<)
-        domain.contains(0x003E) || // U+003E (>)
-        domain.contains(0x003F) || // U+003F (?)
-        domain.contains(0x0040) || // U+0040 (@)
-        domain.contains(0x005B) || // U+005B ([)
-        domain.contains(0x005C) || // U+005C (\)
-        domain.contains(0x005D) || // U+005D (])
-        domain.contains(0x005E) || // U+005E (^)
-        domain.contains(0x007C) // // U+007C (|).
-    )
-        return JSC::JSValue::encode(jsEmptyString(vm));
+// Port of Node's icu-based ToASCII (removed in nodejs/node#55156):
+// https://github.com/nodejs/node/blob/9f5000e0f2a2^/src/node_i18n.cc — filter
+// the CheckHyphens/VerifyDnsLength error classes, fail otherwise unless lenient.
+static String icuToASCII(const String& rawInput, IDNAMode mode)
+{
+    auto input = applyUnicode16IDNADelta(rawInput);
+    // Fast path: an all-ASCII domain with no punycode labels only needs
+    // lowercasing (hyphen and label-length errors are filtered anyway).
+    if (input.containsOnlyASCII()) {
+        auto lowered = input.convertToASCIILowercase();
+        if (!lowered.contains("xn--"_s))
+            return lowered;
+    }
 
-    if (domain.containsOnlyASCII())
-        return JSC::JSValue::encode(arg0);
-    if (domain.is8Bit())
-        domain.convertTo16Bit();
+    UErrorCode status = U_ZERO_ERROR;
+    UIDNAInfo info = UIDNA_INFO_INITIALIZER;
+    auto result = runUIDNA(uidna_nameToASCII, toASCIIIDNA(), input, status, info);
 
-    constexpr static int allowedNameToASCIIErrors = UIDNA_ERROR_EMPTY_LABEL | UIDNA_ERROR_LABEL_TOO_LONG | UIDNA_ERROR_DOMAIN_NAME_TOO_LONG | UIDNA_ERROR_LEADING_HYPHEN | UIDNA_ERROR_TRAILING_HYPHEN | UIDNA_ERROR_HYPHEN_3_4;
-    constexpr static size_t hostnameBufferLength = 2048;
+    // CheckHyphens = false
+    info.errors &= ~UIDNA_ERROR_HYPHEN_3_4;
+    info.errors &= ~UIDNA_ERROR_LEADING_HYPHEN;
+    info.errors &= ~UIDNA_ERROR_TRAILING_HYPHEN;
+    // VerifyDnsLength = false
+    info.errors &= ~UIDNA_ERROR_EMPTY_LABEL;
+    info.errors &= ~UIDNA_ERROR_LABEL_TOO_LONG;
+    info.errors &= ~UIDNA_ERROR_DOMAIN_NAME_TOO_LONG;
 
-    auto encoder = &WTF::URLParser::internationalDomainNameTranscoder();
-    char16_t hostnameBuffer[hostnameBufferLength];
-    UErrorCode error = U_ZERO_ERROR;
-    UIDNAInfo processingDetails = UIDNA_INFO_INITIALIZER;
-    const auto span = domain.span16();
-    int32_t numCharactersConverted = uidna_nameToASCII(encoder, span.data(), span.size(), hostnameBuffer, hostnameBufferLength, &processingDetails, &error);
+    if (result.isNull() || (mode != IDNAMode::Lenient && info.errors != 0))
+        return {};
+    return result;
+}
+
+// Port of Node's icu-based ToUnicode (removed in nodejs/node#55156): UTS #46
+// ToUnicode always produces output, so info.errors is deliberately ignored.
+static String icuToUnicode(const String& rawInput)
+{
+    auto input = applyUnicode16IDNADelta(rawInput);
+    UErrorCode status = U_ZERO_ERROR;
+    UIDNAInfo info = UIDNA_INFO_INITIALIZER;
+    return runUIDNA(uidna_nameToUnicode, toUnicodeIDNA(), input, status, info);
+}
 
-    if (U_SUCCESS(error) && !(processingDetails.errors & ~allowedNameToASCIIErrors) && numCharactersConverted) {
-        return JSC::JSValue::encode(JSC::jsString(vm, WTF::String(std::span { hostnameBuffer, static_cast<unsigned int>(numCharactersConverted) })));
+// WebKit's host parser fast-paths all-ASCII hosts without decoding xn--
+// labels; ada (Node) decodes and validates them. Used to reject hosts whose
+// punycode labels fail UTS #46.
+bool hasValidPunycodeHost(WTF::StringView host)
+{
+    if (!host.contains("xn--"_s))
+        return true;
+    return !icuToASCII(host.toString(), IDNAMode::Default).isNull();
+}
+
+// Mirrors Node's url.domainToASCII/domainToUnicode, which run the input
+// through a WHATWG URL host parse (ada's url.set_hostname on a "ws://x"
+// base). Returns a null String when host parsing fails.
+static String parseDomainAsHost(const String& rawDomain)
+{
+    // WebKit's URLParser shares the bundled ICU, so the same delta is
+    // needed before the host parse (see applyUnicode16IDNADelta).
+    String domain = applyUnicode16IDNADelta(rawDomain);
+    // The hostname setter's basic-URL parse stops at the first path, query,
+    // fragment, or backslash (special scheme) terminator.
+    StringView view { domain };
+    size_t end = view.length();
+    for (size_t i = 0; i < view.length(); i++) {
+        char16_t c = view[i];
+        if (c == '/' || c == '?' || c == '#' || c == '\\') {
+            end = i;
+            break;
+        }
+    }
+    String host = domain.left(end);
+    if (host.isEmpty())
+        return {};
+
+    if (host.startsWith('[')) {
+        // A bracketed host must be nothing but the IPv6 literal; anything
+        // after ']' (including a port) fails the hostname setter.
+        if (!host.endsWith(']'))
+            return {};
+    } else {
+        // Outside brackets, ':' (hostname setters reject ports) and '@'
+        // (would otherwise parse as userinfo) fail host parsing.
+        if (host.contains(':') || host.contains('@'))
+            return {};
     }
-    return JSC::JSValue::encode(jsEmptyString(vm));
+
+    WTF::URL url(makeString("ws://"_s, host, "/"_s));
+    if (!url.isValid())
+        return {};
+
+    String parsedHost = url.host().toString();
+    if (!hasValidPunycodeHost(parsedHost))
+        return {};
+    return parsedHost;
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsDomainToASCII, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
+{
+    auto& vm = JSC::getVM(globalObject);
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    if (callFrame->argumentCount() < 1)
+        return Bun::ERR::MISSING_ARGS(scope, globalObject, "The \"domain\" argument must be specified"_s);
+
+    // Node stringifies the argument (`${domain}`), so undefined parses as
+    // the domain "undefined".
+    auto domain = callFrame->argument(0).toWTFString(globalObject);
+    RETURN_IF_EXCEPTION(scope, {});
+
+    auto host = parseDomainAsHost(domain);
+    if (host.isNull())
+        return JSC::JSValue::encode(jsEmptyString(vm));
+    return JSC::JSValue::encode(JSC::jsString(vm, host));
 }
 
 JSC_DEFINE_HOST_FUNCTION(jsDomainToUnicode, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
@@ -76,82 +245,89 @@ JSC_DEFINE_HOST_FUNCTION(jsDomainToUnicode, (JSC::JSGlobalObject * globalObject,
     auto& vm = JSC::getVM(globalObject);
     auto scope = DECLARE_THROW_SCOPE(vm);
 
-    if (callFrame->argumentCount() < 1) {
-        throwTypeError(globalObject, scope, "domainToUnicode needs 1 argument"_s);
-        return {};
-    }
+    if (callFrame->argumentCount() < 1)
+        return Bun::ERR::MISSING_ARGS(scope, globalObject, "The \"domain\" argument must be specified"_s);
 
-    auto arg0 = callFrame->argument(0);
-    if (arg0.isUndefined())
-        return JSC::JSValue::encode(jsUndefined());
-    if (arg0.isNull())
-        return JSC::JSValue::encode(jsNull());
-    if (!arg0.isString()) {
-        throwTypeError(globalObject, scope, "the \"domain\" argument must be a string"_s);
-        return {};
-    }
+    auto domain = callFrame->argument(0).toWTFString(globalObject);
+    RETURN_IF_EXCEPTION(scope, {});
 
-    auto domain = arg0.toWTFString(globalObject);
-    if (domain.isNull())
-        return JSC::JSValue::encode(jsUndefined());
-
-    // https://url.spec.whatwg.org/#forbidden-host-code-point
-    if (
-        domain.contains(0x0000) || // U+0000 NULL
-        domain.contains(0x0009) || // U+0009 TAB
-        domain.contains(0x000A) || // U+000A LF
-        domain.contains(0x000D) || // U+000D CR
-        domain.contains(0x0020) || // U+0020 SPACE
-        domain.contains(0x0023) || // U+0023 (#)
-        domain.contains(0x002F) || // U+002F (/)
-        domain.contains(0x003A) || // U+003A (:)
-        domain.contains(0x003C) || // U+003C (<)
-        domain.contains(0x003E) || // U+003E (>)
-        domain.contains(0x003F) || // U+003F (?)
-        domain.contains(0x0040) || // U+0040 (@)
-        domain.contains(0x005B) || // U+005B ([)
-        domain.contains(0x005C) || // U+005C (\)
-        domain.contains(0x005D) || // U+005D (])
-        domain.contains(0x005E) || // U+005E (^)
-        domain.contains(0x007C) // // U+007C (|).
-    )
+    // Node: validate through the host parse first, then run ToUnicode on the
+    // resulting ASCII host.
+    auto host = parseDomainAsHost(domain);
+    if (host.isNull())
         return JSC::JSValue::encode(jsEmptyString(vm));
 
-    if (!domain.is8Bit())
-        // this function is only for undoing punycode so its okay if utf-16 text makes it out unchanged.
-        return JSC::JSValue::encode(arg0);
+    auto unicode = icuToUnicode(host);
+    if (unicode.isNull())
+        return JSC::JSValue::encode(jsEmptyString(vm));
+    return JSC::JSValue::encode(JSC::jsString(vm, unicode));
+}
 
-    domain.convertTo16Bit();
+// Standalone UTS #46 domain-to-ascii (Node's encoding_binding toASCII, i.e.
+// ada::idna::to_ascii): returns "" on failure. url.parse's IDNA step — unlike
+// domainToASCII, no host parsing (no IPv4 canonicalization, ':' allowed, ...).
+JSC_DEFINE_HOST_FUNCTION(jsIDNAToASCII, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
+{
+    auto& vm = JSC::getVM(globalObject);
+    auto scope = DECLARE_THROW_SCOPE(vm);
 
-    constexpr static int allowedNameToUnicodeErrors = UIDNA_ERROR_EMPTY_LABEL | UIDNA_ERROR_LABEL_TOO_LONG | UIDNA_ERROR_DOMAIN_NAME_TOO_LONG | UIDNA_ERROR_LEADING_HYPHEN | UIDNA_ERROR_TRAILING_HYPHEN | UIDNA_ERROR_HYPHEN_3_4;
-    constexpr static int hostnameBufferLength = 2048;
+    auto input = callFrame->argument(0).toWTFString(globalObject);
+    RETURN_IF_EXCEPTION(scope, {});
 
-    auto encoder = &WTF::URLParser::internationalDomainNameTranscoder();
-    char16_t hostnameBuffer[hostnameBufferLength];
-    UErrorCode error = U_ZERO_ERROR;
-    UIDNAInfo processingDetails = UIDNA_INFO_INITIALIZER;
+    auto result = icuToASCII(input, IDNAMode::Default);
+    if (result.isNull())
+        return JSC::JSValue::encode(jsEmptyString(vm));
+    return JSC::JSValue::encode(JSC::jsString(vm, result));
+}
 
-    const auto span = domain.span16();
+// internalBinding('icu') shims for the vendored node test suite; the JS shim
+// (internal/test/binding) adds hasConverter on top of this object.
+JSC_DEFINE_HOST_FUNCTION(jsIcuToASCII, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
+{
+    auto& vm = JSC::getVM(globalObject);
+    auto scope = DECLARE_THROW_SCOPE(vm);
 
-    int32_t numCharactersConverted = uidna_nameToUnicode(encoder, span.data(), span.size(), hostnameBuffer, hostnameBufferLength, &processingDetails, &error);
+    auto input = callFrame->argument(0).toWTFString(globalObject);
+    RETURN_IF_EXCEPTION(scope, {});
+    bool lenient = callFrame->argument(1).toBoolean(globalObject);
 
-    if (U_SUCCESS(error) && !(processingDetails.errors & ~allowedNameToUnicodeErrors) && numCharactersConverted) {
-        return JSC::JSValue::encode(JSC::jsString(vm, WTF::String(std::span { hostnameBuffer, static_cast<unsigned int>(numCharactersConverted) })));
+    auto result = icuToASCII(input, lenient ? IDNAMode::Lenient : IDNAMode::Default);
+    if (result.isNull()) {
+        throwException(globalObject, scope, createError(globalObject, ErrorCode::ERR_INVALID_ARG_VALUE, "Cannot convert name to ASCII"_s));
+        return {};
     }
-    return JSC::JSValue::encode(jsEmptyString(vm));
+    return JSC::JSValue::encode(JSC::jsString(vm, result));
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsIcuToUnicode, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
+{
+    auto& vm = JSC::getVM(globalObject);
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    auto input = callFrame->argument(0).toWTFString(globalObject);
+    RETURN_IF_EXCEPTION(scope, {});
+
+    auto result = icuToUnicode(input);
+    if (result.isNull()) {
+        throwException(globalObject, scope, createError(globalObject, ErrorCode::ERR_INVALID_ARG_VALUE, "Cannot convert name to Unicode"_s));
+        return {};
+    }
+    return JSC::JSValue::encode(JSC::jsString(vm, result));
 }
 
 JSC::JSValue createNodeURLBinding(Zig::GlobalObject* globalObject)
 {
     VM& vm = globalObject->vm();
     auto scope = DECLARE_THROW_SCOPE(vm);
-    auto binding = constructEmptyArray(globalObject, nullptr, 2);
+    auto binding = constructEmptyArray(globalObject, nullptr, 3);
     RETURN_IF_EXCEPTION(scope, {});
     ASSERT(binding);
     auto domainToAsciiFunction = JSC::JSFunction::create(vm, globalObject, 1, "domainToAscii"_s, jsDomainToASCII, ImplementationVisibility::Public);
     ASSERT(domainToAsciiFunction);
     auto domainToUnicodeFunction = JSC::JSFunction::create(vm, globalObject, 1, "domainToUnicode"_s, jsDomainToUnicode, ImplementationVisibility::Public);
     ASSERT(domainToUnicodeFunction);
+    auto idnaToASCIIFunction = JSC::JSFunction::create(vm, globalObject, 1, "idnaToASCII"_s, jsIDNAToASCII, ImplementationVisibility::Public);
+    ASSERT(idnaToASCIIFunction);
     binding->putByIndexInline(
         globalObject,
         (unsigned)0,
@@ -162,6 +338,22 @@ JSC::JSValue createNodeURLBinding(Zig::GlobalObject* globalObject)
         (unsigned)1,
         domainToUnicodeFunction,
         false);
+    binding->putByIndexInline(
+        globalObject,
+        (unsigned)2,
+        idnaToASCIIFunction,
+        false);
+    return binding;
+}
+
+JSC::JSValue createNodeICUBinding(Zig::GlobalObject* globalObject)
+{
+    VM& vm = globalObject->vm();
+    auto* binding = JSC::constructEmptyObject(globalObject);
+    binding->putDirect(vm, JSC::Identifier::fromString(vm, "toASCII"_s),
+        JSC::JSFunction::create(vm, globalObject, 2, "toASCII"_s, jsIcuToASCII, ImplementationVisibility::Public), 0);
+    binding->putDirect(vm, JSC::Identifier::fromString(vm, "toUnicode"_s),
+        JSC::JSFunction::create(vm, globalObject, 1, "toUnicode"_s, jsIcuToUnicode, ImplementationVisibility::Public), 0);
     return binding;
 }
 
diff --git a/src/jsc/bindings/NodeURL.h b/src/jsc/bindings/NodeURL.h
index 3252194123c9..bd73d7cd9278 100644
--- a/src/jsc/bindings/NodeURL.h
+++ b/src/jsc/bindings/NodeURL.h
@@ -1,8 +1,10 @@
 #include "config.h"
+#include "NodeURLHelpers.h"
 #include "ZigGlobalObject.h"
 
 namespace Bun {
 
 JSC::JSValue createNodeURLBinding(Zig::GlobalObject*);
+JSC::JSValue createNodeICUBinding(Zig::GlobalObject*);
 
 } // namespace Bun
diff --git a/src/jsc/bindings/NodeURLHelpers.h b/src/jsc/bindings/NodeURLHelpers.h
new file mode 100644
index 000000000000..b05875c9449b
--- /dev/null
+++ b/src/jsc/bindings/NodeURLHelpers.h
@@ -0,0 +1,23 @@
+#pragma once
+
+// IDNA/punycode helpers implemented in NodeURL.cpp, declared separately so
+// WebCore-layer consumers (URLDecomposition.cpp, DOMURL.cpp) do not pull in
+// ZigGlobalObject.h via NodeURL.h.
+
+#include <wtf/Forward.h>
+
+namespace Bun {
+
+// True when every xn-- label in `host` is valid UTS #46 punycode.
+bool hasValidPunycodeHost(WTF::StringView host);
+
+// True when `view` contains a source code unit of the Unicode 15.1/16.0
+// IdnaMappingTable delta (see applyUnicode16IDNADelta in NodeURL.cpp).
+bool containsUnicode16IDNADeltaSource(WTF::StringView view);
+
+// Applies the Unicode 15.1/16.0 IdnaMappingTable delta so IDNA results match
+// node v26 (ada::idna) regardless of the platform ICU data version. Returns
+// the input unchanged when no delta source is present.
+WTF::String applyUnicode16IDNADelta(const WTF::String& input);
+
+} // namespace Bun
diff --git a/src/jsc/bindings/ProcessBindingUV.cpp b/src/jsc/bindings/ProcessBindingUV.cpp
index 3b750a8fe5f7..7488ef2b19ef 100644
--- a/src/jsc/bindings/ProcessBindingUV.cpp
+++ b/src/jsc/bindings/ProcessBindingUV.cpp
@@ -1,4 +1,5 @@
 #include "ProcessBindingUV.h"
+#include "BunProcess.h"
 #include "JavaScriptCore/ArrayAllocationProfile.h"
 #include "JavaScriptCore/JSCJSValue.h"
 #include "JavaScriptCore/ThrowScope.h"
@@ -101,15 +102,34 @@
   macro(EILSEQ, "illegal byte sequence") \
   macro(ESOCKTNOSUPPORT, "socket type not supported") \
   macro(ENODATA, "no data available") \
-  macro(EUNATCH, "protocol driver not attached")
+  macro(EUNATCH, "protocol driver not attached") \
+  macro(ENOEXEC, "exec format error")
 
 // clang-format on
+extern "C" bool Bun__Node__ProcessPendingDeprecation;
+
 namespace Bun {
 namespace ProcessBindingUV {
 
 JSC_DEFINE_HOST_FUNCTION(jsErrname, (JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
 {
     auto& vm = JSC::getVM(globalObject);
+
+    if (Bun__Node__ProcessPendingDeprecation) {
+        // Node latches DEP0119 per Environment (each worker warns once).
+        auto* process = defaultGlobalObject(globalObject)->processObject();
+        if (!process->m_warnedErrname) {
+            process->m_warnedErrname = true;
+            auto scope = DECLARE_THROW_SCOPE(vm);
+            Process::emitWarning(globalObject,
+                JSC::jsString(vm, WTF::String("Directly calling process.binding('uv').errname(<val>) is being deprecated. Please make sure to use util.getSystemErrorName() instead."_s)),
+                JSC::jsString(vm, WTF::String("DeprecationWarning"_s)),
+                JSC::jsString(vm, WTF::String("DEP0119"_s)),
+                JSC::jsUndefined());
+            RETURN_IF_EXCEPTION(scope, {});
+        }
+    }
+
     auto arg0 = callFrame->argument(0);
 
     // Node.js crashes here:
@@ -126,7 +146,8 @@ JSC_DEFINE_HOST_FUNCTION(jsErrname, (JSGlobalObject * globalObject, JSC::CallFra
     BUN_UV_ERRNO_MAP(CASE)
 #undef CASE
 
-    return JSValue::encode(jsString(vm, makeString("Unknown system error: "_s, err)));
+    // node: `Unknown system error ${err}` (no colon), matching util.getSystemErrorName.
+    return JSValue::encode(jsString(vm, makeString("Unknown system error "_s, err)));
 }
 
 JSC_DEFINE_HOST_FUNCTION(jsGetErrorMap, (JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
@@ -152,7 +173,10 @@ JSC_DEFINE_HOST_FUNCTION(jsGetErrorMap, (JSGlobalObject * globalObject, JSC::Cal
 
 JSObject* create(VM& vm, JSGlobalObject* globalObject)
 {
-    auto bindingObject = JSC::constructEmptyObject(globalObject, globalObject->objectPrototype(), 0);
+    // Non-zero inline capacity: a zero-capacity object trips the
+    // hasInlineStorage() assertion in JSObject::inlineStorage when JS
+    // spreads it ({...process.binding("uv")} in internal/test/binding.ts).
+    auto bindingObject = JSC::constructEmptyObject(globalObject);
     EnsureStillAliveScope ensureStillAlive(bindingObject);
     bindingObject->putDirect(vm, JSC::Identifier::fromString(vm, "errname"_s), JSC::JSFunction::create(vm, globalObject, 1, "errname"_s, jsErrname, ImplementationVisibility::Public));
 
diff --git a/src/jsc/bindings/URLDecomposition.cpp b/src/jsc/bindings/URLDecomposition.cpp
index 200530bb9eee..a0806ad44acf 100644
--- a/src/jsc/bindings/URLDecomposition.cpp
+++ b/src/jsc/bindings/URLDecomposition.cpp
@@ -25,10 +25,19 @@
 
 #include "URLDecomposition.h"
 
+#include "NodeURLHelpers.h"
 #include <wtf/text/StringToIntegerConversion.h>
 
 namespace WebCore {
 
+// Like the URL constructor (DOMURL.cpp), reject special-scheme hosts whose
+// xn-- labels fail UTS #46; the WHATWG setters fail silently, so refuse the
+// commit instead of throwing.
+static bool hasAcceptableHost(const WTF::URL& url)
+{
+    return Bun::hasValidPunycodeHost(url.host()) || !url.hasSpecialScheme();
+}
+
 String URLDecomposition::origin() const
 {
     auto fullURL = this->fullURL();
@@ -107,6 +116,19 @@ static unsigned countASCIIDigits(StringView string)
 void URLDecomposition::setHost(StringView value)
 {
     auto fullURL = this->fullURL();
+    // Apply the Unicode 16 IDNA delta to the host span only (see DOMURL.cpp). The port span must
+    // stay verbatim (the delta strips ignored-class chars, which could validate a bad port).
+    // Non-special schemes and '['-prefixed (IPv6) hosts never run IDNA.
+    String mappedValue;
+    if (fullURL.hasSpecialScheme() && !value.startsWith('[')) {
+        size_t hostEnd = value.reverseFind(':');
+        auto hostSpan = hostEnd == notFound ? value : value.left(hostEnd);
+        if (Bun::containsUnicode16IDNADeltaSource(hostSpan)) {
+            auto mappedHost = Bun::applyUnicode16IDNADelta(hostSpan.toString());
+            mappedValue = hostEnd == notFound ? mappedHost : makeString(mappedHost, value.substring(hostEnd));
+            value = mappedValue;
+        }
+    }
     if (value.isEmpty() && !fullURL.protocolIsFile() && fullURL.hasSpecialScheme())
         return;
 
@@ -136,7 +158,7 @@ void URLDecomposition::setHost(StringView value)
                 fullURL.setHostAndPort(value.left(separator + 1 + portLength));
         }
     }
-    if (fullURL.isValid())
+    if (fullURL.isValid() && hasAcceptableHost(fullURL))
         setFullURL(fullURL);
 }
 
@@ -148,12 +170,19 @@ String URLDecomposition::hostname() const
 void URLDecomposition::setHostname(StringView host)
 {
     auto fullURL = this->fullURL();
+    // See setHost: the input is a hostname by definition, and only special
+    // schemes run IDNA on it.
+    String mappedHost;
+    if (fullURL.hasSpecialScheme() && !host.startsWith('[') && Bun::containsUnicode16IDNADeltaSource(host)) {
+        mappedHost = Bun::applyUnicode16IDNADelta(host.toString());
+        host = mappedHost;
+    }
     if (host.isEmpty() && !fullURL.protocolIsFile() && fullURL.hasSpecialScheme())
         return;
     if (fullURL.hasOpaquePath())
         return;
     fullURL.setHost(host);
-    if (fullURL.isValid())
+    if (fullURL.isValid() && hasAcceptableHost(fullURL))
         setFullURL(fullURL);
 }
 
diff --git a/src/jsc/bindings/ZigGlobalObject.cpp b/src/jsc/bindings/ZigGlobalObject.cpp
index 978bc3e6f889..04724225b631 100644
--- a/src/jsc/bindings/ZigGlobalObject.cpp
+++ b/src/jsc/bindings/ZigGlobalObject.cpp
@@ -2654,6 +2654,14 @@ void GlobalObject::finishCreation(VM& vm)
         init.set(JSC::JSFunction::create(init.vm, init.owner, WebCore::ipcSerializeCodeGenerator(init.vm), init.owner));
     });
 
+    m_ipcTagAdvancedBuffersFunction.initLater([](const LazyProperty<JSC::JSGlobalObject, JSC::JSFunction>::Initializer& init) {
+        init.set(JSC::JSFunction::create(init.vm, init.owner, WebCore::ipcTagAdvancedBuffersCodeGenerator(init.vm), init.owner));
+    });
+
+    m_ipcRestoreAdvancedBuffersFunction.initLater([](const LazyProperty<JSC::JSGlobalObject, JSC::JSFunction>::Initializer& init) {
+        init.set(JSC::JSFunction::create(init.vm, init.owner, WebCore::ipcRestoreAdvancedBuffersCodeGenerator(init.vm), init.owner));
+    });
+
     m_JSFileSinkClassStructure.initLater(
         [](LazyClassStructure::Initializer& init) {
             auto* prototype = createJSSinkPrototype(init.vm, init.global, WebCore::SinkID::FileSink);
diff --git a/src/jsc/bindings/ZigGlobalObject.h b/src/jsc/bindings/ZigGlobalObject.h
index 2eb37bf6be0e..abf6e834a36f 100644
--- a/src/jsc/bindings/ZigGlobalObject.h
+++ b/src/jsc/bindings/ZigGlobalObject.h
@@ -700,7 +700,9 @@ class GlobalObject : public Bun::GlobalScope {
     V(public, LazyPropertyOfGlobalObject<Symbol>, m_nodeVMDontContextify)                                    \
     V(public, LazyPropertyOfGlobalObject<Symbol>, m_nodeVMUseMainContextDefaultLoader)                       \
     V(public, LazyPropertyOfGlobalObject<JSFunction>, m_ipcSerializeFunction)                                \
-    V(public, LazyPropertyOfGlobalObject<JSFunction>, m_ipcParseHandleFunction)
+    V(public, LazyPropertyOfGlobalObject<JSFunction>, m_ipcParseHandleFunction)                              \
+    V(public, LazyPropertyOfGlobalObject<JSFunction>, m_ipcTagAdvancedBuffersFunction)                       \
+    V(public, LazyPropertyOfGlobalObject<JSFunction>, m_ipcRestoreAdvancedBuffersFunction)
 
 #define DECLARE_GLOBALOBJECT_GC_MEMBER(visibility, T, name) \
     visibility:                                             \
diff --git a/src/jsc/bindings/bindings.cpp b/src/jsc/bindings/bindings.cpp
index 48e9cad873ec..09db8d5438a2 100644
--- a/src/jsc/bindings/bindings.cpp
+++ b/src/jsc/bindings/bindings.cpp
@@ -47,6 +47,7 @@
 #include "JavaScriptCore/IteratorOperations.h"
 #include "JavaScriptCore/JSArray.h"
 #include "JavaScriptCore/JSArrayBuffer.h"
+#include "JavaScriptCore/JSDataView.h"
 #include "JavaScriptCore/JSArrayInlines.h"
 #include "JavaScriptCore/JSGlobalObjectInlines.h"
 #include "JavaScriptCore/JSFunction.h"
@@ -508,7 +509,7 @@ AsymmetricMatcherResult matchAsymmetricMatcherAndGetFlags(JSGlobalObject* global
                     JSValue otherValue = otherArray->getIndex(globalObject, n);
                     Vector<std::pair<JSValue, JSValue>, 16> stack;
                     MarkedArgumentBuffer gcBuffer;
-                    bool foundNow = Bun__deepEquals<false, true>(globalObject, expectedValue, otherValue, gcBuffer, stack, throwScope, true);
+                    bool foundNow = Bun__deepEquals<false, true, false>(globalObject, expectedValue, otherValue, gcBuffer, stack, throwScope, true);
                     RETURN_IF_EXCEPTION(throwScope, AsymmetricMatcherResult::FAIL);
                     if (foundNow) {
                         found = true;
@@ -661,9 +662,19 @@ JSValue getIndexWithoutAccessors(JSGlobalObject* globalObject, JSObject* obj, ui
     return JSValue();
 }
 
-template<bool isStrict, bool enableAsymmetricMatchers, bool skipPrototype>
+template<bool isStrict, bool enableAsymmetricMatchers, bool checkPrototypes, bool skipPrototypeIdentity = false>
 std::optional<bool> specialObjectsDequal(JSC::JSGlobalObject* globalObject, MarkedArgumentBuffer& gcBuffer, Vector<std::pair<JSC::JSValue, JSC::JSValue>, 16>& stack, ThrowScope& scope, JSCell* _Nonnull c1, JSCell* _Nonnull c2);
 
+template<typename T>
+static bool looseFloatContentsEqual(std::span<const T> a, std::span<const T> b)
+{
+    for (size_t i = 0; i < a.size(); i++) {
+        if (a[i] != b[i])
+            return false;
+    }
+    return true;
+}
+
 // Typed array elements and boxed string characters are synthesized by
 // getOwnPropertySlot instead of being stored in the structure, so a structure with
 // no named properties means nothing is left to compare once the contents match.
@@ -676,7 +687,54 @@ static ALWAYS_INLINE bool hasExtraOwnProperties(JSC::Structure* structure)
         || hasIndexedProperties(structure->indexingType());
 }
 
-template<bool isStrict, bool enableAsymmetricMatchers, bool skipPrototype>
+// node compares the non-index own properties of typed arrays as well;
+// only the node entry point (checkPrototypes) pays for this.
+template<bool isStrict, bool enableAsymmetricMatchers, bool checkPrototypes, bool skipPrototypeIdentity = false>
+static bool nonIndexOwnPropertiesEqual(JSC::JSGlobalObject* globalObject, MarkedArgumentBuffer& gcBuffer, Vector<std::pair<JSC::JSValue, JSC::JSValue>, 16>& stack, ThrowScope& scope, JSC::JSObject* o1, JSC::JSObject* o2)
+{
+    VM& vm = globalObject->vm();
+    JSC::PropertyNameArrayBuilder a1(vm, PropertyNameMode::StringsAndSymbols, PrivateSymbolMode::Exclude);
+    JSC::PropertyNameArrayBuilder a2(vm, PropertyNameMode::StringsAndSymbols, PrivateSymbolMode::Exclude);
+    o1->getOwnNonIndexPropertyNames(globalObject, a1, DontEnumPropertiesMode::Exclude);
+    RETURN_IF_EXCEPTION(scope, false);
+    o2->getOwnNonIndexPropertyNames(globalObject, a2, DontEnumPropertiesMode::Exclude);
+    RETURN_IF_EXCEPTION(scope, false);
+
+    if (a1.size() != a2.size()) {
+        return false;
+    }
+    // Own-property-scoped reads: a plain get() would walk the prototype chain and let an inherited
+    // key satisfy an own one. GetOwnProperty enforces name-for-name ownership in one lookup;
+    // DontEnum is rejected since the name lists exclude non-enumerable properties.
+    for (size_t i = 0; i < a1.size(); i++) {
+        JSC::PropertyName propertyName(a1[i]);
+        PropertySlot slot2(o2, PropertySlot::InternalMethodType::GetOwnProperty);
+        bool o2Owns = o2->methodTable()->getOwnPropertySlot(o2, globalObject, propertyName, slot2);
+        RETURN_IF_EXCEPTION(scope, false);
+        if (!o2Owns || (slot2.attributes() & PropertyAttribute::DontEnum)) {
+            return false;
+        }
+        JSValue v2 = slot2.getValue(globalObject, propertyName);
+        RETURN_IF_EXCEPTION(scope, false);
+        PropertySlot slot1(o1, PropertySlot::InternalMethodType::GetOwnProperty);
+        bool o1Owns = o1->methodTable()->getOwnPropertySlot(o1, globalObject, propertyName, slot1);
+        RETURN_IF_EXCEPTION(scope, false);
+        if (!o1Owns || (slot1.attributes() & PropertyAttribute::DontEnum)) {
+            // A getter above removed or redefined the property mid-iteration.
+            return false;
+        }
+        JSValue v1 = slot1.getValue(globalObject, propertyName);
+        RETURN_IF_EXCEPTION(scope, false);
+        bool eq = Bun__deepEquals<isStrict, enableAsymmetricMatchers, checkPrototypes, skipPrototypeIdentity>(globalObject, v1, v2, gcBuffer, stack, scope, true);
+        RETURN_IF_EXCEPTION(scope, false);
+        if (!eq) {
+            return false;
+        }
+    }
+    return true;
+}
+
+template<bool isStrict, bool enableAsymmetricMatchers, bool checkPrototypes, bool skipPrototypeIdentity>
 bool Bun__deepEquals(JSC::JSGlobalObject* globalObject, JSValue v1, JSValue v2, MarkedArgumentBuffer& gcBuffer, Vector<std::pair<JSC::JSValue, JSC::JSValue>, 16>& stack, ThrowScope& scope, bool addToStack)
 {
     VM& vm = globalObject->vm();
@@ -755,10 +813,28 @@ bool Bun__deepEquals(JSC::JSGlobalObject* globalObject, JSValue v1, JSValue v2,
     JSCell* c2 = v2.asCell();
     ASSERT(c1);
     ASSERT(c2);
-    std::optional<bool> isSpecialEqual = specialObjectsDequal<isStrict, enableAsymmetricMatchers, skipPrototype>(globalObject, gcBuffer, stack, scope, c1, c2);
+
+    // Node's deepStrictEqual compares [[Prototype]]s with ===. Only the
+    // node:assert/node:util entry point does this; Bun.deepEquals and
+    // expect() keep their prototype-blind semantics.
+    if constexpr (checkPrototypes && !skipPrototypeIdentity) {
+        JSObject* protoCheck1 = v1.getObject();
+        JSObject* protoCheck2 = v2.getObject();
+        if (protoCheck1 && protoCheck2) {
+            JSValue proto1 = protoCheck1->getPrototype(globalObject);
+            RETURN_IF_EXCEPTION(scope, false);
+            JSValue proto2 = protoCheck2->getPrototype(globalObject);
+            RETURN_IF_EXCEPTION(scope, false);
+            if (proto1 != proto2) {
+                return false;
+            }
+        }
+    }
+
+    std::optional<bool> isSpecialEqual = specialObjectsDequal<isStrict, enableAsymmetricMatchers, checkPrototypes, skipPrototypeIdentity>(globalObject, gcBuffer, stack, scope, c1, c2);
     RETURN_IF_EXCEPTION(scope, false);
     if (isSpecialEqual.has_value()) return WTF::move(*isSpecialEqual);
-    isSpecialEqual = specialObjectsDequal<isStrict, enableAsymmetricMatchers, skipPrototype>(globalObject, gcBuffer, stack, scope, c2, c1);
+    isSpecialEqual = specialObjectsDequal<isStrict, enableAsymmetricMatchers, checkPrototypes, skipPrototypeIdentity>(globalObject, gcBuffer, stack, scope, c2, c1);
     RETURN_IF_EXCEPTION(scope, false);
     if (isSpecialEqual.has_value()) return WTF::move(*isSpecialEqual);
     JSObject* o1 = v1.getObject();
@@ -806,7 +882,7 @@ bool Bun__deepEquals(JSC::JSGlobalObject* globalObject, JSValue v1, JSValue v2,
                 }
             }
 
-            auto eql = Bun__deepEquals<isStrict, enableAsymmetricMatchers, skipPrototype>(globalObject, left, right, gcBuffer, stack, scope, true);
+            auto eql = Bun__deepEquals<isStrict, enableAsymmetricMatchers, checkPrototypes, skipPrototypeIdentity>(globalObject, left, right, gcBuffer, stack, scope, true);
             RETURN_IF_EXCEPTION(scope, false);
             if (!eql) return false;
         }
@@ -822,6 +898,12 @@ bool Bun__deepEquals(JSC::JSGlobalObject* globalObject, JSValue v1, JSValue v2,
             return false;
         }
 
+        if constexpr (checkPrototypes) {
+            // node compares own enumerable non-index string+symbol props via getOwnNonIndexProperties;
+            // the Bun.deepEquals symbol-only block below walks the prototype chain, so diverge here.
+            return nonIndexOwnPropertiesEqual<isStrict, enableAsymmetricMatchers, checkPrototypes, skipPrototypeIdentity>(globalObject, gcBuffer, stack, scope, o1, o2);
+        }
+
         JSC::PropertyNameArrayBuilder a1(vm, PropertyNameMode::Symbols, PrivateSymbolMode::Exclude);
         JSC::PropertyNameArrayBuilder a2(vm, PropertyNameMode::Symbols, PrivateSymbolMode::Exclude);
         JSObject::getOwnPropertyNames(o1, globalObject, a1, DontEnumPropertiesMode::Exclude);
@@ -861,7 +943,7 @@ bool Bun__deepEquals(JSC::JSGlobalObject* globalObject, JSValue v1, JSValue v2,
                 return false;
             }
 
-            auto eql = Bun__deepEquals<isStrict, enableAsymmetricMatchers, skipPrototype>(globalObject, prop1, prop2, gcBuffer, stack, scope, true);
+            auto eql = Bun__deepEquals<isStrict, enableAsymmetricMatchers, checkPrototypes, skipPrototypeIdentity>(globalObject, prop1, prop2, gcBuffer, stack, scope, true);
             RETURN_IF_EXCEPTION(scope, false);
             if (!eql) return false;
         }
@@ -871,7 +953,7 @@ bool Bun__deepEquals(JSC::JSGlobalObject* globalObject, JSValue v1, JSValue v2,
         return true;
     }
 
-    if constexpr (isStrict && !skipPrototype) {
+    if constexpr (isStrict && !skipPrototypeIdentity) {
         if (!equal(JSObject::calculatedClassName(o1), JSObject::calculatedClassName(o2))) {
             return false;
         }
@@ -880,7 +962,11 @@ bool Bun__deepEquals(JSC::JSGlobalObject* globalObject, JSValue v1, JSValue v2,
     JSC::Structure* o1Structure = o1->structure();
     if (!o1Structure->hasNonReifiedStaticProperties() && o1Structure->canPerformFastPropertyEnumeration()) {
         JSC::Structure* o2Structure = o2->structure();
-        if (!o2Structure->hasNonReifiedStaticProperties() && o2Structure->canPerformFastPropertyEnumeration()) {
+        // The mixed-structure fast path resolves properties with getDirect(),
+        // which also finds non-enumerable ones node ignores; the node entry
+        // point only takes the fast path when the structures match.
+        if (!o2Structure->hasNonReifiedStaticProperties() && o2Structure->canPerformFastPropertyEnumeration()
+            && (!checkPrototypes || o2Structure->id() == o1Structure->id())) {
 
             bool result = true;
             bool sameStructure = o2Structure->id() == o1Structure->id();
@@ -909,7 +995,7 @@ bool Bun__deepEquals(JSC::JSGlobalObject* globalObject, JSValue v1, JSValue v2,
                     RETURN_IF_EXCEPTION(scope, false);
                     if (same) return true;
 
-                    auto eql = Bun__deepEquals<isStrict, enableAsymmetricMatchers, skipPrototype>(globalObject, left, right, gcBuffer, stack, scope, true);
+                    auto eql = Bun__deepEquals<isStrict, enableAsymmetricMatchers, checkPrototypes, skipPrototypeIdentity>(globalObject, left, right, gcBuffer, stack, scope, true);
                     RETURN_IF_EXCEPTION(scope, false);
                     if (!eql) {
                         result = false;
@@ -958,7 +1044,7 @@ bool Bun__deepEquals(JSC::JSGlobalObject* globalObject, JSValue v1, JSValue v2,
                     RETURN_IF_EXCEPTION(scope, false);
                     if (same) return true;
 
-                    auto eql = Bun__deepEquals<isStrict, enableAsymmetricMatchers, skipPrototype>(globalObject, left, right, gcBuffer, stack, scope, true);
+                    auto eql = Bun__deepEquals<isStrict, enableAsymmetricMatchers, checkPrototypes, skipPrototypeIdentity>(globalObject, left, right, gcBuffer, stack, scope, true);
                     RETURN_IF_EXCEPTION(scope, false);
                     if (!eql) {
                         result = false;
@@ -1007,10 +1093,19 @@ bool Bun__deepEquals(JSC::JSGlobalObject* globalObject, JSValue v1, JSValue v2,
 
     JSC::PropertyNameArrayBuilder a1(vm, PropertyNameMode::StringsAndSymbols, PrivateSymbolMode::Exclude);
     JSC::PropertyNameArrayBuilder a2(vm, PropertyNameMode::StringsAndSymbols, PrivateSymbolMode::Exclude);
-    o1->getPropertyNames(globalObject, a1, DontEnumPropertiesMode::Exclude);
-    RETURN_IF_EXCEPTION(scope, false);
-    o2->getPropertyNames(globalObject, a2, DontEnumPropertiesMode::Exclude);
-    RETURN_IF_EXCEPTION(scope, false);
+    if constexpr (checkPrototypes) {
+        // node compares own enumerable properties only; getPropertyNames also
+        // collects enumerable properties from the prototype chain.
+        o1->methodTable()->getOwnPropertyNames(o1, globalObject, a1, DontEnumPropertiesMode::Exclude);
+        RETURN_IF_EXCEPTION(scope, false);
+        o2->methodTable()->getOwnPropertyNames(o2, globalObject, a2, DontEnumPropertiesMode::Exclude);
+        RETURN_IF_EXCEPTION(scope, false);
+    } else {
+        o1->getPropertyNames(globalObject, a1, DontEnumPropertiesMode::Exclude);
+        RETURN_IF_EXCEPTION(scope, false);
+        o2->getPropertyNames(globalObject, a2, DontEnumPropertiesMode::Exclude);
+        RETURN_IF_EXCEPTION(scope, false);
+    }
 
     const size_t propertyArrayLength1 = a1.size();
     const size_t propertyArrayLength2 = a2.size();
@@ -1033,8 +1128,22 @@ bool Bun__deepEquals(JSC::JSGlobalObject* globalObject, JSValue v1, JSValue v2,
             return false;
         }
 
-        JSValue prop2 = o2->getIfPropertyExists(globalObject, propertyName1);
-        RETURN_IF_EXCEPTION(scope, false);
+        JSValue prop2;
+        if constexpr (checkPrototypes) {
+            // node only matches own enumerable properties; getIfPropertyExists
+            // would also find non-enumerable or inherited ones.
+            PropertySlot slot2(o2, PropertySlot::InternalMethodType::GetOwnProperty);
+            bool has = o2->methodTable()->getOwnPropertySlot(o2, globalObject, propertyName1, slot2);
+            RETURN_IF_EXCEPTION(scope, false);
+            if (!has || (slot2.attributes() & PropertyAttribute::DontEnum)) {
+                return false;
+            }
+            prop2 = slot2.getValue(globalObject, propertyName1);
+            RETURN_IF_EXCEPTION(scope, false);
+        } else {
+            prop2 = o2->getIfPropertyExists(globalObject, propertyName1);
+            RETURN_IF_EXCEPTION(scope, false);
+        }
 
         if constexpr (!isStrict) {
             if (prop1.isUndefined() && prop2.isEmpty()) {
@@ -1046,7 +1155,7 @@ bool Bun__deepEquals(JSC::JSGlobalObject* globalObject, JSValue v1, JSValue v2,
             return false;
         }
 
-        auto eql = Bun__deepEquals<isStrict, enableAsymmetricMatchers, skipPrototype>(globalObject, prop1, prop2, gcBuffer, stack, scope, true);
+        auto eql = Bun__deepEquals<isStrict, enableAsymmetricMatchers, checkPrototypes, skipPrototypeIdentity>(globalObject, prop1, prop2, gcBuffer, stack, scope, true);
         RETURN_IF_EXCEPTION(scope, false);
         if (!eql) return false;
     }
@@ -1132,7 +1241,7 @@ static std::optional<bool> temporalObjectsDequal(JSC::JSObject* o1, JSC::JSObjec
     return std::nullopt;
 }
 
-template<bool isStrict, bool enableAsymmetricMatchers, bool skipPrototype>
+template<bool isStrict, bool enableAsymmetricMatchers, bool checkPrototypes, bool skipPrototypeIdentity>
 std::optional<bool> specialObjectsDequal(JSC::JSGlobalObject* globalObject, MarkedArgumentBuffer& gcBuffer, Vector<std::pair<JSC::JSValue, JSC::JSValue>, 16>& stack, ThrowScope& scope, JSCell* _Nonnull c1, JSCell* _Nonnull c2)
 {
     VM& vm = globalObject->vm();
@@ -1169,7 +1278,7 @@ std::optional<bool> specialObjectsDequal(JSC::JSGlobalObject* globalObject, Mark
             JSValue key2;
             bool foundMatchingKey = false;
             while (iter2->next(globalObject, key2)) {
-                bool equal = Bun__deepEquals<isStrict, enableAsymmetricMatchers, skipPrototype>(globalObject, key1, key2, gcBuffer, stack, scope, false);
+                bool equal = Bun__deepEquals<isStrict, enableAsymmetricMatchers, checkPrototypes, skipPrototypeIdentity>(globalObject, key1, key2, gcBuffer, stack, scope, false);
                 RETURN_IF_EXCEPTION(scope, {});
                 if (equal) {
                     foundMatchingKey = true;
@@ -1182,6 +1291,10 @@ std::optional<bool> specialObjectsDequal(JSC::JSGlobalObject* globalObject, Mark
             }
         }
 
+        if constexpr (checkPrototypes) {
+            // node also compares own enumerable properties of Sets.
+            break;
+        }
         return true;
     }
     case JSMapType: {
@@ -1212,7 +1325,7 @@ std::optional<bool> specialObjectsDequal(JSC::JSGlobalObject* globalObject, Mark
                 JSValue key2;
                 bool foundMatchingKey = false;
                 while (iter2->nextKeyValue(globalObject, key2, value2)) {
-                    bool keysEqual = Bun__deepEquals<isStrict, enableAsymmetricMatchers, skipPrototype>(globalObject, key1, key2, gcBuffer, stack, scope, false);
+                    bool keysEqual = Bun__deepEquals<isStrict, enableAsymmetricMatchers, checkPrototypes, skipPrototypeIdentity>(globalObject, key1, key2, gcBuffer, stack, scope, false);
                     RETURN_IF_EXCEPTION(scope, {});
                     if (keysEqual) {
                         foundMatchingKey = true;
@@ -1227,13 +1340,17 @@ std::optional<bool> specialObjectsDequal(JSC::JSGlobalObject* globalObject, Mark
                 // Compare both values below.
             }
 
-            bool valuesEqual = Bun__deepEquals<isStrict, enableAsymmetricMatchers, skipPrototype>(globalObject, value1, value2, gcBuffer, stack, scope, false);
+            bool valuesEqual = Bun__deepEquals<isStrict, enableAsymmetricMatchers, checkPrototypes, skipPrototypeIdentity>(globalObject, value1, value2, gcBuffer, stack, scope, false);
             RETURN_IF_EXCEPTION(scope, {});
             if (!valuesEqual) {
                 return false;
             }
         }
 
+        if constexpr (checkPrototypes) {
+            // node also compares own enumerable properties of Maps.
+            break;
+        }
         return true;
     }
     case ArrayBufferType: {
@@ -1262,19 +1379,47 @@ std::optional<bool> specialObjectsDequal(JSC::JSGlobalObject* globalObject, Mark
             return false;
         }
 
-        if (byteLength == 0)
-            return true;
+        if (!WTF::equalSpans(left->span(), right->span()))
+            return false;
 
-        const void* vector = left->data();
-        const void* rightVector = right->data();
-        if (!vector || !rightVector) [[unlikely]] {
+        if constexpr (checkPrototypes) {
+            // node also compares own enumerable properties of ArrayBuffers.
+            break;
+        }
+        return true;
+    }
+    case DataViewType: {
+        if constexpr (!checkPrototypes) {
+            // Bun.deepEquals / bun:test compare DataViews as plain objects; reserve the byte
+            // comparison for the node-parity instantiations.
+            break;
+        }
+        if (c2Type != DataViewType) {
             return false;
         }
 
-        if (vector == rightVector) [[unlikely]]
-            return true;
-
-        return (memcmp(vector, rightVector, byteLength) == 0);
+        // node compares DataViews by contents (their bytes at the view's
+        // offset), then falls through to own enumerable properties.
+        JSC::JSDataView* left = uncheckedDowncast<JSC::JSDataView>(c1);
+        JSC::JSDataView* right = uncheckedDowncast<JSC::JSDataView>(c2);
+        if (left->isDetached() || right->isDetached()) [[unlikely]] {
+            // The C++ byteLength() accessor silently reports 0 for a detached
+            // view; node reads the JS accessor, which throws. Keep node's
+            // exact error contract.
+            throwTypeError(globalObject, scope, "Cannot perform get DataView.prototype.byteLength on a detached or out-of-bounds ArrayBuffer"_s);
+            return false;
+        }
+        size_t byteLength = left->byteLength();
+        if (right->byteLength() != byteLength) {
+            return false;
+        }
+        if (!WTF::equalSpans(std::span { static_cast<const uint8_t*>(left->vector()), byteLength },
+                std::span { static_cast<const uint8_t*>(right->vector()), byteLength }))
+            return false;
+        // node compares DataView own properties via getOwnNonIndexProperties
+        // (an extra integer-index key is ignored), so compare the non-index
+        // keys directly instead of falling through to the full own-key walk.
+        return nonIndexOwnPropertiesEqual<isStrict, enableAsymmetricMatchers, checkPrototypes, skipPrototypeIdentity>(globalObject, gcBuffer, stack, scope, left, right);
     }
     case JSDateType: {
         if (c2Type != JSDateType) {
@@ -1284,6 +1429,17 @@ std::optional<bool> specialObjectsDequal(JSC::JSGlobalObject* globalObject, Mark
         JSC::DateInstance* left = uncheckedDowncast<DateInstance>(c1);
         JSC::DateInstance* right = uncheckedDowncast<DateInstance>(c2);
 
+        if constexpr (checkPrototypes) {
+            double time1 = left->internalNumber();
+            double time2 = right->internalNumber();
+            // node treats two invalid dates as equal, and compares own
+            // enumerable properties as well.
+            if (time1 != time2 && !(std::isnan(time1) && std::isnan(time2))) {
+                return false;
+            }
+            break;
+        }
+
         return left->internalNumber() == right->internalNumber();
     }
     case RegExpObjectType: {
@@ -1298,7 +1454,19 @@ std::optional<bool> specialObjectsDequal(JSC::JSGlobalObject* globalObject, Mark
                 return false;
             }
 
-            return left->regExp()->key() == right->regExp()->key();
+            if (left->regExp()->key() != right->regExp()->key()) {
+                return false;
+            }
+            if constexpr (checkPrototypes) {
+                // node also compares `lastIndex` and own enumerable properties.
+                bool sameLastIndex = JSC::sameValue(globalObject, left->getLastIndex(), right->getLastIndex());
+                RETURN_IF_EXCEPTION(scope, {});
+                if (!sameLastIndex) {
+                    return false;
+                }
+                break;
+            }
+            return true;
         }
 
         return false;
@@ -1364,7 +1532,7 @@ std::optional<bool> specialObjectsDequal(JSC::JSGlobalObject* globalObject, Mark
             RETURN_IF_EXCEPTION(scope, {});
             auto rightCause = right->get(globalObject, cause);
             RETURN_IF_EXCEPTION(scope, {});
-            bool causesEqual = Bun__deepEquals<isStrict, enableAsymmetricMatchers, skipPrototype>(globalObject, leftCause, rightCause, gcBuffer, stack, scope, true);
+            bool causesEqual = Bun__deepEquals<isStrict, enableAsymmetricMatchers, checkPrototypes, skipPrototypeIdentity>(globalObject, leftCause, rightCause, gcBuffer, stack, scope, true);
             RETURN_IF_EXCEPTION(scope, {});
             if (!causesEqual) {
                 return false;
@@ -1414,7 +1582,7 @@ std::optional<bool> specialObjectsDequal(JSC::JSGlobalObject* globalObject, Mark
                     return false;
                 }
 
-                bool propertiesEqual = Bun__deepEquals<isStrict, enableAsymmetricMatchers, skipPrototype>(globalObject, prop1, prop2, gcBuffer, stack, scope, true);
+                bool propertiesEqual = Bun__deepEquals<isStrict, enableAsymmetricMatchers, checkPrototypes, skipPrototypeIdentity>(globalObject, prop1, prop2, gcBuffer, stack, scope, true);
                 RETURN_IF_EXCEPTION(scope, {});
                 if (!propertiesEqual) {
                     return false;
@@ -1479,6 +1647,9 @@ std::optional<bool> specialObjectsDequal(JSC::JSGlobalObject* globalObject, Mark
         }
 
         if (byteLength == 0) {
+            if constexpr (checkPrototypes) {
+                return nonIndexOwnPropertiesEqual<isStrict, enableAsymmetricMatchers, checkPrototypes, skipPrototypeIdentity>(globalObject, gcBuffer, stack, scope, left, right);
+            }
             if (compareOwnProperties) break;
             return true;
         }
@@ -1494,52 +1665,37 @@ std::optional<bool> specialObjectsDequal(JSC::JSGlobalObject* globalObject, Mark
         }
 
         if (vector == rightVector) [[unlikely]] {
+            if constexpr (checkPrototypes) {
+                return nonIndexOwnPropertiesEqual<isStrict, enableAsymmetricMatchers, checkPrototypes, skipPrototypeIdentity>(globalObject, gcBuffer, stack, scope, left, right);
+            }
             if (compareOwnProperties) break;
             return true;
         }
 
-        // For Float32Array and Float64Array, when not in strict mode, we need to
-        // handle +0 and -0 as equal, and NaN as not equal to itself.
+        // Float arrays in non-strict mode use IEEE == (+0/-0 equal, NaN != NaN); everything else
+        // compares raw bytes. All results funnel to one tail so node-parity never skips own props.
+        bool contentsEqual;
         if (!isStrict && (c1Type == Float16ArrayType || c1Type == Float32ArrayType || c1Type == Float64ArrayType)) {
             if (c1Type == Float16ArrayType) {
-                auto* leftFloat = static_cast<const WTF::Float16*>(vector);
-                auto* rightFloat = static_cast<const WTF::Float16*>(rightVector);
-                size_t numElements = byteLength / sizeof(WTF::Float16);
-
-                for (size_t i = 0; i < numElements; i++) {
-                    if (leftFloat[i] != rightFloat[i]) {
-                        return false;
-                    }
-                }
-                return true;
+                contentsEqual = looseFloatContentsEqual(std::span { static_cast<const WTF::Float16*>(vector), byteLength / sizeof(WTF::Float16) },
+                    std::span { static_cast<const WTF::Float16*>(rightVector), byteLength / sizeof(WTF::Float16) });
             } else if (c1Type == Float32ArrayType) {
-                auto* leftFloat = static_cast<const float*>(vector);
-                auto* rightFloat = static_cast<const float*>(rightVector);
-                size_t numElements = byteLength / sizeof(float);
-
-                for (size_t i = 0; i < numElements; i++) {
-                    if (leftFloat[i] != rightFloat[i]) {
-                        return false;
-                    }
-                }
-                return true;
+                contentsEqual = looseFloatContentsEqual(std::span { static_cast<const float*>(vector), byteLength / sizeof(float) },
+                    std::span { static_cast<const float*>(rightVector), byteLength / sizeof(float) });
             } else { // Float64Array
-                auto* leftDouble = static_cast<const double*>(vector);
-                auto* rightDouble = static_cast<const double*>(rightVector);
-                size_t numElements = byteLength / sizeof(double);
-
-                for (size_t i = 0; i < numElements; i++) {
-                    if (leftDouble[i] != rightDouble[i]) {
-                        return false;
-                    }
-                }
-                return true;
+                contentsEqual = looseFloatContentsEqual(std::span { static_cast<const double*>(vector), byteLength / sizeof(double) },
+                    std::span { static_cast<const double*>(rightVector), byteLength / sizeof(double) });
             }
+        } else {
+            contentsEqual = WTF::equalSpans(std::span { static_cast<const uint8_t*>(vector), byteLength },
+                std::span { static_cast<const uint8_t*>(rightVector), byteLength });
         }
-
-        if (memcmp(vector, rightVector, byteLength) != 0) {
+        if (!contentsEqual) {
             return false;
         }
+        if constexpr (checkPrototypes) {
+            return nonIndexOwnPropertiesEqual<isStrict, enableAsymmetricMatchers, checkPrototypes, skipPrototypeIdentity>(globalObject, gcBuffer, stack, scope, left, right);
+        }
         if (compareOwnProperties) break;
         return true;
     }
@@ -1548,14 +1704,14 @@ std::optional<bool> specialObjectsDequal(JSC::JSGlobalObject* globalObject, Mark
             // A String subclass instance is DerivedStringObjectType. Only skipPrototype
             // mode, where the constructor is ignored, treats it as an equivalent boxed
             // string; every other mode keeps the existing "different type" answer.
-            if constexpr (!(isStrict && skipPrototype)) {
+            if constexpr (!(isStrict && skipPrototypeIdentity)) {
                 return false;
             } else if (c2Type != DerivedStringObjectType) {
                 return false;
             }
         }
 
-        if constexpr (!skipPrototype) {
+        if constexpr (!skipPrototypeIdentity) {
             if (!equal(JSObject::calculatedClassName(c1->getObject()), JSObject::calculatedClassName(c2->getObject()))) {
                 return false;
             }
@@ -1568,12 +1724,13 @@ std::optional<bool> specialObjectsDequal(JSC::JSGlobalObject* globalObject, Mark
 
         bool stringsEqual = s1->equal(globalObject, s2);
         RETURN_IF_EXCEPTION(scope, {});
-        if (!stringsEqual) return false;
-
-        if constexpr (isStrict) {
-            // Only strict mode compares extra own properties on boxed primitives.
-            // Guarded so a plain boxed string does not fall through to the property
-            // walk, which would enumerate every character index.
+        if (!stringsEqual) {
+            return false;
+        }
+        if constexpr (checkPrototypes || isStrict) {
+            // Only these modes compare extra own props on boxed primitives. Guarded so a plain
+            // boxed string skips the per-char-index walk; `break` (not nonIndexOwnPropertiesEqual)
+            // when extras exist so an out-of-range index still fails the compare, like node.
             if (hasExtraOwnProperties(c1->structure()) || hasExtraOwnProperties(c2->structure())) {
                 break;
             }
@@ -1729,6 +1886,15 @@ std::optional<bool> specialObjectsDequal(JSC::JSGlobalObject* globalObject, Mark
         break;
     }
 
+    if constexpr (checkPrototypes) {
+        // node never considers distinct WeakMaps, WeakSets, or Promises equal
+        // (their contents cannot be inspected).
+        if (c1Type == JSC::JSWeakMapType || c1Type == JSC::JSWeakSetType || c1Type == JSC::JSPromiseType
+            || c2Type == JSC::JSWeakMapType || c2Type == JSC::JSWeakSetType || c2Type == JSC::JSPromiseType) {
+            return false;
+        }
+    }
+
     // Symbol and BigInt wrapper objects are plain ObjectType in JSC, so they are not
     // reachable from the switch above. Like Number and Boolean wrappers, they must be
     // the same kind of wrapper and hold the same internal value. Everything else --
@@ -1756,13 +1922,13 @@ std::optional<bool> specialObjectsDequal(JSC::JSGlobalObject* globalObject, Mark
             }
         }
     }
+
     return std::nullopt;
 }
 
 // The other combinations are instantiated by their uses in this file. This one is
-// only reached from `Bun.deepEquals(a, b, true, true)` in BunObject.cpp, which
-// backs `util.isDeepStrictEqual(a, b, skipPrototype)`.
-template bool Bun__deepEquals<true, false, true>(JSC::JSGlobalObject*, JSValue, JSValue, MarkedArgumentBuffer&, Vector<std::pair<JSC::JSValue, JSC::JSValue>, 16>&, ThrowScope&, bool);
+// only reached from `Bun.deepEquals(a, b, true, true)` in BunObject.cpp.
+template bool Bun__deepEquals<true, false, false, true>(JSC::JSGlobalObject*, JSValue, JSValue, MarkedArgumentBuffer&, Vector<std::pair<JSC::JSValue, JSC::JSValue>, 16>&, ThrowScope&, bool);
 
 /**
  * @brief `Bun.deepMatch(a, b)`
@@ -1887,7 +2053,7 @@ bool Bun__deepMatch(
             if (enableAsymmetricMatchers && isMatchingObjectContaining) {
                 Vector<std::pair<JSValue, JSValue>, 16> stack;
                 MarkedArgumentBuffer gcBuffer;
-                auto eql = Bun__deepEquals<false, true>(globalObject, prop, subsetProp, gcBuffer, stack, throwScope, true);
+                auto eql = Bun__deepEquals<false, true, false>(globalObject, prop, subsetProp, gcBuffer, stack, throwScope, true);
                 RETURN_IF_EXCEPTION(throwScope, false);
                 if (!eql) return false;
             } else {
@@ -1916,14 +2082,14 @@ bool Bun__deepMatch(
 
 // anonymous namespace to avoid name collision
 namespace {
-template<bool isStrict, bool enableAsymmetricMatchers>
+template<bool isStrict, bool enableAsymmetricMatchers, bool checkPrototypes, bool skipPrototypeIdentity = false>
 inline bool deepEqualsWrapperImpl(JSC::EncodedJSValue a, JSC::EncodedJSValue b, JSC::JSGlobalObject* global)
 {
     auto& vm = global->vm();
     auto scope = DECLARE_THROW_SCOPE(vm);
     Vector<std::pair<JSC::JSValue, JSC::JSValue>, 16> stack;
     MarkedArgumentBuffer args;
-    bool result = Bun__deepEquals<isStrict, enableAsymmetricMatchers>(global, JSC::JSValue::decode(a), JSC::JSValue::decode(b), args, stack, scope, true);
+    bool result = Bun__deepEquals<isStrict, enableAsymmetricMatchers, checkPrototypes, skipPrototypeIdentity>(global, JSC::JSValue::decode(a), JSC::JSValue::decode(b), args, stack, scope, true);
     RELEASE_AND_RETURN(scope, result);
 }
 }
@@ -2912,22 +3078,36 @@ bool JSC__JSValue__isSameValue(JSC::EncodedJSValue JSValue0, JSC::EncodedJSValue
 
 bool JSC__JSValue__deepEquals(JSC::EncodedJSValue JSValue0, JSC::EncodedJSValue JSValue1, JSC::JSGlobalObject* globalObject)
 {
-    return deepEqualsWrapperImpl<false, false>(JSValue0, JSValue1, globalObject);
+    return deepEqualsWrapperImpl<false, false, false>(JSValue0, JSValue1, globalObject);
 }
 
 bool JSC__JSValue__jestDeepEquals(JSC::EncodedJSValue JSValue0, JSC::EncodedJSValue JSValue1, JSC::JSGlobalObject* globalObject)
 {
-    return deepEqualsWrapperImpl<false, true>(JSValue0, JSValue1, globalObject);
+    return deepEqualsWrapperImpl<false, true, false>(JSValue0, JSValue1, globalObject);
 }
 
 bool JSC__JSValue__strictDeepEquals(JSC::EncodedJSValue JSValue0, JSC::EncodedJSValue JSValue1, JSC::JSGlobalObject* globalObject)
 {
-    return deepEqualsWrapperImpl<true, false>(JSValue0, JSValue1, globalObject);
+    return deepEqualsWrapperImpl<true, false, false>(JSValue0, JSValue1, globalObject);
 }
 
 bool JSC__JSValue__jestStrictDeepEquals(JSC::EncodedJSValue JSValue0, JSC::EncodedJSValue JSValue1, JSC::JSGlobalObject* globalObject)
 {
-    return deepEqualsWrapperImpl<true, true>(JSValue0, JSValue1, globalObject);
+    return deepEqualsWrapperImpl<true, true, false>(JSValue0, JSValue1, globalObject);
+}
+
+// node:assert deepStrictEqual / node:util.isDeepStrictEqual: strict deepEquals
+// plus node's [[Prototype]] identity rule (Bun.deepEquals stays prototype-blind).
+bool Bun__deepEqualsNodeStrict(JSC::EncodedJSValue JSValue0, JSC::EncodedJSValue JSValue1, JSC::JSGlobalObject* globalObject)
+{
+    return deepEqualsWrapperImpl<true, false, true>(JSValue0, JSValue1, globalObject);
+}
+
+// node:assert deepStrictEqual with the Assert class skipPrototype option:
+// node semantics, but the [[Prototype]] identity check is skipped.
+bool Bun__deepEqualsNodeStrictSkipProto(JSC::EncodedJSValue JSValue0, JSC::EncodedJSValue JSValue1, JSC::JSGlobalObject* globalObject)
+{
+    return deepEqualsWrapperImpl<true, false, true, true>(JSValue0, JSValue1, globalObject);
 }
 
 #undef IMPL_DEEP_EQUALS_WRAPPER
diff --git a/src/jsc/bindings/c-bindings.cpp b/src/jsc/bindings/c-bindings.cpp
index f5270305621d..1ead5980b9ba 100644
--- a/src/jsc/bindings/c-bindings.cpp
+++ b/src/jsc/bindings/c-bindings.cpp
@@ -3,6 +3,7 @@
 #include <cstdio>
 
 #if !OS(WINDOWS)
+#include <wtf/WTFConfig.h>
 #include <sys/resource.h>
 #include <fcntl.h>
 #include <sys/stat.h>
@@ -283,6 +284,10 @@ extern "C" ssize_t bun_close_range(unsigned int start, unsigned int end, unsigne
 }
 #endif
 
+#endif // OS(LINUX) || OS(FREEBSD)
+
+#if !OS(WINDOWS)
+
 static void unset_cloexec(int fd)
 {
     int flags = fcntl(fd, F_GETFD, 0);
@@ -293,24 +298,60 @@ static void unset_cloexec(int fd)
     fcntl(fd, F_SETFD, flags);
 }
 
-extern "C" void on_before_reload_process_linux()
+extern "C" void on_before_reload_process_posix()
 {
     unset_cloexec(STDIN_FILENO);
     unset_cloexec(STDOUT_FILENO);
     unset_cloexec(STDERR_FILENO);
 
+#if OS(LINUX) || OS(FREEBSD)
     // close all file descriptors except stdin, stdout, stderr and possibly IPC.
     // if you're passing additional file descriptors to Bun, you're probably not passing more than 8.
     // If this fails, it's ultimately okay, we're just trying our best to avoid leaking file descriptors.
     bun_close_range(3, ~0U, CLOSE_RANGE_CLOEXEC);
+#endif
+
+    // Preserve the IPC channel to the parent across the execve: NODE_CHANNEL_FD survives in
+    // environ and the reloaded image re-attaches to it; CLOEXEC'd, the parent stops receiving
+    // 'message' events after the first reload.
+    if (const char* s = getenv("NODE_CHANNEL_FD")) {
+        char* end = nullptr;
+        long fd = strtol(s, &end, 10);
+        if (end != s && *end == '\0' && fd >= 3 && fd <= INT_MAX)
+            unset_cloexec(static_cast<int>(fd));
+    }
+
+    // Reset caught dispositions so a SIGTERM arriving between here and execve isn't queued-then-
+    // lost. Inherited SIG_IGN is left alone. SIGSEGV/SIGBUS/RT/sigThreadSuspendResume are left
+    // for execve to reset atomically — resetting them here races JSC's sampler/GC threads fatally.
+    struct sigaction sa {};
+    sa.sa_handler = SIG_DFL;
+    sigemptyset(&sa.sa_mask);
+    for (int s = 1; s < NSIG; s++) {
+        if (s == SIGKILL || s == SIGSTOP || s == SIGSEGV || s == SIGBUS)
+            continue;
+#if OS(LINUX)
+        if (s == g_wtfConfig.sigThreadSuspendResume)
+            continue;
+#endif
+#ifdef SIGRTMIN
+        if (s >= SIGRTMIN)
+            break;
+#endif
+        struct sigaction old {};
+        if (sigaction(s, nullptr, &old) != 0)
+            continue;
+        if (old.sa_handler == SIG_IGN || old.sa_handler == SIG_DFL)
+            continue;
+        sigaction(s, &sa, nullptr);
+    }
 
-    // reset all signals to default
     sigset_t signal_set;
     sigemptyset(&signal_set);
     sigprocmask(SIG_SETMASK, &signal_set, nullptr);
 }
 
-#endif
+#endif // !OS(WINDOWS)
 
 #define LSHPACK_MAX_HEADER_SIZE 65536
 
diff --git a/src/jsc/bindings/headers-handwritten.h b/src/jsc/bindings/headers-handwritten.h
index 6cb74be5243e..67e94e8c3deb 100644
--- a/src/jsc/bindings/headers-handwritten.h
+++ b/src/jsc/bindings/headers-handwritten.h
@@ -405,7 +405,7 @@ extern "C" JSC::EncodedJSValue Bun__encoding__constructFromUTF16(void*, const ch
 extern "C" void Bun__EventLoop__runCallback2(JSC::JSGlobalObject* global, JSC::EncodedJSValue callback, JSC::EncodedJSValue thisValue, JSC::EncodedJSValue arg1, JSC::EncodedJSValue arg2);
 
 /// @note throws a JS exception and returns false if a stack overflow occurs
-template<bool isStrict, bool enableAsymmetricMatchers, bool skipPrototype = false>
+template<bool isStrict, bool enableAsymmetricMatchers, bool checkPrototypes, bool skipPrototypeIdentity = false>
 bool Bun__deepEquals(JSC::JSGlobalObject* globalObject, JSC::JSValue v1, JSC::JSValue v2, JSC::MarkedArgumentBuffer&, Vector<std::pair<JSC::JSValue, JSC::JSValue>, 16>& stack, JSC::ThrowScope& scope, bool addToStack);
 
 /**
diff --git a/src/jsc/bindings/stringWidth.cpp b/src/jsc/bindings/stringWidth.cpp
index 0c8abbb3c35a..65cda77f301e 100644
--- a/src/jsc/bindings/stringWidth.cpp
+++ b/src/jsc/bindings/stringWidth.cpp
@@ -25,6 +25,7 @@
 #include "root.h"
 #include "stringWidth.h"
 #include "ANSIHelpers.h"
+#include <unicode/uchar.h>
 #include "ObjectBindings.h"
 #include "stringWidthTables.h"
 
@@ -1031,6 +1032,73 @@ static void applyTruthyBooleanOption(JSC::JSGlobalObject* globalObject, JSC::JSV
     out = value.toBoolean(globalObject);
 }
 
+namespace StringWidth {
+
+// node's per-code-point column width: EAW first, Emoji_Presentation on the neutral/narrow-
+// ambiguous path, then zero-width categories (Cc/Cf/Me/Mn or Emoji_Modifier), SOFT HYPHEN = 1.
+// https://github.com/nodejs/node/blob/main/src/node_i18n.cc (GetColumnWidth)
+static uint32_t perCodePointColumnWidth(char32_t cp, bool ambiguousAsWide)
+{
+    switch (u_getIntPropertyValue(static_cast<UChar32>(cp), UCHAR_EAST_ASIAN_WIDTH)) {
+    case U_EA_FULLWIDTH:
+    case U_EA_WIDE:
+        return 2;
+    case U_EA_AMBIGUOUS:
+        if (ambiguousAsWide)
+            return 2;
+        [[fallthrough]];
+    case U_EA_NEUTRAL:
+        if (u_hasBinaryProperty(static_cast<UChar32>(cp), UCHAR_EMOJI_PRESENTATION))
+            return 2;
+        [[fallthrough]];
+    default: {
+        constexpr uint32_t zeroWidthMask = U_GC_CC_MASK | U_GC_CF_MASK | U_GC_ME_MASK | U_GC_MN_MASK;
+        if (cp != 0x00AD
+            && ((U_MASK(u_charType(static_cast<UChar32>(cp))) & zeroWidthMask)
+                || u_hasBinaryProperty(static_cast<UChar32>(cp), UCHAR_EMOJI_MODIFIER)))
+            return 0;
+        return 1;
+    }
+    }
+}
+
+static size_t perCodePointLatin1Width(std::span<const uint8_t> input, bool excludeAnsiColors, bool ambiguousAsWide)
+{
+    size_t width = 0;
+    const uint8_t* p = input.data();
+    const uint8_t* const end = p + input.size();
+    while (p != end) {
+        if (excludeAnsiColors && ANSI::isEscapeCharacter(*p)) {
+            p = ANSI::consumeANSI(p, end); // always makes progress
+            continue;
+        }
+        width += perCodePointColumnWidth(*p++, ambiguousAsWide);
+    }
+    return width;
+}
+
+static size_t perCodePointUTF16Width(std::span<const char16_t> input, bool excludeAnsiColors, bool ambiguousAsWide)
+{
+    size_t width = 0;
+    const char16_t* p = input.data();
+    const char16_t* const end = p + input.size();
+    while (p != end) {
+        if (excludeAnsiColors && ANSI::isEscapeCharacter(*p)) {
+            p = ANSI::consumeANSI(p, end); // always makes progress
+            continue;
+        }
+        char32_t cp = *p++;
+        if (U16_IS_LEAD(cp) && p != end && U16_IS_TRAIL(*p)) {
+            cp = U16_GET_SUPPLEMENTARY(static_cast<char16_t>(cp), *p);
+            p++;
+        }
+        width += perCodePointColumnWidth(cp, ambiguousAsWide);
+    }
+    return width;
+}
+
+} // namespace StringWidth
+
 JSC_DEFINE_HOST_FUNCTION(jsFunctionBunStringWidth, (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))
 {
     auto& vm = globalObject->vm();
@@ -1049,6 +1117,7 @@ JSC_DEFINE_HOST_FUNCTION(jsFunctionBunStringWidth, (JSC::JSGlobalObject * global
 
     bool countAnsiEscapeCodes = false;
     bool ambiguousIsNarrow = true;
+    bool perCodePoint = false;
 
     const JSC::JSValue optionsValue = callFrame->argument(1);
     if (optionsValue.isObject()) {
@@ -1063,9 +1132,27 @@ JSC_DEFINE_HOST_FUNCTION(jsFunctionBunStringWidth, (JSC::JSGlobalObject * global
         JSC::JSValue ambiguousIsNarrowValue = getIfPropertyExistsPrototypePollutionMitigation(globalObject, optionsObject, JSC::Identifier::fromString(vm, "ambiguousIsNarrow"_s));
         RETURN_IF_EXCEPTION(scope, {});
         applyTruthyBooleanOption(globalObject, ambiguousIsNarrowValue, ambiguousIsNarrow);
+
+        JSC::JSValue perCodePointValue = getIfPropertyExistsPrototypePollutionMitigation(globalObject, optionsObject, JSC::Identifier::fromString(vm, "perCodePoint"_s));
+        RETURN_IF_EXCEPTION(scope, {});
+        applyTruthyBooleanOption(globalObject, perCodePointValue, perCodePoint);
     }
 
     const bool ambiguousAsWide = !ambiguousIsNarrow;
+    if (perCodePoint) {
+        // node's ICU column-width algorithm: every code point measured
+        // individually (an emoji ZWJ sequence counts each member), instead
+        // of the grapheme clustering above.
+        size_t width;
+        if (view->is8Bit()) {
+            const auto span = view->span8();
+            width = StringWidth::perCodePointLatin1Width({ reinterpret_cast<const uint8_t*>(span.data()), span.size() }, !countAnsiEscapeCodes, ambiguousAsWide);
+        } else {
+            const auto span = view->span16();
+            width = StringWidth::perCodePointUTF16Width({ span.data(), span.size() }, !countAnsiEscapeCodes, ambiguousAsWide);
+        }
+        return JSC::JSValue::encode(JSC::jsNumber(static_cast<double>(width)));
+    }
     size_t width;
     if (view->is8Bit()) {
         // 8-bit JSC strings are Latin-1.
diff --git a/src/jsc/bindings/webcore/EventEmitter.cpp b/src/jsc/bindings/webcore/EventEmitter.cpp
index 3b6ac949fa24..1151d79b38d0 100644
--- a/src/jsc/bindings/webcore/EventEmitter.cpp
+++ b/src/jsc/bindings/webcore/EventEmitter.cpp
@@ -85,8 +85,18 @@ bool EventEmitter::removeAllListeners()
 
     auto& map = data->eventListenerMap;
     bool any = !map.isEmpty();
+    // Collect before clearing so per-event teardown (signal handlers, IPC
+    // refs, listener-count mirrors) observes the post-removal zero counts.
+    Vector<Identifier> eventTypes = map.eventTypes();
     map.clear();
     this->m_thisObject.clear();
+    if (any) {
+        eventListenersDidChange();
+        if (this->onDidChangeListener) {
+            for (auto& eventType : eventTypes)
+                this->onDidChangeListener(*this, eventType, false);
+        }
+    }
     return any;
 }
 
diff --git a/src/jsc/bindings/webcore/JSDOMConvertStrings.cpp b/src/jsc/bindings/webcore/JSDOMConvertStrings.cpp
index af8536c0d697..2fa7a305e085 100644
--- a/src/jsc/bindings/webcore/JSDOMConvertStrings.cpp
+++ b/src/jsc/bindings/webcore/JSDOMConvertStrings.cpp
@@ -86,6 +86,12 @@ String valueToUSVString(JSGlobalObject& lexicalGlobalObject, JSValue value)
     VM& vm = lexicalGlobalObject.vm();
     auto scope = DECLARE_THROW_SCOPE(vm);
 
+    // Match V8/Node's wording for symbol-to-string coercion errors.
+    if (value.isSymbol()) [[unlikely]] {
+        throwTypeError(&lexicalGlobalObject, scope, "Cannot convert a Symbol value to a string"_s);
+        return {};
+    }
+
     auto string = value.toWTFString(&lexicalGlobalObject);
     RETURN_IF_EXCEPTION(scope, {});
 
diff --git a/src/jsc/bindings/webcore/JSDOMURL.cpp b/src/jsc/bindings/webcore/JSDOMURL.cpp
index 151b59d1639f..0b4018ed59ee 100644
--- a/src/jsc/bindings/webcore/JSDOMURL.cpp
+++ b/src/jsc/bindings/webcore/JSDOMURL.cpp
@@ -41,15 +41,20 @@
 #include "JSURLSearchParams.h"
 #include "ScriptExecutionContext.h"
 #include "WebCoreJSClientData.h"
+#include "streams/WebStreamsInspectCustom.h"
 #include <JavaScriptCore/FunctionPrototype.h>
+#include <JavaScriptCore/GetterSetter.h>
 #include <JavaScriptCore/HeapAnalyzer.h>
 #include <JavaScriptCore/JSCInlines.h>
 #include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>
+#include <JavaScriptCore/ObjectConstructor.h>
 #include <JavaScriptCore/SlotVisitorMacros.h>
 #include <JavaScriptCore/SubspaceInlines.h>
+#include <JavaScriptCore/Symbol.h>
 #include <wtf/GetPtr.h>
 #include <wtf/PointerPreparations.h>
 #include <wtf/URL.h>
+#include <wtf/text/StringToIntegerConversion.h>
 
 #if ENABLE(MEDIA_SOURCE)
 #include "DOMURLMediaSource.h"
@@ -65,6 +70,7 @@ static JSC_DECLARE_HOST_FUNCTION(jsDOMURLConstructorFunction_parse);
 static JSC_DECLARE_HOST_FUNCTION(jsDOMURLConstructorFunction_canParse);
 static JSC_DECLARE_HOST_FUNCTION(jsDOMURLPrototypeFunction_toJSON);
 static JSC_DECLARE_HOST_FUNCTION(jsDOMURLPrototypeFunction_toString);
+static JSC_DECLARE_HOST_FUNCTION(jsDOMURLPrototypeFunction_inspectCustom);
 
 BUN_DECLARE_HOST_FUNCTION(Bun__createObjectURL);
 BUN_DECLARE_HOST_FUNCTION(Bun__revokeObjectURL);
@@ -159,7 +165,8 @@ template<> EncodedJSValue JSC_HOST_CALL_ATTRIBUTES JSDOMURLDOMConstructor::const
     EnsureStillAliveScope argument1 = callFrame->argument(1);
     auto base = argument1.value().isUndefined() ? String() : convert<IDLUSVString>(*lexicalGlobalObject, argument1.value());
     RETURN_IF_EXCEPTION(throwScope, {});
-    auto object = base.isEmpty() ? DOMURL::create(WTF::move(url)) : DOMURL::create(WTF::move(url), WTF::move(base));
+    // An empty base string must still be parsed (and fail) per the URL spec.
+    auto object = base.isNull() ? DOMURL::create(WTF::move(url)) : DOMURL::create(WTF::move(url), WTF::move(base));
     if constexpr (IsExceptionOr<decltype(object)>)
         RETURN_IF_EXCEPTION(throwScope, {});
     static_assert(TypeOrExceptionOrUnderlyingType<decltype(object)>::isRef);
@@ -218,6 +225,7 @@ void JSDOMURLPrototype::finishCreation(VM& vm)
 {
     Base::finishCreation(vm);
     reifyStaticProperties(vm, JSDOMURL::info(), JSDOMURLPrototypeTableValues, *this);
+    Bun::WebStreams::installInspectCustom(vm, this, jsDOMURLPrototypeFunction_inspectCustom);
     JSC_TO_STRING_TAG_WITHOUT_TRANSITION();
 }
 
@@ -614,6 +622,167 @@ JSC_DEFINE_CUSTOM_GETTER(jsDOMURL_searchParams, (JSGlobalObject * lexicalGlobalO
     return IDLAttribute<JSDOMURL>::get<jsDOMURL_searchParamsGetter, CastedThisErrorBehavior::Assert>(*lexicalGlobalObject, thisValue, attributeName);
 }
 
+static inline unsigned jsDOMURLSchemeType(const String& protocol)
+{
+    if (protocol == "http:"_s)
+        return 0;
+    if (protocol == "https:"_s)
+        return 2;
+    if (protocol == "ws:"_s)
+        return 3;
+    if (protocol == "ftp:"_s)
+        return 4;
+    if (protocol == "wss:"_s)
+        return 5;
+    if (protocol == "file:"_s)
+        return 6;
+    return 1;
+}
+
+static constexpr uint32_t kURLContextOmittedComponent = 4294967295u;
+
+static JSC_DECLARE_HOST_FUNCTION(jsDOMURLContextNoop);
+JSC_DEFINE_HOST_FUNCTION(jsDOMURLContextNoop, (JSGlobalObject*, CallFrame*))
+{
+    return JSValue::encode(jsUndefined());
+}
+
+#define DEFINE_URL_CONTEXT_HAS_GETTER(name, field)                                                                           \
+    static JSC_DECLARE_HOST_FUNCTION(jsDOMURLContext##name);                                                                 \
+    JSC_DEFINE_HOST_FUNCTION(jsDOMURLContext##name, (JSGlobalObject * globalObject, CallFrame * callFrame))                  \
+    {                                                                                                                        \
+        auto& vm = JSC::getVM(globalObject);                                                                                 \
+        JSObject* thisObj = callFrame->thisValue().getObject();                                                              \
+        if (!thisObj)                                                                                                        \
+            return JSValue::encode(jsBoolean(false));                                                                        \
+        JSValue v = thisObj->getDirect(vm, Identifier::fromString(vm, field##_s));                                           \
+        return JSValue::encode(jsBoolean(v.isNumber() && v.asNumber() != static_cast<double>(kURLContextOmittedComponent))); \
+    }
+DEFINE_URL_CONTEXT_HAS_GETTER(HasPort, "port")
+DEFINE_URL_CONTEXT_HAS_GETTER(HasSearch, "search_start")
+DEFINE_URL_CONTEXT_HAS_GETTER(HasHash, "hash_start")
+#undef DEFINE_URL_CONTEXT_HAS_GETTER
+
+// Node's URLContext (lib/internal/url.js): ada's uint32 component offsets into
+// the href, reconstructed so util.inspect(url, { showHidden: true }) matches.
+static JSObject* jsDOMURLMakeURLContext(JSGlobalObject* lexicalGlobalObject, DOMURL& impl)
+{
+    auto& vm = JSC::getVM(lexicalGlobalObject);
+    constexpr uint32_t kOmittedComponent = kURLContextOmittedComponent;
+
+    const String href = impl.href().string();
+    const String protocol = impl.protocol();
+    const String username = impl.username();
+    const String password = impl.password();
+    const String hostname = impl.hostname();
+    const String portStr = impl.port();
+    const String pathname = impl.pathname();
+    const String search = impl.search();
+    const String hash = impl.hash();
+
+    unsigned protocolEnd = protocol.length();
+    bool hasSlashes = StringView(href).substring(protocolEnd).startsWith("//"_s);
+    unsigned authorityStart = protocolEnd + (hasSlashes ? 2 : 0);
+    bool hasCredentials = !username.isEmpty() || !password.isEmpty();
+    unsigned position = authorityStart + username.length();
+    unsigned usernameEnd = position;
+    if (!password.isEmpty())
+        position += 1 + password.length();
+    unsigned hostStart = position;
+    unsigned hostEnd = position + (hasCredentials ? 1 : 0) + hostname.length();
+    uint32_t portNumber = portStr.isEmpty() ? kOmittedComponent : WTF::parseInteger<uint32_t>(portStr).value_or(kOmittedComponent);
+    unsigned pathnameStart = hostEnd + (portStr.isEmpty() ? 0 : 1 + portStr.length());
+    // URL Standard section 4.5 step 3: null host + empty first path segment
+    // serializes with a /. guard that the pathname getter omits, shifting
+    // everything from the pathname on by 2.
+    if (!hasSlashes && pathname.startsWith("//"_s) && StringView(href).substring(protocolEnd).startsWith("/."_s))
+        pathnameStart += 2;
+    unsigned pathnameEnd = pathnameStart + pathname.length();
+    // .search/.hash return "" for both a null and an empty-string component,
+    // but the href serializer emits the bare "?"/"#" for empty-but-present;
+    // derive presence from the href (a raw '?'/'#' is always the delimiter
+    // there) so the offsets match ada's.
+    size_t hashAt = href.find('#');
+    uint32_t hashStart = hashAt == notFound ? kOmittedComponent : static_cast<uint32_t>(hashAt);
+    size_t queryEnd = hashAt == notFound ? href.length() : hashAt;
+    uint32_t searchStart = (queryEnd > pathnameEnd && href[pathnameEnd] == '?') ? pathnameEnd : kOmittedComponent;
+
+    // inspect() prints `URLContext { ... }` via getConstructorName, which
+    // requires `ctx instanceof ctor`, so ctor.prototype must be the object
+    // actually in ctx's prototype chain (matching node's class shape).
+    JSObject* proto = constructEmptyObject(lexicalGlobalObject);
+    JSFunction* ctor = JSFunction::create(vm, lexicalGlobalObject, 0, "URLContext"_s, jsDOMURLContextNoop, ImplementationVisibility::Public);
+    ctor->putDirect(vm, vm.propertyNames->prototype, proto, JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::DontDelete | JSC::PropertyAttribute::ReadOnly);
+    proto->putDirect(vm, vm.propertyNames->constructor, ctor, JSC::PropertyAttribute::DontEnum | 0);
+
+    JSObject* ctx = constructEmptyObject(lexicalGlobalObject, proto);
+    ctx->putDirect(vm, Identifier::fromString(vm, "href"_s), jsString(vm, href), 0);
+    ctx->putDirect(vm, Identifier::fromString(vm, "protocol_end"_s), jsNumber(protocolEnd), 0);
+    ctx->putDirect(vm, Identifier::fromString(vm, "username_end"_s), jsNumber(usernameEnd), 0);
+    ctx->putDirect(vm, Identifier::fromString(vm, "host_start"_s), jsNumber(hostStart), 0);
+    ctx->putDirect(vm, Identifier::fromString(vm, "host_end"_s), jsNumber(hostEnd), 0);
+    ctx->putDirect(vm, Identifier::fromString(vm, "pathname_start"_s), jsNumber(pathnameStart), 0);
+    ctx->putDirect(vm, Identifier::fromString(vm, "search_start"_s), jsNumber(searchStart), 0);
+    ctx->putDirect(vm, Identifier::fromString(vm, "hash_start"_s), jsNumber(hashStart), 0);
+    ctx->putDirect(vm, Identifier::fromString(vm, "port"_s), jsNumber(portNumber), 0);
+    ctx->putDirect(vm, Identifier::fromString(vm, "scheme_type"_s), jsNumber(jsDOMURLSchemeType(protocol)), 0);
+
+    // Node's URLContext exposes hasPort/hasSearch/hasHash as prototype
+    // getters; showHidden reveals them as `[hasPort]: [Getter]`.
+    const unsigned getterAttrs = JSC::PropertyAttribute::DontEnum | JSC::PropertyAttribute::Accessor;
+    auto addGetter = [&](ASCIILiteral name, JSC::NativeFunction impl) {
+        JSFunction* getter = JSFunction::create(vm, lexicalGlobalObject, 0, makeString("get "_s, name), impl, ImplementationVisibility::Public);
+        proto->putDirectAccessor(lexicalGlobalObject, Identifier::fromString(vm, name), JSC::GetterSetter::create(vm, lexicalGlobalObject, getter, nullptr), getterAttrs);
+    };
+    addGetter("hasPort"_s, jsDOMURLContextHasPort);
+    addGetter("hasSearch"_s, jsDOMURLContextHasSearch);
+    addGetter("hasHash"_s, jsDOMURLContextHasHash);
+    return ctx;
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsDOMURLPrototypeFunction_inspectCustom, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+{
+    auto& vm = JSC::getVM(lexicalGlobalObject);
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    JSValue thisValue = callFrame->thisValue();
+    auto* thisObject = dynamicDowncast<JSDOMURL>(thisValue);
+    if (!thisObject) [[unlikely]]
+        return JSValue::encode(thisValue);
+
+    auto& impl = thisObject->wrapped();
+    JSObject* data = constructEmptyObject(lexicalGlobalObject);
+    data->putDirect(vm, Identifier::fromString(vm, "href"_s), jsString(vm, impl.href().string()), 0);
+    data->putDirect(vm, Identifier::fromString(vm, "origin"_s), jsString(vm, impl.origin()), 0);
+    data->putDirect(vm, Identifier::fromString(vm, "protocol"_s), jsString(vm, impl.protocol()), 0);
+    data->putDirect(vm, Identifier::fromString(vm, "username"_s), jsString(vm, impl.username()), 0);
+    data->putDirect(vm, Identifier::fromString(vm, "password"_s), jsString(vm, impl.password()), 0);
+    data->putDirect(vm, Identifier::fromString(vm, "host"_s), jsString(vm, impl.host()), 0);
+    data->putDirect(vm, Identifier::fromString(vm, "hostname"_s), jsString(vm, impl.hostname()), 0);
+    data->putDirect(vm, Identifier::fromString(vm, "port"_s), jsString(vm, impl.port()), 0);
+    data->putDirect(vm, Identifier::fromString(vm, "pathname"_s), jsString(vm, impl.pathname()), 0);
+    data->putDirect(vm, Identifier::fromString(vm, "search"_s), jsString(vm, impl.search()), 0);
+
+    JSValue searchParams = jsDOMURL_searchParamsGetter(*lexicalGlobalObject, *thisObject);
+    RETURN_IF_EXCEPTION(scope, {});
+    data->putDirect(vm, Identifier::fromString(vm, "searchParams"_s), searchParams, 0);
+
+    data->putDirect(vm, Identifier::fromString(vm, "hash"_s), jsString(vm, impl.hash()), 0);
+
+    JSValue optionsValue = callFrame->argument(1);
+    if (optionsValue.isObject()) {
+        JSValue showHidden = asObject(optionsValue)->get(lexicalGlobalObject, Identifier::fromString(vm, "showHidden"_s));
+        RETURN_IF_EXCEPTION(scope, {});
+        if (showHidden.toBoolean(lexicalGlobalObject)) {
+            auto* contextSymbol = JSC::Symbol::createWithDescription(vm, "context"_s);
+            data->putDirect(vm, Identifier::fromUid(contextSymbol->privateName()), jsDOMURLMakeURLContext(lexicalGlobalObject, impl), 0);
+        }
+    }
+
+    auto name = Bun::WebStreams::constructorNameOf(lexicalGlobalObject, thisValue, "URL"_s);
+    RETURN_IF_EXCEPTION(scope, {});
+    RELEASE_AND_RETURN(scope, Bun::WebStreams::customInspect(lexicalGlobalObject, callFrame, thisValue, name, data));
+}
+
 static inline JSC::EncodedJSValue jsDOMURLConstructorFunction_parseBody(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame)
 {
     auto& vm = JSC::getVM(lexicalGlobalObject);
diff --git a/src/jsc/bindings/webcore/JSURLSearchParams.cpp b/src/jsc/bindings/webcore/JSURLSearchParams.cpp
index 99aa77f0fab6..5ca282a071f0 100644
--- a/src/jsc/bindings/webcore/JSURLSearchParams.cpp
+++ b/src/jsc/bindings/webcore/JSURLSearchParams.cpp
@@ -46,14 +46,20 @@
 #include <JavaScriptCore/JSArray.h>
 
 #include <JavaScriptCore/JSDestructibleObjectHeapCellType.h>
+#include <JavaScriptCore/ObjectConstructor.h>
+#include <JavaScriptCore/PropertyNameArray.h>
 #include <JavaScriptCore/SlotVisitorMacros.h>
 #include <JavaScriptCore/SubspaceInlines.h>
 #include "ScriptExecutionContext.h"
 #include "WebCoreJSClientData.h"
+#include "ZigGlobalObject.h"
+#include "streams/WebStreamsInspectCustom.h"
 #include <wtf/GetPtr.h>
 #include <wtf/PointerPreparations.h>
 #include <wtf/URL.h>
 #include <wtf/Vector.h>
+#include <wtf/text/MakeString.h>
+#include <wtf/text/StringBuilder.h>
 #include <variant>
 #include "GCDefferalContext.h"
 #include "wtf/StdLibExtras.h"
@@ -76,6 +82,7 @@ static JSC_DECLARE_HOST_FUNCTION(jsURLSearchParamsPrototypeFunction_keys);
 static JSC_DECLARE_HOST_FUNCTION(jsURLSearchParamsPrototypeFunction_values);
 static JSC_DECLARE_HOST_FUNCTION(jsURLSearchParamsPrototypeFunction_forEach);
 static JSC_DECLARE_HOST_FUNCTION(jsURLSearchParamsPrototypeFunction_toString);
+static JSC_DECLARE_HOST_FUNCTION(jsURLSearchParamsPrototypeFunction_inspectCustom);
 
 // Attributes
 
@@ -187,11 +194,145 @@ static const HashTableValue JSURLSearchParamsPrototypeTableValues[] = {
 
 const ClassInfo JSURLSearchParamsPrototype::s_info = { "URLSearchParams"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSURLSearchParamsPrototype) };
 
+JSC_DEFINE_HOST_FUNCTION(jsURLSearchParamsPrototypeFunction_inspectCustom, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+{
+    auto& vm = JSC::getVM(lexicalGlobalObject);
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    JSValue thisValue = callFrame->thisValue();
+    auto* thisObject = dynamicDowncast<JSURLSearchParams>(thisValue);
+    if (!thisObject) [[unlikely]]
+        return JSValue::encode(thisValue);
+
+    JSValue depthValue = callFrame->argument(0);
+    JSValue optionsValue = callFrame->argument(1);
+
+    double depth = depthValue.toNumber(lexicalGlobalObject);
+    RETURN_IF_EXCEPTION(scope, {});
+
+    JSObject* options = optionsValue.isObject() ? asObject(optionsValue) : nullptr;
+    if (depth < 0) {
+        if (options) {
+            JSValue stylize = options->get(lexicalGlobalObject, Identifier::fromString(vm, "stylize"_s));
+            RETURN_IF_EXCEPTION(scope, {});
+            auto callData = JSC::getCallData(stylize);
+            if (callData.type != CallData::Type::None) {
+                MarkedArgumentBuffer args;
+                args.append(jsNontrivialString(vm, "[Object]"_s));
+                args.append(jsNontrivialString(vm, "special"_s));
+                ASSERT(!args.hasOverflowed());
+                RELEASE_AND_RETURN(scope, JSValue::encode(JSC::profiledCall(lexicalGlobalObject, ProfilingReason::API, stylize, callData, optionsValue, args)));
+            }
+        }
+        return JSValue::encode(jsNontrivialString(vm, "[Object]"_s));
+    }
+
+    JSObject* opts = constructEmptyObject(lexicalGlobalObject);
+    JSValue childDepth = jsNull();
+    if (options) {
+        PropertyNameArrayBuilder names(vm, PropertyNameMode::StringsAndSymbols, PrivateSymbolMode::Exclude);
+        options->getPropertyNames(lexicalGlobalObject, names, DontEnumPropertiesMode::Exclude);
+        RETURN_IF_EXCEPTION(scope, {});
+        for (size_t i = 0; i < names.size(); ++i) {
+            JSValue v = options->get(lexicalGlobalObject, names[i]);
+            RETURN_IF_EXCEPTION(scope, {});
+            opts->putDirect(vm, names[i], v, 0);
+        }
+        if (!depthValue.isUndefinedOrNull())
+            childDepth = jsNumber(depth - 1);
+    }
+    opts->putDirect(vm, Identifier::fromString(vm, "depth"_s), childDepth, 0);
+
+    auto* globalObject = defaultGlobalObject(lexicalGlobalObject);
+    JSFunction* utilInspect = globalObject->utilInspectFunction();
+    RETURN_IF_EXCEPTION(scope, {});
+    auto inspectCallData = JSC::getCallData(utilInspect);
+
+    // node measures removeColors(output[i]).length before comparing to
+    // breakLength, so ANSI escapes (ESC[ ... letter) don't count towards the
+    // single/multi-line layout decision.
+    auto visibleLengthOf = [](const String& s) -> size_t {
+        StringView view { s };
+        size_t count = 0;
+        for (unsigned i = 0; i < view.length();) {
+            char16_t c = view[i];
+            if (c == 0x1B && i + 1 < view.length() && view[i + 1] == '[') {
+                i += 2;
+                while (i < view.length()) {
+                    char16_t t = view[i++];
+                    if ((t >= 'A' && t <= 'Z') || (t >= 'a' && t <= 'z'))
+                        break;
+                }
+                continue;
+            }
+            count++;
+            i++;
+        }
+        return count;
+    };
+
+    auto& impl = thisObject->wrapped();
+    auto iter = impl.createIterator();
+    Vector<String> output;
+    size_t totalLength = 0;
+    for (auto entry = iter.next(); entry.has_value(); entry = iter.next()) {
+        MarkedArgumentBuffer keyArgs;
+        keyArgs.append(jsString(vm, entry.value().key));
+        keyArgs.append(opts);
+        ASSERT(!keyArgs.hasOverflowed());
+        JSValue keyInspected = JSC::profiledCall(lexicalGlobalObject, ProfilingReason::API, utilInspect, inspectCallData, jsUndefined(), keyArgs);
+        RETURN_IF_EXCEPTION(scope, {});
+        auto keyStr = keyInspected.toWTFString(lexicalGlobalObject);
+        RETURN_IF_EXCEPTION(scope, {});
+
+        MarkedArgumentBuffer valueArgs;
+        valueArgs.append(jsString(vm, entry.value().value));
+        valueArgs.append(opts);
+        ASSERT(!valueArgs.hasOverflowed());
+        JSValue valueInspected = JSC::profiledCall(lexicalGlobalObject, ProfilingReason::API, utilInspect, inspectCallData, jsUndefined(), valueArgs);
+        RETURN_IF_EXCEPTION(scope, {});
+        auto valueStr = valueInspected.toWTFString(lexicalGlobalObject);
+        RETURN_IF_EXCEPTION(scope, {});
+
+        auto line = makeString(keyStr, " => "_s, valueStr);
+        totalLength += visibleLengthOf(line);
+        output.append(WTF::move(line));
+    }
+    if (output.size() > 1)
+        totalLength += (output.size() - 1) * 2;
+
+    double breakLength = 128;
+    if (options) {
+        JSValue breakLengthValue = options->get(lexicalGlobalObject, Identifier::fromString(vm, "breakLength"_s));
+        RETURN_IF_EXCEPTION(scope, {});
+        if (breakLengthValue.isNumber())
+            breakLength = breakLengthValue.asNumber();
+    }
+
+    auto name = Bun::WebStreams::constructorNameOf(lexicalGlobalObject, thisValue, "URLSearchParams"_s);
+    RETURN_IF_EXCEPTION(scope, {});
+    if (output.isEmpty())
+        return JSValue::encode(jsString(vm, makeString(name, " {}"_s)));
+
+    const bool multiLine = static_cast<double>(totalLength) > breakLength;
+    StringBuilder builder;
+    builder.append(name);
+    builder.append(multiLine ? " {\n  "_s : " { "_s);
+    ASCIILiteral separator = multiLine ? ",\n  "_s : ", "_s;
+    for (size_t i = 0; i < output.size(); ++i) {
+        if (i)
+            builder.append(separator);
+        builder.append(output[i]);
+    }
+    builder.append(" }"_s);
+    return JSValue::encode(jsString(vm, builder.toString()));
+}
+
 void JSURLSearchParamsPrototype::finishCreation(VM& vm)
 {
     Base::finishCreation(vm);
     reifyStaticProperties(vm, JSURLSearchParams::info(), JSURLSearchParamsPrototypeTableValues, *this);
     putDirect(vm, vm.propertyNames->iteratorSymbol, getDirect(vm, vm.propertyNames->builtinNames().entriesPublicName()), static_cast<unsigned>(JSC::PropertyAttribute::DontEnum));
+    Bun::WebStreams::installInspectCustom(vm, this, jsURLSearchParamsPrototypeFunction_inspectCustom);
     JSC_TO_STRING_TAG_WITHOUT_TRANSITION();
 }
 
diff --git a/src/jsc/bindings/webcore/StructuredClone.cpp b/src/jsc/bindings/webcore/StructuredClone.cpp
index 56e0b0fd6f95..40c7e7af9de3 100644
--- a/src/jsc/bindings/webcore/StructuredClone.cpp
+++ b/src/jsc/bindings/webcore/StructuredClone.cpp
@@ -57,7 +57,11 @@ JSC_DEFINE_HOST_FUNCTION(jsFunctionStructuredClone, (JSC::JSGlobalObject * globa
     RETURN_IF_EXCEPTION(throwScope, {});
 
     Vector<RefPtr<MessagePort>> ports;
-    ExceptionOr<Ref<SerializedScriptValue>> serialized = SerializedScriptValue::create(*globalObject, value, WTF::move(serializeOptions.transfer), ports);
+    // structuredClone never leaves this agent cluster, so SABs may share their backing store per
+    // https://html.spec.whatwg.org/multipage/structured-data.html#structuredserializeinternal —
+    // only the WorkerPostMessage context takes the SAB-sharing path; Default would copy to a plain AB.
+    ExceptionOr<Ref<SerializedScriptValue>> serialized = SerializedScriptValue::create(*globalObject, value, WTF::move(serializeOptions.transfer), ports,
+        SerializationForStorage::No, SerializationContext::WorkerPostMessage);
     if (serialized.hasException()) {
         WebCore::propagateException(*globalObject, throwScope, serialized.releaseException());
         RELEASE_AND_RETURN(throwScope, {});
diff --git a/src/jsc/bindings/webcore/streams/WebStreamsInspectCustom.cpp b/src/jsc/bindings/webcore/streams/WebStreamsInspectCustom.cpp
index a253a35afa8a..1712b7b22025 100644
--- a/src/jsc/bindings/webcore/streams/WebStreamsInspectCustom.cpp
+++ b/src/jsc/bindings/webcore/streams/WebStreamsInspectCustom.cpp
@@ -14,6 +14,11 @@ namespace WebStreams {
 using namespace JSC;
 
 EncodedJSValue customInspect(JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame, JSValue thisValue, ASCIILiteral name, JSObject* data)
+{
+    return customInspect(lexicalGlobalObject, callFrame, thisValue, WTF::String(name), data);
+}
+
+EncodedJSValue customInspect(JSGlobalObject* lexicalGlobalObject, CallFrame* callFrame, JSValue thisValue, const WTF::String& name, JSObject* data)
 {
     auto& vm = JSC::getVM(lexicalGlobalObject);
     auto scope = DECLARE_THROW_SCOPE(vm);
@@ -26,7 +31,6 @@ EncodedJSValue customInspect(JSGlobalObject* lexicalGlobalObject, CallFrame* cal
     if (depth < 0)
         return JSValue::encode(thisValue);
 
-    // opts = { ...options, depth: options.depth == null ? null : options.depth - 1 }
     JSObject* opts = constructEmptyObject(lexicalGlobalObject);
     JSValue childDepth = jsNull();
     if (optionsValue.isObject()) {
@@ -69,6 +73,38 @@ EncodedJSValue customInspect(JSGlobalObject* lexicalGlobalObject, CallFrame* cal
     return JSValue::encode(jsString(vm, makeString(name, " "_s, view.data)));
 }
 
+WTF::String constructorNameOf(JSGlobalObject* lexicalGlobalObject, JSValue thisValue, ASCIILiteral fallback)
+{
+    auto& vm = JSC::getVM(lexicalGlobalObject);
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    JSObject* obj = thisValue.getObject();
+    while (obj) {
+        PropertySlot slot(obj, PropertySlot::InternalMethodType::GetOwnProperty);
+        bool has = obj->methodTable()->getOwnPropertySlot(obj, lexicalGlobalObject, vm.propertyNames->constructor, slot);
+        RETURN_IF_EXCEPTION(scope, fallback);
+        if (has) {
+            JSValue ctorValue = slot.getValue(lexicalGlobalObject, vm.propertyNames->constructor);
+            RETURN_IF_EXCEPTION(scope, fallback);
+            if (!ctorValue.isEmpty() && ctorValue.isCallable()) {
+                JSValue nameValue = ctorValue.get(lexicalGlobalObject, vm.propertyNames->name);
+                RETURN_IF_EXCEPTION(scope, fallback);
+                if (!nameValue.isEmpty() && nameValue.isString()) {
+                    String name = asString(nameValue)->value(lexicalGlobalObject);
+                    RETURN_IF_EXCEPTION(scope, fallback);
+                    if (!name.isEmpty())
+                        return name;
+                }
+            }
+        }
+        JSValue proto = obj->getPrototype(lexicalGlobalObject);
+        RETURN_IF_EXCEPTION(scope, fallback);
+        if (proto.isEmpty())
+            break;
+        obj = proto.getObject();
+    }
+    return fallback;
+}
+
 void installInspectCustom(VM& vm, JSObject* prototype, NativeFunction nativeFunction)
 {
     auto* globalObject = prototype->globalObject();
diff --git a/src/jsc/bindings/webcore/streams/WebStreamsInspectCustom.h b/src/jsc/bindings/webcore/streams/WebStreamsInspectCustom.h
index 24665c3adce6..34f9a04d4de1 100644
--- a/src/jsc/bindings/webcore/streams/WebStreamsInspectCustom.h
+++ b/src/jsc/bindings/webcore/streams/WebStreamsInspectCustom.h
@@ -13,6 +13,11 @@ namespace WebStreams {
 // Node's `customInspect(depth, options, name, data)` (lib/internal/webstreams/util.js):
 // depth < 0 returns `thisValue`; otherwise `${name} ${inspect(data, {...options, depth-1})}`.
 JSC::EncodedJSValue customInspect(JSC::JSGlobalObject*, JSC::CallFrame*, JSC::JSValue thisValue, ASCIILiteral name, JSC::JSObject* data);
+// Same, with a runtime-computed class name (subclass-aware inspectors).
+JSC::EncodedJSValue customInspect(JSC::JSGlobalObject*, JSC::CallFrame*, JSC::JSValue thisValue, const WTF::String& name, JSC::JSObject* data);
+// getConstructorOf(obj).name (node lib/internal/util.js) with `fallback` when
+// no named constructor is found on the prototype chain.
+WTF::String constructorNameOf(JSC::JSGlobalObject*, JSC::JSValue thisValue, ASCIILiteral fallback);
 
 // Installs the host function on a prototype under Symbol.for("nodejs.util.inspect.custom").
 void installInspectCustom(JSC::VM&, JSC::JSObject* prototype, JSC::NativeFunction);
diff --git a/src/jsc/event_loop.rs b/src/jsc/event_loop.rs
index 29fc3082309f..14ecee8fafa0 100644
--- a/src/jsc/event_loop.rs
+++ b/src/jsc/event_loop.rs
@@ -10,7 +10,7 @@
 //! poll deadline). See PORTING.md §Dispatch.
 
 use core::ptr::NonNull;
-use core::sync::atomic::{AtomicI32, AtomicPtr, Ordering};
+use core::sync::atomic::{AtomicI32, AtomicPtr, AtomicU32, Ordering};
 
 use bun_io::{self as Async, Waker};
 use bun_uws as uws;
@@ -88,6 +88,10 @@ pub struct EventLoop {
 
     pub entered_event_loop_count: isize,
     pub concurrent_ref: AtomicI32,
+    /// Work-pool tasks that will post to `concurrent_tasks` when they finish (counted on the JS
+    /// thread before hand-off, decremented on the pool thread after the post). Shutdown waits for
+    /// zero before the final queue drain so a completion can't land after it and leak.
+    pub concurrent_posters: AtomicU32,
     /// Atomic nullable pointer to the next-due `WTFTimer`.
     ///
     /// Note (§Dispatch): payload is `*mut ()` — the real
@@ -128,6 +132,7 @@ impl Default for EventLoop {
             uws_loop: (),
             entered_event_loop_count: 0,
             concurrent_ref: AtomicI32::new(0),
+            concurrent_posters: AtomicU32::new(0),
             imminent_gc_timer: AtomicPtr::new(core::ptr::null_mut()),
             #[cfg(unix)]
             signal_handler: None,
@@ -1005,6 +1010,29 @@ impl EventLoop {
         self.wakeup();
     }
 
+    /// See `concurrent_posters`. Call on the JS thread before scheduling a
+    /// work-pool task whose completion posts via `enqueue_task_concurrent`.
+    pub fn concurrent_poster_begin(&self) {
+        let _ = self.concurrent_posters.fetch_add(1, Ordering::SeqCst);
+    }
+
+    /// Pool-thread pair of [`Self::concurrent_poster_begin`]. Must be the
+    /// poster's last touch of this event loop: once the count hits zero the
+    /// shutdown thread may drain the queue and tear the VM down.
+    pub fn concurrent_poster_end(&self) {
+        let prev = self.concurrent_posters.fetch_sub(1, Ordering::Release);
+        debug_assert!(prev > 0);
+    }
+
+    /// Spin until every counted poster has finished its post. Called on the JS thread during
+    /// shutdown, after the last JS has run and before the final queue drain. Each pending fs
+    /// operation is finite, so the wait is bounded by syscall latency.
+    pub fn wait_for_concurrent_posters(&self) {
+        while self.concurrent_posters.load(Ordering::Acquire) > 0 {
+            std::thread::yield_now();
+        }
+    }
+
     pub fn ref_concurrently(&self) {
         let _ = self.concurrent_ref.fetch_add(1, Ordering::SeqCst);
         self.wakeup();
@@ -1315,6 +1343,7 @@ bun_event_loop::link_impl_JsEventLoop! {
         exit() => (*this).exit(),
         enqueue_task(task) => (*this).enqueue_task(task),
         enqueue_task_concurrent(task) => (*this).enqueue_task_concurrent(task),
+        concurrent_poster_end() => (*this).concurrent_poster_end(),
         env() => (*this).vm_ref().transpiler.env,
         top_level_dir() => core::ptr::from_ref::<[u8]>((*this).vm_ref().top_level_dir()),
         create_null_delimited_env_map() =>
diff --git a/src/jsc/hot_reloader.rs b/src/jsc/hot_reloader.rs
index f287ca762600..41c1d0c74052 100644
--- a/src/jsc/hot_reloader.rs
+++ b/src/jsc/hot_reloader.rs
@@ -207,6 +207,9 @@ impl HotReloaderCtx for VirtualMachine {
 /// The dyn trait below is the type-erased view used by
 /// `HotReloaderCtx::reload`.
 pub type HotReloadTask = Task<VirtualMachine, EventLoop, false>;
+/// `bun run --watch` reload routed through the event loop (only when
+/// `--watch-kill-signal` listeners exist; see `Task::enqueue`).
+pub type WatchReloadTask = Task<VirtualMachine, EventLoop, true>;
 
 /// Trait bound on `Ctx` exposing the operations the reloader needs.
 /// Implemented by `VirtualMachine` and `bun.bake.DevServer`.
@@ -276,10 +279,9 @@ impl HotReloaderEventLoop for EventLoop {
     }
 }
 
-/// `bun build --watch` instantiates `NewHotReloader<BundleV2, AnyEventLoop, true>`.
-/// With `RELOAD_IMMEDIATELY = true`, `Task::enqueue` diverges via
-/// `bun_core::reload_process()` before any concurrent task is enqueued, so
-/// this is never reached.
+/// `bun build --watch` instantiates `NewHotReloader<BundleV2, AnyEventLoop, true>`. With
+/// `RELOAD_IMMEDIATELY = true`, `Task::enqueue` either diverges or takes the kill-signal branch —
+/// the latter needs `watch_kill_signal_has_listeners()`, never true here, so this is never reached.
 impl HotReloaderEventLoop for bun_event_loop::AnyEventLoop {
     fn enqueue_task_concurrent(_this: &Self, _task: core::ptr::NonNull<ConcurrentTask>) {
         unreachable!()
@@ -613,7 +615,11 @@ where
             return;
         }
 
-        if RELOAD_IMMEDIATELY {
+        // With --watch-kill-signal listeners registered, reload via the event
+        // loop so the JS thread emits them before execve (node runs the child's
+        // handlers on kill); otherwise execve immediately (node's default kill).
+        if RELOAD_IMMEDIATELY && !crate::posix_signal_handle::watch_kill_signal_has_listeners() {
+            crate::node_compile_cache::persist_now();
             Output::flush();
             flush_changed_paths_for_reload();
             bun_core::reload_process(
@@ -638,16 +644,18 @@ where
             // Note: `JscTask::init` requires `Taskable`, but const-generic
             // `Task<Ctx, _, _>` can't implement it (one tag per monomorphization).
             // Use the raw `(tag, ptr)` constructor.
+            let tag = if RELOAD_IMMEDIATELY {
+                task_tag::WatchReloadTask
+            } else {
+                task_tag::HotReloadTask
+            };
             let concurrent = (*that).concurrent_task.insert(ConcurrentTask {
-                task: JscTask::new(task_tag::HotReloadTask, that.cast::<()>()),
+                task: JscTask::new(tag, that.cast::<()>()),
                 ..Default::default()
             });
-            // `&that.concurrent_task` is an interior pointer into a
-            // Box-allocated Task; the event loop must not outlive `that`.
-            //
-            // Inlines `NewHotReloader::enqueue_task_concurrent` to avoid forming
-            // a whole-struct `&NewHotReloader` (see `Self::pending_count` doc).
-            // `RELOAD_IMMEDIATELY` already diverged above so its guard is dead here.
+            // `&that.concurrent_task` is interior to a Box-allocated Task; the loop must not
+            // outlive `that`. Inlines `enqueue_task_concurrent` to avoid forming a whole-struct
+            // `&NewHotReloader`. BundleV2/AnyEventLoop reach here only with RELOAD_IMMEDIATELY=false.
             let ctx = self.ctx_ptr();
             // SAFETY: ctx outlives reloader (BACKREF); `event_loop()` returns
             // the live event-loop pointer owned by `Ctx`.
@@ -658,6 +666,73 @@ where
             );
         }
         self.count = 0;
+
+        // The JS thread emits kill-signal listeners then execve; if it's stuck in sync code it
+        // never drains the posted task. Arm a one-shot timer that forces the reload after a
+        // bounded window (node's watcher SIGKILLs an unresponsive child after its grace period).
+        if RELOAD_IMMEDIATELY {
+            arm_watch_reload_grace_timer();
+        }
+    }
+}
+
+static WATCH_RELOAD_GRACE_ARMED: core::sync::atomic::AtomicBool =
+    core::sync::atomic::AtomicBool::new(false);
+
+fn arm_watch_reload_grace_timer() {
+    if WATCH_RELOAD_GRACE_ARMED.load(core::sync::atomic::Ordering::Relaxed) {
+        return;
+    }
+    let reload_started = bun_core::is_process_reload_in_progress_on_another_thread;
+    let handler_running = crate::posix_signal_handle::is_emitting_watch_kill_signal;
+    let force = || -> ! {
+        // Same as the sibling reload paths: execve never reaches on_exit, so
+        // flush the compile cache first (safe off the JS thread; generation
+        // runs on its own worker VM).
+        crate::node_compile_cache::persist_now();
+        Output::flush();
+        bun_core::reload_process(
+            CLEAR_SCREEN.load(core::sync::atomic::Ordering::Relaxed),
+            false,
+        );
+        unreachable!();
+    };
+    let spawned = std::thread::Builder::new()
+        .name("WatchReloadGrace".into())
+        .spawn(move || {
+            const STEP_MS: u64 = 10;
+            // Budget to drain the posted WatchReloadTask; extended once when
+            // the kill-signal emit is observed so a bounded synchronous
+            // handler has time to finish before being torn down mid-run.
+            const DRAIN_MS: u64 = 500;
+            const HANDLER_MS: u64 = 2000;
+            let mut deadline = DRAIN_MS;
+            let mut extended = false;
+            let mut waited = 0u64;
+            while waited < deadline {
+                if reload_started() {
+                    // execve prep has begun; park until it tears this thread down.
+                    loop {
+                        std::thread::sleep(std::time::Duration::from_secs(3600));
+                    }
+                }
+                if !extended && handler_running() {
+                    deadline = waited + HANDLER_MS;
+                    extended = true;
+                }
+                std::thread::sleep(std::time::Duration::from_millis(STEP_MS));
+                waited += STEP_MS;
+            }
+            // Deadline hit without reload_process starting: either the task
+            // never drained, or the handler itself is wedged. Force it (node
+            // SIGKILLs the child after its own grace period either way).
+            force();
+        })
+        .is_ok();
+    if spawned {
+        WATCH_RELOAD_GRACE_ARMED.store(true, core::sync::atomic::Ordering::Relaxed);
+    } else {
+        force();
     }
 }
 
@@ -719,7 +794,12 @@ where
         // SAFETY: `watcher_ptr` was just installed into the ctx and is live.
         if let Err(err) = unsafe { (*watcher_ptr).start() } {
             bun_core::handle_error_return_trace(&err);
-            Output::panic(format_args!("Failed to start File Watcher: {}", err.name()));
+            bun_core::pretty_errorln!(
+                "<red>error<r><d>:<r> Failed to start File Watcher: {}",
+                err.name()
+            );
+            Output::flush();
+            bun_core::Global::exit(1);
         }
     }
 
@@ -1254,13 +1334,15 @@ impl<'a> HotReloaderCtx for bun_bundler::BundleV2<'a> {
     type EventLoop = bun_event_loop::AnyEventLoop;
 
     fn event_loop(&self) -> *mut Self::EventLoop {
-        // With RELOAD_IMMEDIATELY=true the only caller
-        // (`Task::enqueue` post-diverge) is dead code.
+        // With RELOAD_IMMEDIATELY=true the only caller (`Task::enqueue`)
+        // diverges or takes the kill-signal branch first, and BundleV2 never
+        // has kill-signal listeners, so this is dead code.
         unreachable!()
     }
 
     fn event_loop_ref(&self) -> &Self::EventLoop {
-        // See `event_loop` above — dead code under RELOAD_IMMEDIATELY=true.
+        // See `event_loop` above — dead for BundleV2 under
+        // RELOAD_IMMEDIATELY=true (no kill-signal listeners).
         unreachable!()
     }
 
@@ -1275,7 +1357,8 @@ impl<'a> HotReloaderCtx for bun_bundler::BundleV2<'a> {
     }
 
     fn reload(&mut self, _task: &mut dyn HotReloadTaskView) {
-        // RELOAD_IMMEDIATELY=true → `Task::run` is never enqueued.
+        // RELOAD_IMMEDIATELY=true never enqueues `Task::run` for BundleV2
+        // (diverges or kill-signal branch; no listeners registered there).
         unreachable!()
     }
 
diff --git a/src/jsc/lib.rs b/src/jsc/lib.rs
index a4ddb912d61b..36b31ec4878a 100644
--- a/src/jsc/lib.rs
+++ b/src/jsc/lib.rs
@@ -445,6 +445,8 @@ pub mod js_array_iterator;
 pub mod js_global_object;
 #[path = "JSPropertyIterator.rs"]
 pub mod js_property_iterator;
+#[path = "NodeCompileCache.rs"]
+pub mod node_compile_cache;
 #[path = "SystemError.rs"]
 pub mod system_error;
 #[path = "URL.rs"]
diff --git a/src/jsc/modules/NodeBufferModule.cpp b/src/jsc/modules/NodeBufferModule.cpp
new file mode 100644
index 000000000000..2aaf499e3155
--- /dev/null
+++ b/src/jsc/modules/NodeBufferModule.cpp
@@ -0,0 +1,248 @@
+#include "root.h"
+
+#include "BunClientData.h"
+#include "ErrorCode.h"
+#include "JSBufferEncodingType.h"
+#include "JSDOMExceptionHandling.h"
+#include "wtf/SIMDUTF.h"
+#include <JavaScriptCore/JSTypedArrays.h>
+
+namespace WebCore {
+JSC::JSUint8Array* createBuffer(JSC::JSGlobalObject*, std::span<const uint8_t>);
+JSC::JSUint8Array* createEmptyBuffer(JSC::JSGlobalObject*);
+}
+
+using namespace JSC;
+
+namespace {
+
+enum class TranscodeEncoding : uint8_t {
+    Ascii,
+    Latin1,
+    Ucs2,
+    Utf8,
+    Unsupported,
+};
+
+// Mirrors Node's normalizeEncoding() + SupportedEncoding(): every encoding
+// that doesn't resolve to ascii/latin1/ucs2/utf8 (including base64/hex and
+// unknown labels) transcodes as U_ILLEGAL_ARGUMENT_ERROR.
+static TranscodeEncoding parseTranscodeEncoding(const WTF::String& encoding)
+{
+    auto lowered = encoding.convertToASCIILowercase();
+    if (lowered == "utf8"_s || lowered == "utf-8"_s)
+        return TranscodeEncoding::Utf8;
+    if (lowered == "ucs2"_s || lowered == "ucs-2"_s || lowered == "utf16le"_s || lowered == "utf-16le"_s)
+        return TranscodeEncoding::Ucs2;
+    if (lowered == "latin1"_s || lowered == "binary"_s)
+        return TranscodeEncoding::Latin1;
+    if (lowered == "ascii"_s)
+        return TranscodeEncoding::Ascii;
+    return TranscodeEncoding::Unsupported;
+}
+
+// Decode the source bytes into well-formed UTF-16 for the pivot paths.
+static void transcodeDecodeToUtf16(std::span<const uint8_t> input, TranscodeEncoding fromEncoding, bool replaceTrailingOddByte, WTF::Vector<char16_t>& units)
+{
+    const auto* data = reinterpret_cast<const char*>(input.data());
+    switch (fromEncoding) {
+    case TranscodeEncoding::Latin1:
+        units.grow(input.size());
+        (void)simdutf::convert_latin1_to_utf16le(data, input.size(), units.begin());
+        break;
+    case TranscodeEncoding::Ascii: {
+        units.grow(input.size());
+        (void)simdutf::convert_latin1_to_utf16le(data, input.size(), units.begin());
+        // ICU's ascii converter substitutes non-ASCII bytes with U+FFFD;
+        // simdutf has no substituting decode, so fix up only when needed.
+        if (!simdutf::validate_ascii(data, input.size())) {
+            for (auto& unit : units) {
+                if (unit > 0x7F)
+                    unit = 0xFFFD;
+            }
+        }
+        break;
+    }
+    case TranscodeEncoding::Utf8: {
+        // WHATWG-style replacement decode (each maximal ill-formed
+        // subsequence becomes one U+FFFD), via WTF's implementation.
+        auto decoded = WTF::String::fromUTF8ReplacingInvalidSequences(std::span { reinterpret_cast<const char8_t*>(input.data()), input.size() });
+        units.grow(decoded.length());
+        if (decoded.is8Bit())
+            (void)simdutf::convert_latin1_to_utf16le(reinterpret_cast<const char*>(decoded.span8().data()), decoded.length(), units.begin());
+        else
+            memcpy(units.begin(), decoded.span16().data(), decoded.length() * 2);
+        break;
+    }
+    case TranscodeEncoding::Ucs2: {
+        // Lone surrogates are replaced with U+FFFD like ICU's pivot decode;
+        // the trailing odd byte of the source is dropped for narrow targets
+        // (Node floors the char count) but replaced for a ucs2 target.
+        const size_t lengthInChars = input.size() / 2;
+        units.grow(lengthInChars);
+        memcpy(units.begin(), input.data(), lengthInChars * 2);
+        simdutf::to_well_formed_utf16le(units.begin(), lengthInChars, units.begin());
+        if (replaceTrailingOddByte && (input.size() & 1))
+            units.append(0xFFFD);
+        break;
+    }
+    default:
+        RELEASE_ASSERT_NOT_REACHED();
+    }
+}
+
+// Encode well-formed UTF-16 into a single-byte encoding: code points above
+// maxCodePoint become '?', matching ICU's substitution behavior.
+static void transcodeEncodeNarrow(const WTF::Vector<char16_t>& units, char16_t maxCodePoint, WTF::Vector<uint8_t>& out)
+{
+    // Fast path: a latin1 target with in-range contents converts in bulk.
+    if (maxCodePoint == 0xFF) {
+        out.grow(units.size());
+        auto result = simdutf::convert_utf16le_to_latin1_with_errors(units.begin(), units.size(), reinterpret_cast<char*>(out.begin()));
+        if (result.error == simdutf::error_code::SUCCESS)
+            return;
+        out.shrink(0);
+    }
+    // Substitution path: simdutf conversions are strict, so out-of-range
+    // code points ('?' in ICU) are handled per unit. `units` is well-formed,
+    // so a lead surrogate always has its trail: the pair is one code point.
+    for (size_t i = 0; i < units.size(); i++) {
+        const char16_t unit = units[i];
+        if (U16_IS_LEAD(unit)) {
+            out.append('?');
+            i++;
+            continue;
+        }
+        out.append(unit <= maxCodePoint ? static_cast<uint8_t>(unit) : '?');
+    }
+}
+
+} // namespace
+
+BUN_DECLARE_HOST_FUNCTION(jsBufferTranscode);
+
+// Port of Node's buffer.transcode; ICU-converter paths implemented over simdutf (macOS system
+// ICU hides the ucnv API). https://github.com/nodejs/node/blob/main/src/node_i18n.cc
+BUN_DEFINE_HOST_FUNCTION(jsBufferTranscode,
+    (JSGlobalObject * globalObject,
+        CallFrame* callFrame))
+{
+    VM& vm = globalObject->vm();
+    auto scope = DECLARE_THROW_SCOPE(vm);
+
+    JSValue sourceValue = callFrame->argument(0);
+    auto* view = dynamicDowncast<JSC::JSUint8Array>(sourceValue);
+    if (!view)
+        return Bun::ERR::INVALID_ARG_INSTANCE(scope, globalObject, "source"_s, "Buffer or Uint8Array"_s, sourceValue);
+    if (view->isDetached() || view->byteLength() == 0)
+        RELEASE_AND_RETURN(scope, JSValue::encode(WebCore::createEmptyBuffer(globalObject)));
+
+    // Coerce the encodings (which can run user toString) BEFORE snapshotting
+    // the view's pointer/length — the coercion may detach or resize it.
+    // Node's normalizeEncoding maps undefined/null/"" to utf8.
+    auto parseEncodingArgument = [&](JSValue value) -> TranscodeEncoding {
+        if (value.isUndefinedOrNull())
+            return TranscodeEncoding::Utf8;
+        auto string = value.toWTFString(globalObject);
+        if (string.isEmpty())
+            return TranscodeEncoding::Utf8;
+        return parseTranscodeEncoding(string);
+    };
+    const auto fromEncoding = parseEncodingArgument(callFrame->argument(1));
+    RETURN_IF_EXCEPTION(scope, {});
+    const auto toEncoding = parseEncodingArgument(callFrame->argument(2));
+    RETURN_IF_EXCEPTION(scope, {});
+
+    if (view->isDetached()) [[unlikely]]
+        RELEASE_AND_RETURN(scope, JSValue::encode(WebCore::createEmptyBuffer(globalObject)));
+
+    const size_t length = view->byteLength();
+    if (length == 0)
+        RELEASE_AND_RETURN(scope, JSValue::encode(WebCore::createEmptyBuffer(globalObject)));
+
+    const std::span<const uint8_t> input { view->typedVector(), length };
+    const auto* data = reinterpret_cast<const char*>(input.data());
+
+    // Only these two ICU statuses are producible here.
+    constexpr int32_t U_ILLEGAL_ARGUMENT_ERRNO = 1;
+    constexpr int32_t U_INVALID_CHAR_FOUND_ERRNO = 10;
+
+    int32_t errorCode = 0;
+    ASCIILiteral errorName;
+    WTF::Vector<uint8_t> result;
+
+    if (fromEncoding == TranscodeEncoding::Unsupported || toEncoding == TranscodeEncoding::Unsupported) {
+        errorCode = U_ILLEGAL_ARGUMENT_ERRNO;
+        errorName = "U_ILLEGAL_ARGUMENT_ERROR"_s;
+    } else if ((fromEncoding == TranscodeEncoding::Ascii || fromEncoding == TranscodeEncoding::Latin1)
+        && toEncoding == TranscodeEncoding::Ucs2) {
+        // Node's TranscodeLatin1ToUcs2: widen each byte to a UTF-16LE unit
+        // (an ASCII source is treated as latin1 here, matching Node).
+        result.grow(length * 2);
+        // Latin1 -> UTF-16 cannot fail; every byte is a valid code unit.
+        (void)simdutf::convert_latin1_to_utf16le(data, length, reinterpret_cast<char16_t*>(result.begin()));
+    } else if (fromEncoding == TranscodeEncoding::Utf8 && toEncoding == TranscodeEncoding::Ucs2) {
+        // Node's TranscodeUcs2FromUtf8: invalid UTF-8 fails.
+        const size_t expected = simdutf::utf16_length_from_utf8(data, length);
+        result.grow(expected * 2);
+        const size_t actual = simdutf::convert_utf8_to_utf16le(data, length, reinterpret_cast<char16_t*>(result.begin()));
+        if (actual == 0) {
+            errorCode = U_INVALID_CHAR_FOUND_ERRNO;
+            errorName = "U_INVALID_CHAR_FOUND"_s;
+        } else {
+            result.shrink(actual * 2);
+        }
+    } else if (fromEncoding == TranscodeEncoding::Ucs2 && toEncoding == TranscodeEncoding::Utf8) {
+        // Node's TranscodeUtf8FromUcs2: lone surrogates fail; a trailing odd
+        // byte is dropped.
+        const size_t lengthInChars = length / 2;
+        WTF::Vector<char16_t> sourceBuffer(lengthInChars);
+        memcpy(sourceBuffer.begin(), data, lengthInChars * 2);
+        const size_t expected = simdutf::utf8_length_from_utf16le(sourceBuffer.begin(), lengthInChars);
+        result.grow(expected);
+        const size_t actual = simdutf::convert_utf16le_to_utf8(sourceBuffer.begin(), lengthInChars, reinterpret_cast<char*>(result.begin()));
+        if (actual == 0) {
+            errorCode = U_INVALID_CHAR_FOUND_ERRNO;
+            errorName = "U_INVALID_CHAR_FOUND"_s;
+        } else {
+            result.shrink(actual);
+        }
+    } else {
+        // Decode to well-formed UTF-16, then encode to the target.
+        WTF::Vector<char16_t> units;
+        transcodeDecodeToUtf16(input, fromEncoding, /* replaceTrailingOddByte */ toEncoding == TranscodeEncoding::Ucs2, units);
+
+        switch (toEncoding) {
+        case TranscodeEncoding::Latin1:
+            transcodeEncodeNarrow(units, 0xFF, result);
+            break;
+        case TranscodeEncoding::Ascii:
+            transcodeEncodeNarrow(units, 0x7F, result);
+            break;
+        case TranscodeEncoding::Ucs2:
+            result.grow(units.size() * 2);
+            memcpy(result.begin(), units.begin(), units.size() * 2);
+            break;
+        case TranscodeEncoding::Utf8: {
+            // `units` is well-formed UTF-16, so this conversion cannot fail.
+            const size_t expected = simdutf::utf8_length_from_utf16le(units.begin(), units.size());
+            result.grow(expected);
+            const size_t actual = simdutf::convert_utf16le_to_utf8(units.begin(), units.size(), reinterpret_cast<char*>(result.begin()));
+            result.shrink(actual);
+            break;
+        }
+        default:
+            RELEASE_ASSERT_NOT_REACHED();
+        }
+    }
+
+    if (errorCode != 0) {
+        auto* error = JSC::createError(globalObject, makeString("Unable to transcode Buffer ["_s, errorName, "]"_s));
+        error->putDirect(vm, JSC::Identifier::fromString(vm, "code"_s), JSC::jsString(vm, String(errorName)), 0);
+        error->putDirect(vm, JSC::Identifier::fromString(vm, "errno"_s), JSC::jsNumber(errorCode), 0);
+        throwException(globalObject, scope, error);
+        return {};
+    }
+
+    RELEASE_AND_RETURN(scope, JSValue::encode(WebCore::createBuffer(globalObject, result)));
+}
diff --git a/src/jsc/modules/NodeBufferModule.h b/src/jsc/modules/NodeBufferModule.h
index 91996a725e04..fcf346bcdfe7 100644
--- a/src/jsc/modules/NodeBufferModule.h
+++ b/src/jsc/modules/NodeBufferModule.h
@@ -125,17 +125,7 @@ JSC_DEFINE_HOST_FUNCTION(jsBufferConstructorFunction_isAscii,
 
 BUN_DECLARE_HOST_FUNCTION(jsFunctionResolveObjectURL);
 
-JSC_DEFINE_HOST_FUNCTION(jsFunctionNotImplemented,
-    (JSGlobalObject * globalObject,
-        CallFrame* callFrame))
-{
-    VM& vm = globalObject->vm();
-    auto scope = DECLARE_THROW_SCOPE(vm);
-
-    throwException(globalObject, scope,
-        createError(globalObject, "Not implemented"_s));
-    return {};
-}
+BUN_DECLARE_HOST_FUNCTION(jsBufferTranscode);
 
 JSC_DEFINE_CUSTOM_GETTER(jsGetter_INSPECT_MAX_BYTES, (JSGlobalObject * lexicalGlobalObject, JSC::EncodedJSValue thisValue, PropertyName propertyName))
 {
@@ -204,7 +194,7 @@ DEFINE_NATIVE_MODULE(NodeBuffer)
     put(atobI, atobV);
     put(btoaI, btoaV);
 
-    auto* transcode = InternalFunction::createFunctionThatMasqueradesAsUndefined(vm, globalObject, 1, "transcode"_s, jsFunctionNotImplemented);
+    auto* transcode = JSC::JSFunction::create(vm, globalObject, 3, "transcode"_s, jsBufferTranscode, ImplementationVisibility::Public, NoIntrinsic, jsBufferTranscode);
 
     put(JSC::Identifier::fromString(vm, "transcode"_s), transcode);
 
diff --git a/src/jsc/modules/NodeConstantsModule.h b/src/jsc/modules/NodeConstantsModule.h
index 62a54d2c392c..734bd8b57a31 100644
--- a/src/jsc/modules/NodeConstantsModule.h
+++ b/src/jsc/modules/NodeConstantsModule.h
@@ -766,6 +766,8 @@ DEFINE_NATIVE_MODULE(NodeConstants)
 #ifdef SSL_OP_ALLOW_NO_DHE_KEX
     put(Identifier::fromString(vm, "SSL_OP_ALLOW_NO_DHE_KEX"_s),
         jsNumber(SSL_OP_ALLOW_NO_DHE_KEX));
+#else
+    put(Identifier::fromString(vm, "SSL_OP_ALLOW_NO_DHE_KEX"_s), jsNumber(0));
 #endif
 #ifdef SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION
     put(Identifier::fromString(vm, "SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION"_s),
@@ -778,14 +780,20 @@ DEFINE_NATIVE_MODULE(NodeConstants)
 #ifdef SSL_OP_CISCO_ANYCONNECT
     put(Identifier::fromString(vm, "SSL_OP_CISCO_ANYCONNECT"_s),
         jsNumber(SSL_OP_CISCO_ANYCONNECT));
+#else
+    put(Identifier::fromString(vm, "SSL_OP_CISCO_ANYCONNECT"_s), jsNumber(0));
 #endif
 #ifdef SSL_OP_COOKIE_EXCHANGE
     put(Identifier::fromString(vm, "SSL_OP_COOKIE_EXCHANGE"_s),
         jsNumber(SSL_OP_COOKIE_EXCHANGE));
+#else
+    put(Identifier::fromString(vm, "SSL_OP_COOKIE_EXCHANGE"_s), jsNumber(0));
 #endif
 #ifdef SSL_OP_CRYPTOPRO_TLSEXT_BUG
     put(Identifier::fromString(vm, "SSL_OP_CRYPTOPRO_TLSEXT_BUG"_s),
         jsNumber(SSL_OP_CRYPTOPRO_TLSEXT_BUG));
+#else
+    put(Identifier::fromString(vm, "SSL_OP_CRYPTOPRO_TLSEXT_BUG"_s), jsNumber(0));
 #endif
 #ifdef SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS
     put(Identifier::fromString(vm, "SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS"_s),
@@ -802,6 +810,8 @@ DEFINE_NATIVE_MODULE(NodeConstants)
 #ifdef SSL_OP_NO_ENCRYPT_THEN_MAC
     put(Identifier::fromString(vm, "SSL_OP_NO_ENCRYPT_THEN_MAC"_s),
         jsNumber(SSL_OP_NO_ENCRYPT_THEN_MAC));
+#else
+    put(Identifier::fromString(vm, "SSL_OP_NO_ENCRYPT_THEN_MAC"_s), jsNumber(0));
 #endif
 #ifdef SSL_OP_NO_QUERY_MTU
     put(Identifier::fromString(vm, "SSL_OP_NO_QUERY_MTU"_s),
@@ -847,57 +857,26 @@ DEFINE_NATIVE_MODULE(NodeConstants)
 #ifdef SSL_OP_PRIORITIZE_CHACHA
     put(Identifier::fromString(vm, "SSL_OP_PRIORITIZE_CHACHA"_s),
         jsNumber(SSL_OP_PRIORITIZE_CHACHA));
+#else
+    put(Identifier::fromString(vm, "SSL_OP_PRIORITIZE_CHACHA"_s), jsNumber(0));
 #endif
 #ifdef SSL_OP_TLS_ROLLBACK_BUG
     put(Identifier::fromString(vm, "SSL_OP_TLS_ROLLBACK_BUG"_s),
         jsNumber(SSL_OP_TLS_ROLLBACK_BUG));
 #endif
-#ifndef OPENSSL_NO_ENGINE
-#ifdef ENGINE_METHOD_RSA
-    put(Identifier::fromString(vm, "ENGINE_METHOD_RSA"_s),
-        jsNumber(ENGINE_METHOD_RSA));
-#endif
-#ifdef ENGINE_METHOD_DSA
-    put(Identifier::fromString(vm, "ENGINE_METHOD_DSA"_s),
-        jsNumber(ENGINE_METHOD_DSA));
-#endif
-#ifdef ENGINE_METHOD_DH
-    put(Identifier::fromString(vm, "ENGINE_METHOD_DH"_s),
-        jsNumber(ENGINE_METHOD_DH));
-#endif
-#ifdef ENGINE_METHOD_RAND
-    put(Identifier::fromString(vm, "ENGINE_METHOD_RAND"_s),
-        jsNumber(ENGINE_METHOD_RAND));
-#endif
-#ifdef ENGINE_METHOD_EC
-    put(Identifier::fromString(vm, "ENGINE_METHOD_EC"_s),
-        jsNumber(ENGINE_METHOD_EC));
-#endif
-#ifdef ENGINE_METHOD_CIPHERS
-    put(Identifier::fromString(vm, "ENGINE_METHOD_CIPHERS"_s),
-        jsNumber(ENGINE_METHOD_CIPHERS));
-#endif
-#ifdef ENGINE_METHOD_DIGESTS
-    put(Identifier::fromString(vm, "ENGINE_METHOD_DIGESTS"_s),
-        jsNumber(ENGINE_METHOD_DIGESTS));
-#endif
-#ifdef ENGINE_METHOD_PKEY_METHS
-    put(Identifier::fromString(vm, "ENGINE_METHOD_PKEY_METHS"_s),
-        jsNumber(ENGINE_METHOD_PKEY_METHS));
-#endif
-#ifdef ENGINE_METHOD_PKEY_ASN1_METHS
-    put(Identifier::fromString(vm, "ENGINE_METHOD_PKEY_ASN1_METHS"_s),
-        jsNumber(ENGINE_METHOD_PKEY_ASN1_METHS));
-#endif
-#ifdef ENGINE_METHOD_ALL
-    put(Identifier::fromString(vm, "ENGINE_METHOD_ALL"_s),
-        jsNumber(ENGINE_METHOD_ALL));
-#endif
-#ifdef ENGINE_METHOD_NONE
-    put(Identifier::fromString(vm, "ENGINE_METHOD_NONE"_s),
-        jsNumber(ENGINE_METHOD_NONE));
-#endif
-#endif // !OPENSSL_NO_ENGINE
+    // BoringSSL does not define engine constants in openssl/engine.h.
+    // Values mirror ProcessBindingConstants.cpp (and node).
+    put(Identifier::fromString(vm, "ENGINE_METHOD_RSA"_s), jsNumber(0x0001));
+    put(Identifier::fromString(vm, "ENGINE_METHOD_DSA"_s), jsNumber(0x0002));
+    put(Identifier::fromString(vm, "ENGINE_METHOD_DH"_s), jsNumber(0x0004));
+    put(Identifier::fromString(vm, "ENGINE_METHOD_RAND"_s), jsNumber(0x0008));
+    put(Identifier::fromString(vm, "ENGINE_METHOD_CIPHERS"_s), jsNumber(0x0040));
+    put(Identifier::fromString(vm, "ENGINE_METHOD_DIGESTS"_s), jsNumber(0x0080));
+    put(Identifier::fromString(vm, "ENGINE_METHOD_PKEY_METHS"_s), jsNumber(0x0200));
+    put(Identifier::fromString(vm, "ENGINE_METHOD_PKEY_ASN1_METHS"_s), jsNumber(0x0400));
+    put(Identifier::fromString(vm, "ENGINE_METHOD_EC"_s), jsNumber(0x0800));
+    put(Identifier::fromString(vm, "ENGINE_METHOD_ALL"_s), jsNumber(0xFFFF));
+    put(Identifier::fromString(vm, "ENGINE_METHOD_NONE"_s), jsNumber(0x0000));
 #ifdef DH_CHECK_P_NOT_SAFE_PRIME
     put(Identifier::fromString(vm, "DH_CHECK_P_NOT_SAFE_PRIME"_s),
         jsNumber(DH_CHECK_P_NOT_SAFE_PRIME));
@@ -932,6 +911,8 @@ DEFINE_NATIVE_MODULE(NodeConstants)
 #ifdef RSA_X931_PADDING
     put(Identifier::fromString(vm, "RSA_X931_PADDING"_s),
         jsNumber(RSA_X931_PADDING));
+#else
+    put(Identifier::fromString(vm, "RSA_X931_PADDING"_s), jsNumber(5));
 #endif
 #ifdef RSA_PKCS1_PSS_PADDING
     put(Identifier::fromString(vm, "RSA_PKCS1_PSS_PADDING"_s),
@@ -944,6 +925,8 @@ DEFINE_NATIVE_MODULE(NodeConstants)
 #ifdef RSA_PSS_SALTLEN_MAX_SIGN
     put(Identifier::fromString(vm, "RSA_PSS_SALTLEN_MAX_SIGN"_s),
         jsNumber(RSA_PSS_SALTLEN_MAX_SIGN));
+#else
+    put(Identifier::fromString(vm, "RSA_PSS_SALTLEN_MAX_SIGN"_s), jsNumber(-2));
 #endif
 #ifdef RSA_PSS_SALTLEN_AUTO
     put(Identifier::fromString(vm, "RSA_PSS_SALTLEN_AUTO"_s),
@@ -996,6 +979,33 @@ DEFINE_NATIVE_MODULE(NodeConstants)
     put(Identifier::fromString(vm, "POINT_CONVERSION_HYBRID"_s),
         jsNumber(POINT_CONVERSION_HYBRID));
 
+    // OBSOLETE OPTIONS retained for compatibility (always 0, as in node).
+    put(Identifier::fromString(vm, "SSL_OP_MICROSOFT_SESS_ID_BUG"_s), jsNumber(0));
+    put(Identifier::fromString(vm, "SSL_OP_NETSCAPE_CHALLENGE_BUG"_s), jsNumber(0));
+    put(Identifier::fromString(vm, "SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG"_s), jsNumber(0));
+    put(Identifier::fromString(vm, "SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG"_s), jsNumber(0));
+    put(Identifier::fromString(vm, "SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER"_s), jsNumber(0));
+    put(Identifier::fromString(vm, "SSL_OP_MSIE_SSLV2_RSA_PADDING"_s), jsNumber(0));
+    put(Identifier::fromString(vm, "SSL_OP_SSLEAY_080_CLIENT_DH_BUG"_s), jsNumber(0));
+    put(Identifier::fromString(vm, "SSL_OP_TLS_D5_BUG"_s), jsNumber(0));
+    put(Identifier::fromString(vm, "SSL_OP_TLS_BLOCK_PADDING_BUG"_s), jsNumber(0));
+    put(Identifier::fromString(vm, "SSL_OP_SINGLE_ECDH_USE"_s), jsNumber(0));
+    put(Identifier::fromString(vm, "SSL_OP_SINGLE_DH_USE"_s), jsNumber(0));
+    put(Identifier::fromString(vm, "SSL_OP_EPHEMERAL_RSA"_s), jsNumber(0));
+    put(Identifier::fromString(vm, "SSL_OP_PKCS1_CHECK_1"_s), jsNumber(0));
+    put(Identifier::fromString(vm, "SSL_OP_PKCS1_CHECK_2"_s), jsNumber(0));
+    put(Identifier::fromString(vm, "SSL_OP_NETSCAPE_CA_DN_BUG"_s), jsNumber(0));
+    put(Identifier::fromString(vm, "SSL_OP_NETSCAPE_DEMO_CIPHER_CHANGE_BUG"_s), jsNumber(0));
+
+    // fs formats the binding exposes; keep in sync with ProcessBindingConstants.cpp.
+    put(Identifier::fromString(vm, "EXTENSIONLESS_FORMAT_JAVASCRIPT"_s), jsNumber(0));
+    put(Identifier::fromString(vm, "EXTENSIONLESS_FORMAT_WASM"_s), jsNumber(1));
+
+    // node freezes require('constants') (lib/constants.js ObjectFreeze).
+    auto scope = DECLARE_THROW_SCOPE(vm);
+    JSC::objectConstructorFreeze(globalObject, defaultObject);
+    RETURN_IF_EXCEPTION(scope, void());
+
     // RETURN_NATIVE_MODULE();
 }
 
diff --git a/src/jsc/modules/NodeModuleModule.cpp b/src/jsc/modules/NodeModuleModule.cpp
index 25eed6ee7ac8..a5d4b6d45869 100644
--- a/src/jsc/modules/NodeModuleModule.cpp
+++ b/src/jsc/modules/NodeModuleModule.cpp
@@ -867,6 +867,10 @@ JSC_DEFINE_HOST_FUNCTION(jsFunctionRegister, (JSGlobalObject * globalObject, JSC
     return JSC::JSValue::encode(JSC::jsUndefined());
 }
 
+extern "C" int32_t Bun__NodeCompileCache__enable(const BunString* dir, int32_t portable, BunString* outDirectory, BunString* outMessage);
+extern "C" BunString Bun__NodeCompileCache__getDir();
+extern "C" void Bun__NodeCompileCache__flush();
+
 JSC_DEFINE_HOST_FUNCTION(jsFunctionEnableCompileCache,
     (JSGlobalObject * globalObject,
         JSC::CallFrame* callFrame))
@@ -874,34 +878,52 @@ JSC_DEFINE_HOST_FUNCTION(jsFunctionEnableCompileCache,
     auto& vm = JSC::getVM(globalObject);
     auto scope = DECLARE_THROW_SCOPE(vm);
 
-    // Accepts `string | { directory?: string, portable?: boolean } | undefined`.
-    // When a directory is provided explicitly it must be a string.
-    JSC::JSValue optionsValue = callFrame->argument(0);
-    JSC::JSValue directoryValue = optionsValue;
-    // Matches `typeof options === "object"`, so a callable is not an options bag.
-    if (optionsValue.isObject() && !optionsValue.isCallable()) {
-        auto* options = optionsValue.getObject();
-        directoryValue = options->get(globalObject, JSC::Identifier::fromString(vm, "directory"_s));
+    // Accepts `undefined`, a string, or `{ directory?, portable? }`.
+    JSValue options = callFrame->argument(0);
+    JSValue directoryValue = options;
+    int32_t portable = -1; // -1 = unspecified, Rust falls back to the env var
+    if (options.isObject() && !options.isCallable()) {
+        auto* optionsObject = options.getObject();
+        directoryValue = optionsObject->get(globalObject, JSC::Identifier::fromString(vm, "directory"_s));
         RETURN_IF_EXCEPTION(scope, {});
-        // Node reads `portable` before validating `directory`; the value is unused
-        // here but a throwing getter still propagates.
-        options->get(globalObject, JSC::Identifier::fromString(vm, "portable"_s));
+        JSValue portableValue = optionsObject->get(globalObject, JSC::Identifier::fromString(vm, "portable"_s));
         RETURN_IF_EXCEPTION(scope, {});
+        if (!portableValue.isUndefined()) {
+            portable = portableValue.toBoolean(globalObject) ? 1 : 0;
+        }
     }
 
-    if (!directoryValue.isUndefined() && !directoryValue.isString()) {
-        Bun::throwError(globalObject, scope, Bun::ErrorCode::ERR_INVALID_ARG_TYPE,
-            "cacheDir should be a string"_s);
-        return {};
+    WTF::String directory;
+    if (!directoryValue.isUndefined()) {
+        if (!directoryValue.isString()) {
+            Bun::throwError(globalObject, scope, Bun::ErrorCode::ERR_INVALID_ARG_TYPE, "cacheDir should be a string"_s);
+            return {};
+        }
+        directory = directoryValue.toWTFString(globalObject);
+        RETURN_IF_EXCEPTION(scope, {});
     }
 
-    // There is no on-disk module compile cache, so report failure instead of
-    // silently claiming the cache was enabled.
+    BunString directoryStr = Bun::toString(directory);
+    BunString outDirectory = { BunStringTag::Empty, {} };
+    BunString outMessage = { BunStringTag::Empty, {} };
+    int32_t status = Bun__NodeCompileCache__enable(
+        directory.isNull() ? nullptr : &directoryStr, portable, &outDirectory, &outMessage);
+
     auto* result = JSC::constructEmptyObject(globalObject);
-    result->putDirect(vm, JSC::Identifier::fromString(vm, "status"_s),
-        JSC::jsNumber(0)); // constants.compileCacheStatus.FAILED
-    result->putDirect(vm, JSC::Identifier::fromString(vm, "message"_s),
-        JSC::jsString(vm, String("the on-disk module compile cache is not supported"_s)));
+    result->putDirect(vm, JSC::Identifier::fromString(vm, "status"_s), JSC::jsNumber(status));
+    if (!outMessage.isEmpty()) {
+        JSValue message = outMessage.transferToJS(globalObject);
+        if (scope.exception()) [[unlikely]] {
+            outDirectory.deref();
+            return {};
+        }
+        result->putDirect(vm, JSC::Identifier::fromString(vm, "message"_s), message);
+    }
+    if (!outDirectory.isEmpty()) {
+        JSValue dir = outDirectory.transferToJS(globalObject);
+        RETURN_IF_EXCEPTION(scope, {});
+        result->putDirect(vm, JSC::Identifier::fromString(vm, "directory"_s), dir);
+    }
     RELEASE_AND_RETURN(scope, JSC::JSValue::encode(result));
 }
 
@@ -909,6 +931,18 @@ JSC_DEFINE_HOST_FUNCTION(jsFunctionGetCompileCacheDir,
     (JSGlobalObject * globalObject,
         JSC::CallFrame* callFrame))
 {
+    BunString dir = Bun__NodeCompileCache__getDir();
+    if (dir.isEmpty()) {
+        return JSC::JSValue::encode(JSC::jsUndefined());
+    }
+    return JSC::JSValue::encode(dir.transferToJS(globalObject));
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunctionFlushCompileCache,
+    (JSGlobalObject * globalObject,
+        JSC::CallFrame* callFrame))
+{
+    Bun__NodeCompileCache__flush();
     return JSC::JSValue::encode(JSC::jsUndefined());
 }
 
@@ -936,6 +970,7 @@ constants               getConstantsObject                PropertyCallback
 createRequire           jsFunctionNodeModuleCreateRequire Function 1
 enableCompileCache      jsFunctionEnableCompileCache      Function 1
 findSourceMap           Bun__JSSourceMap__find           Function 1
+flushCompileCache       jsFunctionFlushCompileCache       Function 0
 getCompileCacheDir      jsFunctionGetCompileCacheDir      Function 0
 globalPaths             getGlobalPathsObject              PropertyCallback
 isBuiltin               jsFunctionIsBuiltinModule         Function 1
diff --git a/src/jsc/modules/NodeUtilTypesModule.cpp b/src/jsc/modules/NodeUtilTypesModule.cpp
index 92eaddcdc1f1..8f5c7df09a6c 100644
--- a/src/jsc/modules/NodeUtilTypesModule.cpp
+++ b/src/jsc/modules/NodeUtilTypesModule.cpp
@@ -1,5 +1,18 @@
 #include "BunClientData.h"
+#include "JSDOMURL.h"
 #include "JSDOMWrapper.h"
+#include "node/crypto/JSKeyObject.h"
+#include <JavaScriptCore/DateInstance.h>
+#include <JavaScriptCore/JSMapIterator.h>
+#include <JavaScriptCore/BigIntObject.h>
+#include <JavaScriptCore/BooleanObject.h>
+#include <JavaScriptCore/JSWrapperObject.h>
+#include <JavaScriptCore/NumberObject.h>
+#include <JavaScriptCore/StringObject.h>
+#include <JavaScriptCore/RegExpObject.h>
+#include <JavaScriptCore/JSSetIterator.h>
+#include <JavaScriptCore/ObjectPrototype.h>
+#include <cmath>
 #include "JSEventTarget.h"
 #include "JavaScriptCore/TopExceptionScope.h"
 #include "_NativeModule.h"
@@ -107,6 +120,768 @@ JSC_DEFINE_HOST_FUNCTION(jsFunctionIsSymbolObject,
     GET_FIRST_CELL
     return JSValue::encode(jsBoolean(cell->inherits<JSC::SymbolObject>()));
 }
+
+// assert.partialDeepStrictEqual typed-array/ArrayBuffer branch (node's kPartial): expected's
+// elements as an ordered-with-gaps subsequence of actual's, Object.is equality at storage width.
+// https://github.com/nodejs/node/blob/main/lib/internal/util/comparisons.js
+template<typename T, typename EqualFn>
+static bool partialSequenceContains(std::span<const T> actual, std::span<const T> expected, EqualFn equal)
+{
+    if (expected.size() > actual.size())
+        return false;
+    size_t pos = 0;
+    for (size_t i = 0; i < expected.size(); i++) {
+        const size_t lastCandidate = actual.size() - expected.size() + i;
+        while (pos <= lastCandidate && !equal(actual[pos], expected[i]))
+            pos++;
+        if (pos > lastCandidate)
+            return false;
+        pos++;
+    }
+    return true;
+}
+
+template<typename T>
+static bool partialIntSequenceContains(std::span<const uint8_t> actual, std::span<const uint8_t> expected)
+{
+    return partialSequenceContains<T>(
+        { reinterpret_cast<const T*>(actual.data()), actual.size() / sizeof(T) },
+        { reinterpret_cast<const T*>(expected.data()), expected.size() / sizeof(T) },
+        [](T a, T b) { return a == b; });
+}
+
+template<typename FloatT, typename BitsT>
+static bool partialFloatSequenceContains(std::span<const uint8_t> actual, std::span<const uint8_t> expected)
+{
+    return partialSequenceContains<FloatT>(
+        { reinterpret_cast<const FloatT*>(actual.data()), actual.size() / sizeof(FloatT) },
+        { reinterpret_cast<const FloatT*>(expected.data()), expected.size() / sizeof(FloatT) },
+        [](FloatT a, FloatT b) {
+            if (std::isnan(a) || std::isnan(b))
+                return std::isnan(a) && std::isnan(b);
+            return std::bit_cast<BitsT>(a) == std::bit_cast<BitsT>(b);
+        });
+}
+
+// Float16 handled at the bit level: NaN = exponent all-ones with a non-zero
+// mantissa; everything else compares by exact bits (Object.is semantics).
+static bool partialFloat16SequenceContains(std::span<const uint8_t> actual, std::span<const uint8_t> expected)
+{
+    auto isNaN16 = [](uint16_t bits) { return (bits & 0x7C00) == 0x7C00 && (bits & 0x03FF); };
+    return partialSequenceContains<uint16_t>(
+        { reinterpret_cast<const uint16_t*>(actual.data()), actual.size() / 2 },
+        { reinterpret_cast<const uint16_t*>(expected.data()), expected.size() / 2 },
+        [isNaN16](uint16_t a, uint16_t b) {
+            if (isNaN16(a) || isNaN16(b))
+                return isNaN16(a) && isNaN16(b);
+            return a == b;
+        });
+}
+
+enum class ByteSpanResult { Ok,
+    NotABufferLike,
+    Detached };
+
+static ByteSpanResult byteSpanOf(JSC::JSValue value, std::span<const uint8_t>& out, JSC::TypedArrayType& type)
+{
+    JSCell* cell = value.isCell() ? value.asCell() : nullptr;
+    if (!cell)
+        return ByteSpanResult::NotABufferLike;
+    if (auto* view = dynamicDowncast<JSC::JSArrayBufferView>(cell)) {
+        if (view->isDetached())
+            return ByteSpanResult::Detached;
+        out = { static_cast<const uint8_t*>(view->vector()), view->byteLength() };
+        type = JSC::typedArrayType(cell->type());
+        return ByteSpanResult::Ok;
+    }
+    if (auto* buffer = dynamicDowncast<JSC::JSArrayBuffer>(cell)) {
+        auto* impl = buffer->impl();
+        if (!impl || impl->isDetached())
+            return ByteSpanResult::Detached;
+        out = { static_cast<const uint8_t*>(impl->data()), impl->byteLength() };
+        type = JSC::TypedArrayType::NotTypedArray;
+        return ByteSpanResult::Ok;
+    }
+    return ByteSpanResult::NotABufferLike;
+}
+
+// Ordered-with-gaps contents containment for same-kind typed arrays,
+// DataViews, and ArrayBuffers. Throws node's detached-buffer TypeError.
+static bool partialBufferContentsEquiv(JSC::JSGlobalObject* globalObject, JSC::ThrowScope& scope, JSC::JSValue actualValue, JSC::JSValue expectedValue)
+{
+    std::span<const uint8_t> actual, expected;
+    JSC::TypedArrayType actualType = JSC::TypedArrayType::NotTypedArray;
+    JSC::TypedArrayType expectedType = JSC::TypedArrayType::NotTypedArray;
+    auto actualResult = byteSpanOf(actualValue, actual, actualType);
+    auto expectedResult = byteSpanOf(expectedValue, expected, expectedType);
+    if (actualResult == ByteSpanResult::Detached || expectedResult == ByteSpanResult::Detached) {
+        // node reaches this branch via `new Uint8Array(detached)`, which
+        // throws; keep the exact error contract.
+        throwTypeError(globalObject, scope, "Cannot perform Construct on a detached ArrayBuffer"_s);
+        return false;
+    }
+    if (actualResult != ByteSpanResult::Ok || expectedResult != ByteSpanResult::Ok || actualType != expectedType)
+        return false;
+
+    bool result;
+    switch (actualType) {
+    case JSC::TypeInt8:
+        result = partialIntSequenceContains<int8_t>(actual, expected);
+        break;
+    case JSC::TypeInt16:
+        result = partialIntSequenceContains<int16_t>(actual, expected);
+        break;
+    case JSC::TypeInt32:
+        result = partialIntSequenceContains<int32_t>(actual, expected);
+        break;
+    case JSC::TypeUint16:
+        result = partialIntSequenceContains<uint16_t>(actual, expected);
+        break;
+    case JSC::TypeUint32:
+        result = partialIntSequenceContains<uint32_t>(actual, expected);
+        break;
+    case JSC::TypeBigInt64:
+        result = partialIntSequenceContains<int64_t>(actual, expected);
+        break;
+    case JSC::TypeBigUint64:
+        result = partialIntSequenceContains<uint64_t>(actual, expected);
+        break;
+    case JSC::TypeFloat16:
+        result = partialFloat16SequenceContains(actual, expected);
+        break;
+    case JSC::TypeFloat32:
+        result = partialFloatSequenceContains<float, uint32_t>(actual, expected);
+        break;
+    case JSC::TypeFloat64:
+        result = partialFloatSequenceContains<double, uint64_t>(actual, expected);
+        break;
+    default:
+        // Uint8, Uint8Clamped, DataView, and raw ArrayBuffers: byte-wise.
+        result = partialIntSequenceContains<uint8_t>(actual, expected);
+        break;
+    }
+    return result;
+}
+
+extern "C" bool JSC__JSValue__strictDeepEquals(JSC::EncodedJSValue, JSC::EncodedJSValue, JSC::JSGlobalObject*);
+
+// assert.partialDeepStrictEqual (node's kPartial mode), fully native. `expected` must be
+// recursively contained in `actual`; cycles are accepted only when both sides revisit together.
+// https://github.com/nodejs/node/blob/main/lib/internal/util/comparisons.js
+namespace PartialDeepEqual {
+
+struct CycleState {
+    WTF::Vector<JSC::JSCell*, 8> actualSeen;
+    WTF::Vector<JSC::JSCell*, 8> expectedSeen;
+};
+
+static bool compareBranch(JSC::JSGlobalObject*, JSC::MarkedArgumentBuffer&, CycleState&, JSC::ThrowScope&, JSValue actual, JSValue expected);
+
+// Both-sides cycle guard: a cycle is accepted only when actual and expected
+// each cycle back on their own side together.
+template<typename Body>
+static bool withCycleGuard(JSC::JSGlobalObject* globalObject, JSC::MarkedArgumentBuffer& gcBuffer, CycleState& cycles, JSC::ThrowScope& scope, JSValue actual, JSValue expected, Body body)
+{
+    JSC::JSCell* actualCell = actual.asCell();
+    JSC::JSCell* expectedCell = expected.asCell();
+    const bool hadActual = cycles.actualSeen.contains(actualCell);
+    const bool hadExpected = cycles.expectedSeen.contains(expectedCell);
+    if (hadActual && hadExpected)
+        return true;
+    if (hadActual || hadExpected)
+        return false;
+    cycles.actualSeen.append(actualCell);
+    cycles.expectedSeen.append(expectedCell);
+    const bool result = body(globalObject, gcBuffer, cycles, scope, actual, expected);
+    cycles.actualSeen.removeLast();
+    cycles.expectedSeen.removeLast();
+    return result;
+}
+
+// JS `actual[key]` guarded by `ObjectPrototypePropertyIsEnumerable`: the
+// property must be an own enumerable of `actual`, but the value read is an
+// ordinary get, exactly like the JS implementation.
+static bool ownEnumerableThenCompare(JSC::JSGlobalObject* globalObject, JSC::MarkedArgumentBuffer& gcBuffer, CycleState& cycles, JSC::ThrowScope& scope, JSC::JSObject* actualObject, JSC::JSObject* expectedObject, JSC::PropertyName propertyName)
+{
+    JSC::PropertySlot ownSlot(actualObject, JSC::PropertySlot::InternalMethodType::GetOwnProperty);
+    bool owns = actualObject->methodTable()->getOwnPropertySlot(actualObject, globalObject, propertyName, ownSlot);
+    RETURN_IF_EXCEPTION(scope, false);
+    if (!owns || (ownSlot.attributes() & JSC::PropertyAttribute::DontEnum))
+        return false;
+    JSValue actualValue = actualObject->get(globalObject, propertyName);
+    RETURN_IF_EXCEPTION(scope, false);
+    JSValue expectedValue = expectedObject->get(globalObject, propertyName);
+    RETURN_IF_EXCEPTION(scope, false);
+    return compareBranch(globalObject, gcBuffer, cycles, scope, actualValue, expectedValue);
+}
+
+// Own enumerable string and symbol properties of `expected` only.
+static bool objectSubset(JSC::JSGlobalObject* globalObject, JSC::MarkedArgumentBuffer& gcBuffer, CycleState& cycles, JSC::ThrowScope& scope, JSValue actual, JSValue expected)
+{
+    auto& vm = globalObject->vm();
+    JSC::JSObject* actualObject = actual.getObject();
+    JSC::JSObject* expectedObject = expected.getObject();
+    if (!actualObject || !expectedObject)
+        return false;
+    JSC::PropertyNameArrayBuilder names(vm, JSC::PropertyNameMode::StringsAndSymbols, JSC::PrivateSymbolMode::Exclude);
+    expectedObject->methodTable()->getOwnPropertyNames(expectedObject, globalObject, names, JSC::DontEnumPropertiesMode::Exclude);
+    RETURN_IF_EXCEPTION(scope, false);
+    for (size_t i = 0; i < names.size(); i++) {
+        bool equal = ownEnumerableThenCompare(globalObject, gcBuffer, cycles, scope, actualObject, expectedObject, names[i]);
+        RETURN_IF_EXCEPTION(scope, false);
+        if (!equal)
+            return false;
+    }
+    return true;
+}
+
+// Expected's own enumerable non-index string+symbol properties only — index keys are covered
+// by the caller's subsequence/contents comparison (enforcing them here would break with-gaps).
+static bool nonIndexObjectSubset(JSC::JSGlobalObject* globalObject, JSC::MarkedArgumentBuffer& gcBuffer, CycleState& cycles, JSC::ThrowScope& scope, JSValue actual, JSValue expected)
+{
+    auto& vm = globalObject->vm();
+    JSC::JSObject* actualObject = actual.getObject();
+    JSC::JSObject* expectedObject = expected.getObject();
+    // getOwnNonIndexPropertyNames skips integer indexes at the source (no per-element Identifier
+    // for typed arrays). Array/typed-array `length` is non-enumerable/prototype so neither appears.
+    JSC::PropertyNameArrayBuilder names(vm, JSC::PropertyNameMode::StringsAndSymbols, JSC::PrivateSymbolMode::Exclude);
+    expectedObject->getOwnNonIndexPropertyNames(globalObject, names, JSC::DontEnumPropertiesMode::Exclude);
+    RETURN_IF_EXCEPTION(scope, false);
+    for (size_t i = 0; i < names.size(); i++) {
+        bool equal = ownEnumerableThenCompare(globalObject, gcBuffer, cycles, scope, actualObject, expectedObject, names[i]);
+        RETURN_IF_EXCEPTION(scope, false);
+        if (!equal)
+            return false;
+    }
+    return true;
+}
+
+// Expected's elements as a subsequence of actual's, in order with gaps, then
+// expected's own enumerable non-index properties.
+static bool arraySubsequence(JSC::JSGlobalObject* globalObject, JSC::MarkedArgumentBuffer& gcBuffer, CycleState& cycles, JSC::ThrowScope& scope, JSValue actual, JSValue expected)
+{
+    JSC::JSObject* actualObject = actual.getObject();
+    JSC::JSObject* expectedObject = expected.getObject();
+    const uint64_t actualLength = static_cast<uint64_t>(JSC::toLength(globalObject, actualObject));
+    RETURN_IF_EXCEPTION(scope, false);
+    const uint64_t expectedLength = static_cast<uint64_t>(JSC::toLength(globalObject, expectedObject));
+    RETURN_IF_EXCEPTION(scope, false);
+    if (expectedLength > actualLength)
+        return false;
+
+    uint64_t actualPos = 0;
+    for (uint64_t i = 0; i < expectedLength; i++) {
+        const uint64_t lastCandidate = actualLength - expectedLength + i;
+        JSValue expectedElement = expectedObject->getIndex(globalObject, i);
+        RETURN_IF_EXCEPTION(scope, false);
+        bool matched = false;
+        while (actualPos <= lastCandidate) {
+            JSValue actualElement = actualObject->getIndex(globalObject, actualPos);
+            RETURN_IF_EXCEPTION(scope, false);
+            bool equal = compareBranch(globalObject, gcBuffer, cycles, scope, actualElement, expectedElement);
+            RETURN_IF_EXCEPTION(scope, false);
+            actualPos++;
+            if (equal) {
+                matched = true;
+                break;
+            }
+        }
+        if (!matched)
+            return false;
+    }
+
+    return nonIndexObjectSubset(globalObject, gcBuffer, cycles, scope, actual, expected);
+}
+
+// Expected's entries as a subset of actual's: identity keys fast-path with
+// index reservation so no actual entry is consumed twice; object keys match
+// by partial deep equality.
+static bool mapSubset(JSC::JSGlobalObject* globalObject, JSC::MarkedArgumentBuffer& gcBuffer, CycleState& cycles, JSC::ThrowScope& scope, JSValue actual, JSValue expected)
+{
+    auto& vm = globalObject->vm();
+    JSC::JSMap* actualMap = uncheckedDowncast<JSC::JSMap>(actual.asCell());
+    JSC::JSMap* expectedMap = uncheckedDowncast<JSC::JSMap>(expected.asCell());
+
+    // Materialized lazily, rooted in gcBuffer (keys then values, pairwise).
+    bool materialized = false;
+    size_t entriesStart = 0;
+    size_t entryCount = 0;
+    WTF::Vector<bool, 8> usedIndices;
+    JSC::MarkedArgumentBuffer usedIdentityKeys;
+
+    auto materialize = [&]() -> bool {
+        if (materialized)
+            return true;
+        materialized = true;
+        entriesStart = gcBuffer.size();
+        auto iter = JSC::JSMapIterator::create(vm, globalObject->mapIteratorStructure(), actualMap, JSC::IterationKind::Entries);
+        if (scope.exception()) [[unlikely]]
+            return false;
+        JSValue key, value;
+        while (iter->nextKeyValue(globalObject, key, value)) {
+            gcBuffer.append(key);
+            gcBuffer.append(value);
+            entryCount++;
+        }
+        usedIndices.fill(false, entryCount);
+        return true;
+    };
+
+    auto identityKeyUsed = [&](JSValue key) -> bool {
+        for (size_t i = 0; i < usedIdentityKeys.size(); i++) {
+            bool same = JSC::sameValue(globalObject, usedIdentityKeys.at(i), key);
+            // sameValue can resolve ropes and throw; plain check because the macro can't live
+            // inside a lambda — callers RETURN_IF_EXCEPTION right after this returns.
+            if (scope.exception()) [[unlikely]]
+                return false;
+            if (same)
+                return true;
+        }
+        return false;
+    };
+
+    auto expectedIter = JSC::JSMapIterator::create(vm, globalObject->mapIteratorStructure(), expectedMap, JSC::IterationKind::Entries);
+    RETURN_IF_EXCEPTION(scope, false);
+    JSValue expectedKey, expectedValue;
+    while (expectedIter->nextKeyValue(globalObject, expectedKey, expectedValue)) {
+        bool consumed = false;
+        bool identityPresent = actualMap->has(globalObject, expectedKey);
+        RETURN_IF_EXCEPTION(scope, false);
+        bool expectedKeyAlreadyUsed = identityKeyUsed(expectedKey);
+        // sameValue can resolve rope strings and throw; the lambda cannot
+        // hold the check macro, so check at every call site.
+        RETURN_IF_EXCEPTION(scope, false);
+        if (identityPresent && !expectedKeyAlreadyUsed) {
+            // Reserve the identity entry's index so the deep-matching loop
+            // below cannot consume it twice.
+            size_t identityIndex = SIZE_MAX;
+            if (materialized) {
+                for (size_t i = 0; i < entryCount; i++) {
+                    bool same = JSC::sameValueZero(globalObject, gcBuffer.at(entriesStart + i * 2), expectedKey);
+                    // Same rope-resolution hazard as identityKeyUsed: bail
+                    // before the next VM-entering call, not after the loop.
+                    RETURN_IF_EXCEPTION(scope, false);
+                    if (same) {
+                        identityIndex = i;
+                        break;
+                    }
+                }
+            }
+            if (identityIndex == SIZE_MAX || !usedIndices[identityIndex]) {
+                JSValue actualValue = actualMap->get(globalObject, expectedKey);
+                RETURN_IF_EXCEPTION(scope, false);
+                bool equal = compareBranch(globalObject, gcBuffer, cycles, scope, actualValue, expectedValue);
+                RETURN_IF_EXCEPTION(scope, false);
+                if (equal) {
+                    usedIdentityKeys.append(expectedKey);
+                    if (identityIndex != SIZE_MAX)
+                        usedIndices[identityIndex] = true;
+                    consumed = true;
+                }
+            }
+        }
+        if (consumed)
+            continue;
+        if (!expectedKey.isObject())
+            return false;
+        if (!materialize())
+            return false;
+        RETURN_IF_EXCEPTION(scope, false);
+        bool matched = false;
+        for (size_t i = 0; i < entryCount; i++) {
+            if (usedIndices[i])
+                continue;
+            JSValue candidateKey = gcBuffer.at(entriesStart + i * 2);
+            bool candidateIsUsedIdentity = identityKeyUsed(candidateKey);
+            RETURN_IF_EXCEPTION(scope, false);
+            if (candidateIsUsedIdentity)
+                continue;
+            bool keyEqual = compareBranch(globalObject, gcBuffer, cycles, scope, candidateKey, expectedKey);
+            RETURN_IF_EXCEPTION(scope, false);
+            if (!keyEqual)
+                continue;
+            bool valueEqual = compareBranch(globalObject, gcBuffer, cycles, scope, gcBuffer.at(entriesStart + i * 2 + 1), expectedValue);
+            RETURN_IF_EXCEPTION(scope, false);
+            if (valueEqual) {
+                usedIndices[i] = true;
+                matched = true;
+                break;
+            }
+        }
+        if (!matched)
+            return false;
+    }
+    return true;
+}
+
+// Expected's items as a subset of actual's; item equality is the partial
+// comparison itself — node matches object items with subset semantics
+// (Set([{a:1,b:2}]) partially contains Set([{a:1}])).
+static bool setSubset(JSC::JSGlobalObject* globalObject, JSC::MarkedArgumentBuffer& gcBuffer, CycleState& cycles, JSC::ThrowScope& scope, JSValue actual, JSValue expected)
+{
+    auto& vm = globalObject->vm();
+    JSC::JSSet* actualSet = uncheckedDowncast<JSC::JSSet>(actual.asCell());
+    JSC::JSSet* expectedSet = uncheckedDowncast<JSC::JSSet>(expected.asCell());
+
+    const size_t itemsStart = gcBuffer.size();
+    size_t itemCount = 0;
+    {
+        auto iter = JSC::JSSetIterator::create(vm, globalObject->setIteratorStructure(), actualSet, JSC::IterationKind::Keys);
+        RETURN_IF_EXCEPTION(scope, false);
+        JSValue item;
+        while (iter->next(globalObject, item)) {
+            gcBuffer.append(item);
+            itemCount++;
+        }
+    }
+    WTF::Vector<bool, 8> usedIndices;
+    usedIndices.fill(false, itemCount);
+
+    auto expectedIter = JSC::JSSetIterator::create(vm, globalObject->setIteratorStructure(), expectedSet, JSC::IterationKind::Keys);
+    RETURN_IF_EXCEPTION(scope, false);
+    JSValue expectedItem;
+    while (expectedIter->next(globalObject, expectedItem)) {
+        bool matched = false;
+        for (size_t i = 0; i < itemCount; i++) {
+            if (usedIndices[i])
+                continue;
+            bool equal = compareBranch(globalObject, gcBuffer, cycles, scope, gcBuffer.at(itemsStart + i), expectedItem);
+            RETURN_IF_EXCEPTION(scope, false);
+            if (equal) {
+                usedIndices[i] = true;
+                matched = true;
+                break;
+            }
+        }
+        if (!matched)
+            return false;
+    }
+    return true;
+}
+
+// Errors compare name/message/errors leniently: `undefined` (or an empty
+// expected message) on the expected side is ignored. An own `cause` on the
+// expected error (even undefined) must exist on the actual error as well.
+static bool errorSubset(JSC::JSGlobalObject* globalObject, JSC::MarkedArgumentBuffer& gcBuffer, CycleState& cycles, JSC::ThrowScope& scope, JSValue actual, JSValue expected)
+{
+    auto& vm = globalObject->vm();
+    JSC::JSObject* actualObject = actual.getObject();
+    JSC::JSObject* expectedObject = expected.getObject();
+
+    const JSC::Identifier keys[3] = {
+        vm.propertyNames->message,
+        vm.propertyNames->name,
+        JSC::Identifier::fromString(vm, "errors"_s),
+    };
+    for (const auto& key : keys) {
+        JSValue expectedValue = expectedObject->get(globalObject, key);
+        RETURN_IF_EXCEPTION(scope, false);
+        if (expectedValue.isUndefined())
+            continue;
+        if (key == vm.propertyNames->message && expectedValue.isString()) {
+            auto* str = JSC::asString(expectedValue);
+            if (!str->length())
+                continue;
+        }
+        JSValue actualValue = actualObject->get(globalObject, key);
+        RETURN_IF_EXCEPTION(scope, false);
+        bool equal = compareBranch(globalObject, gcBuffer, cycles, scope, actualValue, expectedValue);
+        RETURN_IF_EXCEPTION(scope, false);
+        if (!equal)
+            return false;
+    }
+
+    const JSC::Identifier causeIdentifier = JSC::Identifier::fromString(vm, "cause"_s);
+    JSC::PropertySlot expectedCauseSlot(expectedObject, JSC::PropertySlot::InternalMethodType::GetOwnProperty);
+    bool expectedHasCause = expectedObject->methodTable()->getOwnPropertySlot(expectedObject, globalObject, causeIdentifier, expectedCauseSlot);
+    RETURN_IF_EXCEPTION(scope, false);
+    if (expectedHasCause) {
+        JSC::PropertySlot actualCauseSlot(actualObject, JSC::PropertySlot::InternalMethodType::GetOwnProperty);
+        bool actualHasCause = actualObject->methodTable()->getOwnPropertySlot(actualObject, globalObject, causeIdentifier, actualCauseSlot);
+        RETURN_IF_EXCEPTION(scope, false);
+        if (!actualHasCause)
+            return false;
+        JSValue actualCause = actualObject->get(globalObject, causeIdentifier);
+        RETURN_IF_EXCEPTION(scope, false);
+        JSValue expectedCause = expectedObject->get(globalObject, causeIdentifier);
+        RETURN_IF_EXCEPTION(scope, false);
+        bool equal = compareBranch(globalObject, gcBuffer, cycles, scope, actualCause, expectedCause);
+        RETURN_IF_EXCEPTION(scope, false);
+        if (!equal)
+            return false;
+    }
+    return objectSubset(globalObject, gcBuffer, cycles, scope, actual, expected);
+}
+
+static JSC::JSWrapperObject* asBoxedPrimitive(JSValue value)
+{
+    if (!value.isCell())
+        return nullptr;
+    JSC::JSCell* cell = value.asCell();
+    if (cell->inherits<JSC::NumberObject>() || cell->inherits<JSC::BooleanObject>()
+        || cell->inherits<JSC::BigIntObject>() || cell->inherits<JSC::SymbolObject>()
+        || cell->inherits<JSC::StringObject>())
+        return uncheckedDowncast<JSC::JSWrapperObject>(cell);
+    return nullptr;
+}
+
+// Container contents first, then own enumerable properties on the Map/Set
+// object itself — node's partial mode checks both (subset semantics), like
+// every other container arm.
+static bool mapSubsetAndProps(JSC::JSGlobalObject* globalObject, JSC::MarkedArgumentBuffer& gcBuffer, CycleState& cycles, JSC::ThrowScope& scope, JSValue actual, JSValue expected)
+{
+    bool contents = mapSubset(globalObject, gcBuffer, cycles, scope, actual, expected);
+    RETURN_IF_EXCEPTION(scope, false);
+    if (!contents)
+        return false;
+    return objectSubset(globalObject, gcBuffer, cycles, scope, actual, expected);
+}
+
+static bool setSubsetAndProps(JSC::JSGlobalObject* globalObject, JSC::MarkedArgumentBuffer& gcBuffer, CycleState& cycles, JSC::ThrowScope& scope, JSValue actual, JSValue expected)
+{
+    bool contents = setSubset(globalObject, gcBuffer, cycles, scope, actual, expected);
+    RETURN_IF_EXCEPTION(scope, false);
+    if (!contents)
+        return false;
+    return objectSubset(globalObject, gcBuffer, cycles, scope, actual, expected);
+}
+
+static bool isSpecialValue(JSValue value)
+{
+    // `typeof x !== "object"`: primitives, null, and callables are decided
+    // by full strict deep equality. Every specific type (Error, Date, RegExp,
+    // boxed primitives, ...) has already been handled by its own arm above.
+    return !value.isObject() || value.isCallable();
+}
+
+static bool compareBranch(JSC::JSGlobalObject* globalObject, JSC::MarkedArgumentBuffer& gcBuffer, CycleState& cycles, JSC::ThrowScope& scope, JSValue actual, JSValue expected)
+{
+    auto& vm = globalObject->vm();
+    if (!vm.isSafeToRecurse()) [[unlikely]] {
+        JSC::throwStackOverflowError(globalObject, scope);
+        return false;
+    }
+
+    bool referenceEqual = JSC::sameValueZero(globalObject, actual, expected);
+    RETURN_IF_EXCEPTION(scope, false);
+    if (referenceEqual) {
+        // `actual === expected` except +0 vs -0, which Object.is rejects.
+        if (actual.isNumber() && actual.asNumber() == 0)
+            return std::signbit(actual.asNumber()) == std::signbit(expected.asNumber());
+        // sameValueZero also accepts NaN === NaN, which the JS fast path
+        // (===) rejected — but every NaN pair falls through to isSpecial →
+        // strict deepEquals, which accepts it, so accepting here matches.
+        return true;
+    }
+
+    const JSC::JSType actualType = actual.isCell() ? actual.asCell()->type() : JSC::JSType(0);
+    const JSC::JSType expectedType = expected.isCell() ? expected.asCell()->type() : JSC::JSType(0);
+
+    // Distinct weak collections and promises are never partially equal.
+    if (actualType == JSC::JSWeakSetType || actualType == JSC::JSWeakMapType || actualType == JSC::JSPromiseType
+        || expectedType == JSC::JSWeakSetType || expectedType == JSC::JSWeakMapType || expectedType == JSC::JSPromiseType)
+        return false;
+
+    if (actualType == JSC::JSMapType && expectedType == JSC::JSMapType) {
+        if (uncheckedDowncast<JSC::JSMap>(expected.asCell())->size() > uncheckedDowncast<JSC::JSMap>(actual.asCell())->size())
+            return false;
+        return withCycleGuard(globalObject, gcBuffer, cycles, scope, actual, expected, mapSubsetAndProps);
+    }
+
+    const bool actualIsView = actual.isCell() && JSC::isTypedArrayTypeIncludingDataView(actualType);
+    const bool expectedIsView = expected.isCell() && JSC::isTypedArrayTypeIncludingDataView(expectedType);
+    if (actualIsView || expectedIsView) {
+        if (actualIsView != expectedIsView || actualType != expectedType)
+            return false;
+        bool contents = partialBufferContentsEquiv(globalObject, scope, actual, expected);
+        RETURN_IF_EXCEPTION(scope, false);
+        if (!contents)
+            return false;
+        if (actualType == JSC::DataViewType)
+            return withCycleGuard(globalObject, gcBuffer, cycles, scope, actual, expected, objectSubset);
+        // node also matches expected's own enumerable non-index properties
+        // on typed arrays; index keys stay with the contents containment.
+        return withCycleGuard(globalObject, gcBuffer, cycles, scope, actual, expected, nonIndexObjectSubset);
+    }
+
+    const bool actualIsBuffer = actualType == JSC::ArrayBufferType;
+    const bool expectedIsBuffer = expectedType == JSC::ArrayBufferType;
+    if (actualIsBuffer || expectedIsBuffer) {
+        if (actualIsBuffer != expectedIsBuffer)
+            return false;
+        JSC::JSString* actualTag = JSC::objectPrototypeToString(globalObject, actual);
+        RETURN_IF_EXCEPTION(scope, false);
+        JSC::JSString* expectedTag = JSC::objectPrototypeToString(globalObject, expected);
+        RETURN_IF_EXCEPTION(scope, false);
+        bool tagsEqual = actualTag->equal(globalObject, expectedTag);
+        RETURN_IF_EXCEPTION(scope, false);
+        if (!tagsEqual)
+            return false;
+        bool contents = partialBufferContentsEquiv(globalObject, scope, actual, expected);
+        RETURN_IF_EXCEPTION(scope, false);
+        if (!contents)
+            return false;
+        return withCycleGuard(globalObject, gcBuffer, cycles, scope, actual, expected, objectSubset);
+    }
+
+    const bool actualIsKeyObject = actual.isCell() && actual.asCell()->inherits<Bun::JSKeyObject>();
+    const bool expectedIsKeyObject = expected.isCell() && expected.asCell()->inherits<Bun::JSKeyObject>();
+    if (actualIsKeyObject || expectedIsKeyObject) {
+        if (!actualIsKeyObject || !expectedIsKeyObject)
+            return false;
+        // KeyObject.prototype.equals, called like the JS implementation did.
+        JSC::JSObject* actualObject = actual.getObject();
+        JSValue equalsFunction = actualObject->get(globalObject, JSC::Identifier::fromString(vm, "equals"_s));
+        RETURN_IF_EXCEPTION(scope, false);
+        auto callData = JSC::getCallData(equalsFunction);
+        if (callData.type == JSC::CallData::Type::None)
+            return false;
+        JSC::MarkedArgumentBuffer args;
+        args.append(expected);
+        JSValue result = JSC::call(globalObject, equalsFunction, callData, actual, args);
+        RETURN_IF_EXCEPTION(scope, false);
+        if (!result.toBoolean(globalObject))
+            return false;
+        return withCycleGuard(globalObject, gcBuffer, cycles, scope, actual, expected, objectSubset);
+    }
+
+    const bool actualIsURL = actual.isCell() && actual.asCell()->inherits<WebCore::JSDOMURL>();
+    const bool expectedIsURL = expected.isCell() && expected.asCell()->inherits<WebCore::JSDOMURL>();
+    if (actualIsURL || expectedIsURL) {
+        if (!actualIsURL || !expectedIsURL)
+            return false;
+        auto& actualURL = uncheckedDowncast<WebCore::JSDOMURL>(actual.asCell())->wrapped();
+        auto& expectedURL = uncheckedDowncast<WebCore::JSDOMURL>(expected.asCell())->wrapped();
+        if (actualURL.href() != expectedURL.href())
+            return false;
+        return withCycleGuard(globalObject, gcBuffer, cycles, scope, actual, expected, objectSubset);
+    }
+
+    const bool actualIsError = actual.isCell() && actual.asCell()->inherits<JSC::ErrorInstance>();
+    const bool expectedIsError = expected.isCell() && expected.asCell()->inherits<JSC::ErrorInstance>();
+    if (actualIsError || expectedIsError) {
+        if (!actualIsError || !expectedIsError)
+            return false;
+        return withCycleGuard(globalObject, gcBuffer, cycles, scope, actual, expected, errorSubset);
+    }
+
+    if (actualType == JSC::JSSetType && expectedType == JSC::JSSetType) {
+        if (uncheckedDowncast<JSC::JSSet>(expected.asCell())->size() > uncheckedDowncast<JSC::JSSet>(actual.asCell())->size())
+            return false;
+        return withCycleGuard(globalObject, gcBuffer, cycles, scope, actual, expected, setSubsetAndProps);
+    }
+
+    // Dates and RegExps: internal value compared strictly, own enumerable properties with subset
+    // semantics (node's partial mode; straight strict compare would be prototype-sensitive).
+    const bool actualIsDate = actualType == JSC::JSDateType;
+    const bool expectedIsDate = expectedType == JSC::JSDateType;
+    if (actualIsDate || expectedIsDate) {
+        if (!actualIsDate || !expectedIsDate)
+            return false;
+        const double actualTime = uncheckedDowncast<JSC::DateInstance>(actual.asCell())->internalNumber();
+        const double expectedTime = uncheckedDowncast<JSC::DateInstance>(expected.asCell())->internalNumber();
+        if (actualTime != expectedTime && !(std::isnan(actualTime) && std::isnan(expectedTime)))
+            return false;
+        return withCycleGuard(globalObject, gcBuffer, cycles, scope, actual, expected, objectSubset);
+    }
+
+    const bool actualIsRegExp = actualType == JSC::RegExpObjectType;
+    const bool expectedIsRegExp = expectedType == JSC::RegExpObjectType;
+    if (actualIsRegExp || expectedIsRegExp) {
+        if (!actualIsRegExp || !expectedIsRegExp)
+            return false;
+        auto* actualRegExp = uncheckedDowncast<JSC::RegExpObject>(actual.asCell());
+        auto* expectedRegExp = uncheckedDowncast<JSC::RegExpObject>(expected.asCell());
+        if (actualRegExp->regExp()->pattern() != expectedRegExp->regExp()->pattern()
+            || actualRegExp->regExp()->flags() != expectedRegExp->regExp()->flags())
+            return false;
+        // node also compares lastIndex strictly (comparisons.js isRegExp arm).
+        bool lastIndexEqual = JSC::sameValue(globalObject, actualRegExp->getLastIndex(), expectedRegExp->getLastIndex());
+        RETURN_IF_EXCEPTION(scope, false);
+        if (!lastIndexEqual)
+            return false;
+        return withCycleGuard(globalObject, gcBuffer, cycles, scope, actual, expected, objectSubset);
+    }
+
+    // Boxed primitives: [[*Data]] compared via Object.is, then own props as a subset — node
+    // unwraps the slot before the property walk. Concrete classes only (JSWrapperObject has no
+    // discriminating ClassInfo, so a base-class downcast would match every object).
+    auto* actualWrapper = asBoxedPrimitive(actual);
+    auto* expectedWrapper = asBoxedPrimitive(expected);
+    if (actualWrapper || expectedWrapper) {
+        if (!actualWrapper || !expectedWrapper)
+            return false;
+        bool internalEqual = JSC::sameValue(globalObject, actualWrapper->internalValue(), expectedWrapper->internalValue());
+        RETURN_IF_EXCEPTION(scope, false);
+        if (!internalEqual)
+            return false;
+        return withCycleGuard(globalObject, gcBuffer, cycles, scope, actual, expected, objectSubset);
+    }
+
+    bool actualIsArray = JSC::isArray(globalObject, actual);
+    RETURN_IF_EXCEPTION(scope, false);
+    bool expectedIsArray = JSC::isArray(globalObject, expected);
+    RETURN_IF_EXCEPTION(scope, false);
+    if (actualIsArray != expectedIsArray)
+        return false;
+    if (actualIsArray)
+        return withCycleGuard(globalObject, gcBuffer, cycles, scope, actual, expected, arraySubsequence);
+
+    // At least one side is a primitive, null, or callable: full strict deep
+    // equality decides.
+    if (isSpecialValue(actual) || isSpecialValue(expected)) {
+        bool equal = JSC__JSValue__strictDeepEquals(JSValue::encode(actual), JSValue::encode(expected), globalObject);
+        RETURN_IF_EXCEPTION(scope, false);
+        return equal;
+    }
+
+    // Objects with different type tags are never partially equal.
+    JSC::JSString* actualTag = JSC::objectPrototypeToString(globalObject, actual);
+    RETURN_IF_EXCEPTION(scope, false);
+    JSC::JSString* expectedTag = JSC::objectPrototypeToString(globalObject, expected);
+    RETURN_IF_EXCEPTION(scope, false);
+    bool tagsEqual = actualTag->equal(globalObject, expectedTag);
+    RETURN_IF_EXCEPTION(scope, false);
+    if (!tagsEqual)
+        return false;
+
+    return withCycleGuard(globalObject, gcBuffer, cycles, scope, actual, expected, objectSubset);
+}
+
+} // namespace PartialDeepEqual
+
+JSC_DEFINE_HOST_FUNCTION(jsFunctionPartialDeepStrictEqual,
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    auto scope = DECLARE_THROW_SCOPE(globalObject->vm());
+    JSC::MarkedArgumentBuffer gcBuffer;
+    PartialDeepEqual::CycleState cycles;
+    bool result = PartialDeepEqual::compareBranch(globalObject, gcBuffer, cycles, scope, callframe->argument(0), callframe->argument(1));
+    RETURN_IF_EXCEPTION(scope, {});
+    return JSValue::encode(jsBoolean(result));
+}
+
+extern "C" bool Bun__deepEqualsNodeStrict(JSC::EncodedJSValue a, JSC::EncodedJSValue b, JSC::JSGlobalObject* globalObject);
+extern "C" bool Bun__deepEqualsNodeStrictSkipProto(JSC::EncodedJSValue a, JSC::EncodedJSValue b, JSC::JSGlobalObject* globalObject);
+
+// util.isDeepStrictEqual / assert.deepStrictEqual: node semantics including the [[Prototype]]
+// identity check Bun.deepEquals omits. argument(2) truthy = node's kStrictWithoutPrototypes.
+// https://github.com/nodejs/node/blob/main/lib/internal/util/comparisons.js
+JSC_DEFINE_HOST_FUNCTION(jsFunctionIsDeepStrictEqual,
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe))
+{
+    auto scope = DECLARE_THROW_SCOPE(globalObject->vm());
+    bool skipPrototype = callframe->argument(2).toBoolean(globalObject);
+    RETURN_IF_EXCEPTION(scope, {});
+    bool result = skipPrototype
+        ? Bun__deepEqualsNodeStrictSkipProto(JSValue::encode(callframe->argument(0)), JSValue::encode(callframe->argument(1)), globalObject)
+        : Bun__deepEqualsNodeStrict(JSValue::encode(callframe->argument(0)), JSValue::encode(callframe->argument(1)), globalObject);
+    RETURN_IF_EXCEPTION(scope, {});
+    return JSValue::encode(jsBoolean(result));
+}
+
 JSC_DEFINE_HOST_FUNCTION(jsFunctionIsError,
     (JSC::JSGlobalObject * globalObject,
         JSC::CallFrame* callframe))
diff --git a/src/jsc/modules/NodeUtilTypesModule.h b/src/jsc/modules/NodeUtilTypesModule.h
index 73a668236c18..74d4359f158f 100644
--- a/src/jsc/modules/NodeUtilTypesModule.h
+++ b/src/jsc/modules/NodeUtilTypesModule.h
@@ -9,6 +9,14 @@ JSC_DEFINE_HOST_FUNCTION(jsFunctionIsError,
     (JSC::JSGlobalObject * globalObject,
         JSC::CallFrame* callframe));
 
+JSC_DEFINE_HOST_FUNCTION(jsFunctionIsDeepStrictEqual,
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe));
+
+JSC_DEFINE_HOST_FUNCTION(jsFunctionPartialDeepStrictEqual,
+    (JSC::JSGlobalObject * globalObject,
+        JSC::CallFrame* callframe));
+
 namespace Zig {
 
 // Hardcoded module "node:util/types"
diff --git a/src/jsc/resolve_message.classes.ts b/src/jsc/resolve_message.classes.ts
index a3ef7c1f90ba..1f9a21dce02d 100644
--- a/src/jsc/resolve_message.classes.ts
+++ b/src/jsc/resolve_message.classes.ts
@@ -6,6 +6,8 @@ export default [
     construct: true,
     finalize: true,
     configurable: false,
+    // Error.prototype in the chain: userland checks `err instanceof Error`.
+    prototypeBase: "Error",
     klass: {},
     JSType: "0b11101110",
     proto: {
@@ -18,6 +20,15 @@ export default [
         getter: "getCode",
         cache: true,
       },
+      requireStack: {
+        getter: "getRequireStack",
+        cache: true,
+      },
+      stack: {
+        getter: "getStack",
+        cache: true,
+        writable: true,
+      },
       name: {
         value: "ResolveMessage",
       },
@@ -65,6 +76,9 @@ export default [
 
   define({
     name: "BuildMessage",
+    // Error.prototype in the chain, matching ResolveMessage: userland checks
+    // `err instanceof Error` on syntax/build failures too.
+    prototypeBase: "Error",
     construct: true,
     finalize: true,
     configurable: false,
diff --git a/src/jsc/web_worker.rs b/src/jsc/web_worker.rs
index 55e9736de75c..90d0b0daab0b 100644
--- a/src/jsc/web_worker.rs
+++ b/src/jsc/web_worker.rs
@@ -1307,13 +1307,11 @@ impl WebWorker {
             // or observes m_isShuttingDown under m_lock and drops. Idempotent;
             // teardownJSCVM sets it again.
             Bun__JSCTaskScheduler__markShuttingDown(vm.global());
-            // Reclaim queued CppTasks (the per-worker stdio/messaging
-            // MessagePort drain tasks that can be in self.tasks mid-tick when
-            // terminate() lands, and any Worker dispatchExit close task from a
-            // sub-worker) while JSC is still live: ~Ref<Worker> walks
-            // ~JSEventListener Weak<> handles, and after teardownJSCVM the
-            // worker VM is dealloc'd-without-Drop so anything still in
-            // self.tasks leaks. Mirrors the global_exit() ordering.
+            // Reclaim queued CppTasks while JSC is still live (after teardownJSCVM the worker VM is
+            // dealloc'd-without-Drop so anything still in self.tasks leaks). Work-pool fs completions
+            // post without a shutdown check; wait for in-flight ones so the drain below sees every
+            // post.
+            vm.event_loop_mut().wait_for_concurrent_posters();
             vm.event_loop_mut().release_queued_tasks_for_shutdown();
             if let Some(rare) = vm.rare_data.as_deref_mut() {
                 rare.release_js_handles();
diff --git a/src/options_types/context.rs b/src/options_types/context.rs
index 32068217f6fb..4190731b8ed8 100644
--- a/src/options_types/context.rs
+++ b/src/options_types/context.rs
@@ -334,6 +334,9 @@ pub struct DebugOptions {
     pub dump_environment_variables: bool,
     pub silent: bool,
     pub hot_reload: HotReload,
+    /// `--watch-kill-signal`: signal whose JS handlers run before a `--watch`
+    /// reload (node delivers this signal to its watched child; default SIGTERM).
+    pub watch_kill_signal: bun_core::SignalCode,
     pub global_cache: GlobalCache,
     pub offline_mode_setting: Option<OfflineMode>,
     pub run_in_bun: bool,
@@ -358,6 +361,7 @@ impl Default for DebugOptions {
             dump_environment_variables: false,
             silent: false,
             hot_reload: HotReload::None,
+            watch_kill_signal: bun_core::SignalCode::DEFAULT,
             global_cache: GlobalCache::auto,
             offline_mode_setting: None,
             run_in_bun: false,
diff --git a/src/resolve_builtins/HardcodedModule.rs b/src/resolve_builtins/HardcodedModule.rs
index 74e98600f720..074d920cef4b 100644
--- a/src/resolve_builtins/HardcodedModule.rs
+++ b/src/resolve_builtins/HardcodedModule.rs
@@ -165,6 +165,8 @@ pub enum HardcodedModule {
     NodeStreamWritableInternal,
     #[strum(serialize = "node:_tls_common")]
     NodeTlsCommonInternal,
+    #[strum(serialize = "node:_tls_wrap")]
+    NodeTlsWrapInternal,
     #[strum(serialize = "node:_http_agent")]
     NodeHttpAgentInternal,
     #[strum(serialize = "node:_http_client")]
@@ -282,6 +284,7 @@ bun_core::comptime_string_map! {
         b"node:_stream_wrap" => HardcodedModule::NodeStreamWrapInternal,
         b"node:_stream_writable" => HardcodedModule::NodeStreamWritableInternal,
         b"node:_tls_common" => HardcodedModule::NodeTlsCommonInternal,
+        b"node:_tls_wrap" => HardcodedModule::NodeTlsWrapInternal,
         b"node:_http_agent" => HardcodedModule::NodeHttpAgentInternal,
         b"node:_http_client" => HardcodedModule::NodeHttpClientInternal,
         b"node:_http_common" => HardcodedModule::NodeHttpCommonInternal,
@@ -615,7 +618,7 @@ const COMMON_ALIAS_KVS: &[AliasKv] = &[
     (
         b"node:_tls_wrap",
         Alias {
-            path: zstr!("node:tls"),
+            path: zstr!("node:_tls_wrap"),
             tag: import_record::Tag::Builtin,
             node_builtin: true,
             node_only_prefix: false,
@@ -687,7 +690,7 @@ const COMMON_ALIAS_KVS: &[AliasKv] = &[
     (
         b"_tls_wrap",
         Alias {
-            path: zstr!("node:tls"),
+            path: zstr!("node:_tls_wrap"),
             tag: import_record::Tag::Builtin,
             node_builtin: true,
             node_only_prefix: false,
diff --git a/src/runtime/cli/Arguments.rs b/src/runtime/cli/Arguments.rs
index e5b2e4f8b30f..0ace6e3b893f 100644
--- a/src/runtime/cli/Arguments.rs
+++ b/src/runtime/cli/Arguments.rs
@@ -161,6 +161,9 @@ const RUNTIME_PARAMS_: &[ParamType] = &[
     parse_param!(
         "--watch                           Automatically restart the process on file change"
     ),
+    parse_param!(
+        "--watch-kill-signal <STR>         Signal whose handlers run when --watch restarts the process (default: \"SIGTERM\")"
+    ),
     parse_param!(
         "--hot                             Enable auto reload in the Bun runtime, test runner, or bundler"
     ),
@@ -199,7 +202,7 @@ const RUNTIME_PARAMS_: &[ParamType] = &[
         "--cpu-prof-interval <STR>         Specify the sampling interval in microseconds for CPU profiling (default: 1000)"
     ),
     parse_param!(
-        "--heap-prof                       Generate V8 heap snapshot on exit (.heapsnapshot)"
+        "--heap-prof                       Write a heap profile to disk on exit (.heapprofile)"
     ),
     parse_param!("--heap-prof-name <STR>            Specify the name of the heap profile file"),
     parse_param!(
@@ -208,6 +211,9 @@ const RUNTIME_PARAMS_: &[ParamType] = &[
     parse_param!(
         "--heap-prof-md                    Generate markdown heap profile on exit (for CLI analysis)"
     ),
+    parse_param!(
+        "--heap-prof-interval <STR>        Specify the average sampling interval in bytes for heap profiling (default: 524288)"
+    ),
     parse_param!(
         "--if-present                      Exit without an error if the entrypoint does not exist"
     ),
@@ -719,6 +725,26 @@ pub(crate) static Bun__Node__ProcessTraceDeprecation: core::sync::atomic::Atomic
 pub(crate) static Bun__Node__ProcessPendingDeprecation: core::sync::atomic::AtomicBool =
     core::sync::atomic::AtomicBool::new(false);
 
+/// Node parity: `--cpu-prof-name` supports a `${pid}` placeholder.
+fn replace_pid_placeholder(name: &[u8]) -> Box<[u8]> {
+    if !bun_core::strings::contains(name, b"${pid}") {
+        return name.into();
+    }
+    let pid = std::process::id().to_string();
+    let mut out = Vec::with_capacity(name.len() + pid.len());
+    let mut i = 0;
+    while i < name.len() {
+        if name[i..].starts_with(b"${pid}") {
+            out.extend_from_slice(pid.as_bytes());
+            i += 6;
+        } else {
+            out.push(name[i]);
+            i += 1;
+        }
+    }
+    out.into_boxed_slice()
+}
+
 #[repr(u8)]
 #[derive(Copy, Clone, PartialEq, Eq)]
 pub(crate) enum BunCAStore {
@@ -739,6 +765,11 @@ pub(crate) static Bun__Node__UseSystemCA: core::sync::atomic::AtomicBool =
 // `crate::cli::arguments::load_config*` callers are unaffected.
 pub use bun_bunfig::arguments::{load_config, load_config_path, load_config_with_cmd_args};
 
+/// node aliases `-pe` to `--print --eval` as a whole token (node_options.cc):
+/// it can't be a short in either runtime, being ambiguous with `-p` carrying
+/// the attached value `e`. Bun's `-p` takes the code, so `-pe X` is `-p X`.
+pub const NODE_SHORT_ALIASES: &[(&[u8], &[u8])] = &[(b"-pe", b"-p")];
+
 /// Parse `argv` into `api::TransformOptions` for the given subcommand.
 ///
 /// `command::tag_params(cmd)` does a runtime lookup of the per-subcommand
@@ -757,6 +788,11 @@ pub(crate) fn parse(cmd: CommandTag, ctx: Context<'_>) -> crate::Result<api::Tra
                 CommandTag::AutoCommand | CommandTag::RunAsNodeCommand => 1,
                 _ => 0,
             },
+            // Only the paths standing in for `node` get node's aliases.
+            short_aliases: match cmd {
+                CommandTag::AutoCommand | CommandTag::RunAsNodeCommand => NODE_SHORT_ALIASES,
+                _ => &[],
+            },
         },
     ) {
         Ok(a) => a,
@@ -793,8 +829,15 @@ pub(crate) fn parse(cmd: CommandTag, ctx: Context<'_>) -> crate::Result<api::Tra
     // so we dupe into a plain `Box<[u8]>`.
     let cwd: Box<[u8]> = if let Some(cwd_arg) = args.option(b"--cwd") {
         let mut outbuf = PathBuffer::uninit();
-        let cwd_len = bun_sys::getcwd(&mut *outbuf)?;
-        let out = resolve_path::join_abs::<platform::Loose>(&outbuf[..cwd_len], cwd_arg);
+        // An absolute --cwd needs no base; a relative one still requires a
+        // live cwd (an exe-dir base would silently chdir somewhere else).
+        let base: &[u8] = if bun_paths::is_absolute(cwd_arg) {
+            b"/"
+        } else {
+            let len = bun_sys::getcwd(&mut *outbuf)?;
+            &outbuf[..len]
+        };
+        let out = resolve_path::join_abs::<platform::Loose>(base, cwd_arg);
         // `chdir` wants a NUL-terminated path; `join_abs` returns a borrowed
         // slice into a threadlocal buffer, so dupe-Z once and reuse for both
         // the `chdir` arg and the stored `absolute_working_dir`.
@@ -807,8 +850,24 @@ pub(crate) fn parse(cmd: CommandTag, ctx: Context<'_>) -> crate::Result<api::Tra
             );
             Global::exit(1);
         }
-        Box::<[u8]>::from(out_z.as_bytes())
+        // Store the post-chdir physical path (mirrors process.chdir) so
+        // process.cwd(), path.resolve, and the resolver agree on one form.
+        let mut phys = PathBuffer::uninit();
+        match bun_core::getcwd(&mut phys) {
+            Ok(p) => Box::<[u8]>::from(p.as_bytes()),
+            Err(_) => Box::<[u8]>::from(out_z.as_bytes()),
+        }
+    } else if matches!(
+        cmd,
+        CommandTag::AutoCommand | CommandTag::RunCommand | CommandTag::RunAsNodeCommand
+    ) {
+        // A deleted cwd must not abort the runtime (Node boots and lets
+        // `process.cwd()` throw later); fall back to the executable's dir.
+        let mut temp = PathBuffer::uninit();
+        Box::<[u8]>::from(bun_core::getcwd_or_exe_dir(&mut temp).as_bytes())
     } else {
+        // Everything else (install/test/build/...) must not silently act on
+        // whatever project happens to live above the executable.
         let mut temp = PathBuffer::uninit();
         let len = bun_sys::getcwd(&mut *temp)?;
         Box::<[u8]>::from(&temp[..len])
@@ -1009,6 +1068,27 @@ pub(crate) fn parse(cmd: CommandTag, ctx: Context<'_>) -> crate::Result<api::Tra
             }
         }
 
+        if let Some(kill_signal) = args.option(b"--watch-kill-signal") {
+            // Node reads --watch-kill-signal only in watch mode; elsewhere it is
+            // accepted and ignored. Matching is case-insensitive (node uppercases).
+            if ctx.debug.hot_reload == HotReload::Watch {
+                let upper = kill_signal.to_ascii_uppercase();
+                match bun_core::SignalCode::from_name(&upper)
+                    .filter(|s| s.platform_number().is_some())
+                {
+                    Some(sig) => ctx.debug.watch_kill_signal = sig,
+                    None => {
+                        Output::print_errorln(format_args!(
+                            "TypeError [ERR_UNKNOWN_SIGNAL]: Unknown signal: {}",
+                            bstr::BStr::new(kill_signal)
+                        ));
+                        Output::flush();
+                        Global::exit(1);
+                    }
+                }
+            }
+        }
+
         if let Some(origin) = args.option(b"--origin") {
             opts.origin = Some(origin.into());
         }
@@ -1236,7 +1316,7 @@ pub(crate) fn parse(cmd: CommandTag, ctx: Context<'_>) -> crate::Result<api::Tra
         if cpu_prof_flag || cpu_prof_md_flag {
             ctx.runtime_options.cpu_prof.enabled = true;
             if let Some(name) = args.option(b"--cpu-prof-name") {
-                ctx.runtime_options.cpu_prof.name = name.into();
+                ctx.runtime_options.cpu_prof.name = replace_pid_placeholder(name);
             }
             if let Some(dir) = args.option(b"--cpu-prof-dir") {
                 ctx.runtime_options.cpu_prof.dir = dir.into();
@@ -1250,21 +1330,32 @@ pub(crate) fn parse(cmd: CommandTag, ctx: Context<'_>) -> crate::Result<api::Tra
                     strings::parse_int::<u32>(interval_str, 10).unwrap_or(1000);
             }
         } else {
-            // Warn if --cpu-prof-name or --cpu-prof-dir is used without a profiler flag
+            // Node parity: profiler-scoped options without a profiler flag are a
+            // usage error printed as "<argv0>: <flag> must be used with --cpu-prof"
+            // and exit code 9. The default interval value is a noop, like node.
+            let mut bad_flags: [Option<&str>; 3] = [None, None, None];
             if args.option(b"--cpu-prof-name").is_some() {
-                bun_core::warn!(
-                    "--cpu-prof-name requires --cpu-prof or --cpu-prof-md to be enabled"
-                );
+                bad_flags[0] = Some("--cpu-prof-name");
             }
             if args.option(b"--cpu-prof-dir").is_some() {
-                bun_core::warn!(
-                    "--cpu-prof-dir requires --cpu-prof or --cpu-prof-md to be enabled"
-                );
+                bad_flags[1] = Some("--cpu-prof-dir");
             }
-            if args.option(b"--cpu-prof-interval").is_some() {
-                bun_core::warn!(
-                    "--cpu-prof-interval requires --cpu-prof or --cpu-prof-md to be enabled",
-                );
+            if let Some(interval_str) = args.option(b"--cpu-prof-interval") {
+                if strings::parse_int::<u32>(interval_str, 10).unwrap_or(0) != 1000 {
+                    bad_flags[2] = Some("--cpu-prof-interval");
+                }
+            }
+            if bad_flags.iter().any(Option::is_some) {
+                let argv0 = bun_core::argv().get(0).unwrap_or(bun_core::zstr!("bun"));
+                for flag in bad_flags.into_iter().flatten() {
+                    bun_core::pretty_errorln!(
+                        "{}: {} must be used with --cpu-prof",
+                        BStr::new(argv0.as_bytes()),
+                        flag
+                    );
+                }
+                Output::flush();
+                Global::exit(9);
             }
         }
 
@@ -1285,6 +1376,8 @@ pub(crate) fn parse(cmd: CommandTag, ctx: Context<'_>) -> crate::Result<api::Tra
                 ctx.runtime_options.heap_prof.dir = dir.into();
             }
         } else if heap_prof_v8 || heap_prof_md {
+            // --heap-prof-interval is accepted for node CLI parity but unused:
+            // JSC has no allocation-site sampler to configure.
             ctx.runtime_options.heap_prof.enabled = true;
             ctx.runtime_options.heap_prof.text_format = heap_prof_md;
             if let Some(name) = args.option(b"--heap-prof-name") {
@@ -1294,16 +1387,32 @@ pub(crate) fn parse(cmd: CommandTag, ctx: Context<'_>) -> crate::Result<api::Tra
                 ctx.runtime_options.heap_prof.dir = dir.into();
             }
         } else {
-            // Warn if --heap-prof-name or --heap-prof-dir is used without --heap-prof or --heap-prof-md
+            // Node parity: heap-profiler-scoped options without a profiler flag
+            // exit 9, like the --cpu-prof block above. The default interval
+            // value (512 KiB) is a noop, like node.
+            let mut bad_flags: [Option<&str>; 3] = [None, None, None];
             if args.option(b"--heap-prof-name").is_some() {
-                bun_core::warn!(
-                    "--heap-prof-name requires --heap-prof or --heap-prof-md to be enabled",
-                );
+                bad_flags[0] = Some("--heap-prof-name");
             }
             if args.option(b"--heap-prof-dir").is_some() {
-                bun_core::warn!(
-                    "--heap-prof-dir requires --heap-prof or --heap-prof-md to be enabled",
-                );
+                bad_flags[1] = Some("--heap-prof-dir");
+            }
+            if let Some(interval_str) = args.option(b"--heap-prof-interval") {
+                if strings::parse_int::<u32>(interval_str, 10).unwrap_or(0) != 512 * 1024 {
+                    bad_flags[2] = Some("--heap-prof-interval");
+                }
+            }
+            if bad_flags.iter().any(Option::is_some) {
+                let argv0 = bun_core::argv().get(0).unwrap_or(bun_core::zstr!("bun"));
+                for flag in bad_flags.into_iter().flatten() {
+                    bun_core::pretty_errorln!(
+                        "{}: {} must be used with --heap-prof",
+                        BStr::new(argv0.as_bytes()),
+                        flag
+                    );
+                }
+                Output::flush();
+                Global::exit(9);
             }
         }
 
@@ -1325,7 +1434,9 @@ pub(crate) fn parse(cmd: CommandTag, ctx: Context<'_>) -> crate::Result<api::Tra
         if args.flag(b"--trace-deprecation") {
             Bun__Node__ProcessTraceDeprecation.store(true, core::sync::atomic::Ordering::Relaxed);
         }
-        if args.flag(b"--pending-deprecation") {
+        if args.flag(b"--pending-deprecation")
+            || env_var::NODE_PENDING_DEPRECATION.get() == Some(b"1" as &[u8])
+        {
             Bun__Node__ProcessPendingDeprecation.store(true, core::sync::atomic::Ordering::Relaxed);
         }
         if let Some(path) = args.option(b"--redirect-warnings") {
diff --git a/src/runtime/cli/mod.rs b/src/runtime/cli/mod.rs
index 5aae85d24132..292db89d5bfd 100644
--- a/src/runtime/cli/mod.rs
+++ b/src/runtime/cli/mod.rs
@@ -954,6 +954,9 @@ pub mod command {
             && first_arg_name[0] == b'-'
             && !(first_arg_name.len() > 1 && first_arg_name[1] == b'e')
         {
+            // `--interactive` stays on AutoCommand: Arguments.rs parses it and the no-target check
+            // routes to RunCommand::exec_node_repl. An early ReplCommand return here would bypass
+            // that and boot the legacy `bun repl` implementation instead.
             match iter.next() {
                 Some(n) => first_arg_name = n,
                 None => return Tag::AutoCommand,
diff --git a/src/runtime/cli/repl.rs b/src/runtime/cli/repl.rs
index cd43e246cfff..1c5ca4732d00 100644
--- a/src/runtime/cli/repl.rs
+++ b/src/runtime/cli/repl.rs
@@ -1209,6 +1209,18 @@ impl<'a> Repl<'a> {
     }
 
     fn refresh_line(&self) {
+        // Non-TTY mirrors node's terminal:false repl: input is never echoed/redrawn — per-key
+        // CLEAR_LINE rewrites fill a socketpair's send buffer and wedge write(2) after a few
+        // hundred keystrokes. Print the prompt once when a fresh line begins, like node.
+        if !self.is_tty {
+            if self.line_editor.buffer.is_empty() && self.input_mode == InputMode::Normal {
+                Output::flush();
+                self.write(self.get_prompt());
+                Output::flush();
+            }
+            return;
+        }
+
         // Flush any buffered output (e.g., from console.log in JS) before drawing prompt
         Output::flush();
 
diff --git a/src/runtime/cli/run_command.rs b/src/runtime/cli/run_command.rs
index a5aca35765ee..0e37e83b9cde 100644
--- a/src/runtime/cli/run_command.rs
+++ b/src/runtime/cli/run_command.rs
@@ -1013,7 +1013,7 @@ Full documentation is available at <magenta>https://bun.com/docs/cli/run<r>
 
             // entry_path must end with /[eval] for the transpiler to use eval_source
             let mut cwd_buf = PathBuffer::uninit();
-            let cwd = bun_core::getcwd(&mut cwd_buf)?;
+            let cwd = bun_core::getcwd_or_exe_dir(&mut cwd_buf);
             let cwd_bytes = cwd.as_bytes();
             let mut eval_path: Vec<u8> = Vec::with_capacity(cwd_bytes.len() + EVAL_TRIGGER.len());
             eval_path.extend_from_slice(cwd_bytes);
@@ -1476,6 +1476,9 @@ impl Run {
                         Some(entry),
                     )
                 }
+                bun_jsc::posix_signal_handle::enable_watch_mode_signals(
+                    ctx.debug.watch_kill_signal,
+                );
             }
             _ => {}
         }
@@ -2900,7 +2903,7 @@ impl RunCommand {
 
         let mut entry_point_buf = [0u8; MAX_PATH_BYTES + STDIN_TRIGGER.len()];
         let mut cwd_buf = PathBuffer::uninit();
-        let cwd = bun_core::getcwd(&mut cwd_buf)?;
+        let cwd = bun_core::getcwd_or_exe_dir(&mut cwd_buf);
         let cwd_bytes = cwd.as_bytes();
         let cwd_len = cwd_bytes.len();
         entry_point_buf[..cwd_len].copy_from_slice(cwd_bytes);
@@ -2962,7 +2965,7 @@ impl RunCommand {
 
         let mut entry_point_buf = [0u8; MAX_PATH_BYTES + EVAL_TRIGGER.len()];
         let mut cwd_buf = PathBuffer::uninit();
-        let cwd = bun_core::getcwd(&mut cwd_buf)?;
+        let cwd = bun_core::getcwd_or_exe_dir(&mut cwd_buf);
         let cwd_bytes = cwd.as_bytes();
         let cwd_len = cwd_bytes.len();
         entry_point_buf[..cwd_len].copy_from_slice(cwd_bytes);
@@ -2997,7 +3000,7 @@ impl RunCommand {
             // synthetic `[eval]` path under cwd
             let mut entry_point_buf = [0u8; MAX_PATH_BYTES + EVAL_TRIGGER.len()];
             let mut cwd_buf = PathBuffer::uninit();
-            let cwd = bun_core::getcwd(&mut cwd_buf)?;
+            let cwd = bun_core::getcwd_or_exe_dir(&mut cwd_buf);
             let cwd_bytes = cwd.as_bytes();
             let cwd_len = cwd_bytes.len();
             entry_point_buf[..cwd_len].copy_from_slice(cwd_bytes);
@@ -3031,7 +3034,7 @@ impl RunCommand {
             // platform separator) and then run the result through
             // `join_abs_string_buf::<Loose>` to collapse `.`/`..`.
             let mut cwd_buf = PathBuffer::uninit();
-            let cwd = bun_core::getcwd(&mut cwd_buf)?;
+            let cwd = bun_core::getcwd_or_exe_dir(&mut cwd_buf);
             let cwd_len = cwd.as_bytes().len();
             cwd_buf[cwd_len] = b'/';
             let mut out_buf = PathBuffer::uninit();
@@ -3184,9 +3187,9 @@ impl RunCommand {
         let mut entry_point_buf = [0u8; MAX_PATH_BYTES + EVAL_TRIGGER.len()];
         // SAFETY: bun_paths::PathBuffer and bun_core::PathBuffer are
         // layout-identical newtypes over [u8; MAX_PATH_BYTES].
-        let cwd = bun_core::getcwd(unsafe {
+        let cwd = bun_core::getcwd_or_exe_dir(unsafe {
             &mut *entry_point_buf.as_mut_ptr().cast::<bun_core::PathBuffer>()
-        })?;
+        });
         let cwd_len = cwd.as_bytes().len();
         entry_point_buf[cwd_len..cwd_len + EVAL_TRIGGER.len()].copy_from_slice(EVAL_TRIGGER);
 
diff --git a/src/runtime/dispatch.rs b/src/runtime/dispatch.rs
index be6acfc62626..654b15564441 100644
--- a/src/runtime/dispatch.rs
+++ b/src/runtime/dispatch.rs
@@ -463,6 +463,14 @@ pub(crate) fn run_task(
             unsafe { hot_reloader::HotReloadTask::deinit(t) };
             return Ok(RunTaskResult::EarlyReturn);
         }
+        task_tag::WatchReloadTask => {
+            let t = cast_ptr!(hot_reloader::WatchReloadTask);
+            // SAFETY: tag identifies pointee; live Box'd WatchReloadTask.
+            unsafe { (*t).run() };
+            // SAFETY: paired with heap::alloc in `Task::enqueue`.
+            unsafe { hot_reloader::WatchReloadTask::deinit(t) };
+            return Ok(RunTaskResult::EarlyReturn);
+        }
         // ── bake dev-server (cold — hoisted to `run_task_cold`) ──────────
         task_tag::BakeHotReloadEvent => run_task_cold(task),
         task_tag::FSWatchTask => {
@@ -690,7 +698,7 @@ fn run_task_cold(task: Task) {
 /// Compile-time guard that the arm count above tracks
 /// `bun_event_loop::task_tag::COUNT`. Bump when adding a variant.
 const _: () = assert!(
-    task_tag::COUNT == 111,
+    task_tag::COUNT == 112,
     "dispatch::run_task arm count out of sync with bun_event_loop::task_tag",
 );
 
diff --git a/src/runtime/ipc.rs b/src/runtime/ipc.rs
index 34572411dd39..fbab0e9ea043 100644
--- a/src/runtime/ipc.rs
+++ b/src/runtime/ipc.rs
@@ -275,7 +275,10 @@ mod advanced {
     const HEADER_LENGTH: usize = size_of::<IPCMessageType>() + size_of::<u32>();
     // HEADER_LENGTH is a 5-byte compile-time constant; narrowing to u32 is provably safe.
     const HEADER_LENGTH_U32: u32 = HEADER_LENGTH as u32;
-    const VERSION: u32 = 1;
+    // v2 added `SerializedMessageWithBuffers`. The peer's advertised version is
+    // debug-logged, never consulted, so mixed-version pairs only break when a
+    // Buffer-bearing message actually crosses to a v1 peer.
+    const VERSION: u32 = 2;
 
     #[repr(u8)]
     #[derive(Copy, Clone, Eq, PartialEq)]
@@ -283,6 +286,10 @@ mod advanced {
         Version = 1,
         SerializedMessage = 2,
         SerializedInternalMessage = 3,
+        /// A `[message, buffers]` envelope so the receiver can restore Buffer prototypes (JSC's
+        /// serializer has no host-object hook). Only emitted when Buffers are present, so plain
+        /// messages keep the version-1 wire format.
+        SerializedMessageWithBuffers = 4,
     }
     // SAFETY: `#[repr(u8)]` fieldless enum → size 1, align 1, no padding,
     // `Copy + 'static`; the single byte is always an initialized discriminant.
@@ -294,6 +301,7 @@ mod advanced {
                 1 => "Version",
                 2 => "SerializedMessage",
                 3 => "SerializedInternalMessage",
+                4 => "SerializedMessageWithBuffers",
                 _ => "unknown",
             }
         }
@@ -336,7 +344,8 @@ mod advanced {
                 message: DecodedIPCMessage::Version(message_len),
             }),
             x if x == IPCMessageType::SerializedMessage as u8
-                || x == IPCMessageType::SerializedInternalMessage as u8 =>
+                || x == IPCMessageType::SerializedInternalMessage as u8
+                || x == IPCMessageType::SerializedMessageWithBuffers as u8 =>
             {
                 if message_len > u32::MAX - HEADER_LENGTH_U32 {
                     return Err(IPCDecodeError::InvalidFormat);
@@ -356,7 +365,10 @@ mod advanced {
                 }
 
                 let message = &data[HEADER_LENGTH..][..message_len as usize];
-                let deserialized = JSValue::deserialize(message, global)?;
+                let mut deserialized = JSValue::deserialize(message, global)?;
+                if x == IPCMessageType::SerializedMessageWithBuffers as u8 {
+                    deserialized = ipc_restore_advanced_buffers(global, deserialized)?;
+                }
 
                 Ok(DecodeIPCMessageResult {
                     bytes_consumed: HEADER_LENGTH_U32 + message_len,
@@ -388,6 +400,24 @@ mod advanced {
         value: JSValue,
         is_internal: IsInternal,
     ) -> Result<usize, IPCSerializationError> {
+        // Internal (control) messages never carry user Buffers, and the
+        // hardcoded ack/nack packets depend on their bare wire shape.
+        let (value, message_type) = match is_internal {
+            IsInternal::Internal => (value, IPCMessageType::SerializedInternalMessage),
+            IsInternal::External => {
+                let tagged = ipc_tag_advanced_buffers(global, value).map_err(|e| match e {
+                    JsError::Thrown => IPCSerializationError::JSError,
+                    JsError::Terminated => IPCSerializationError::JSTerminated,
+                    JsError::OutOfMemory => IPCSerializationError::OutOfMemory,
+                })?;
+                if tagged.is_null() {
+                    (value, IPCMessageType::SerializedMessage)
+                } else {
+                    (tagged, IPCMessageType::SerializedMessageWithBuffers)
+                }
+            }
+        };
+
         let serialized = value
             .serialize(
                 global,
@@ -414,10 +444,7 @@ mod advanced {
             .ensure_unused_capacity(payload_length)
             .map_err(|_| IPCSerializationError::OutOfMemory)?;
 
-        writer.write_type_as_bytes_assume_capacity(match is_internal {
-            IsInternal::Internal => IPCMessageType::SerializedInternalMessage,
-            IsInternal::External => IPCMessageType::SerializedMessage,
-        });
+        writer.write_type_as_bytes_assume_capacity(message_type);
         writer.write_type_as_bytes_assume_capacity(size);
         writer.write_assume_capacity(serialized.data());
 
@@ -2250,6 +2277,25 @@ pub fn ipc_serialize(
     bun_jsc::cpp::IPCSerialize(global_object, message, handle)
 }
 
+#[track_caller]
+pub(crate) fn ipc_tag_advanced_buffers(
+    global_object: &JSGlobalObject,
+    message: JSValue,
+) -> JsResult<JSValue> {
+    // `[[ZIG_EXPORT(zero_is_throw)]]`; returns null when the message holds no
+    // Buffers, else the `[message, buffers]` envelope (see Ipc.ts).
+    bun_jsc::cpp::IPCTagAdvancedBuffers(global_object, message)
+}
+
+#[track_caller]
+pub(crate) fn ipc_restore_advanced_buffers(
+    global_object: &JSGlobalObject,
+    envelope: JSValue,
+) -> JsResult<JSValue> {
+    // `[[ZIG_EXPORT(zero_is_throw)]]`
+    bun_jsc::cpp::IPCRestoreAdvancedBuffers(global_object, envelope)
+}
+
 #[track_caller]
 pub(crate) fn ipc_parse(
     global_object: &JSGlobalObject,
diff --git a/src/runtime/jsc_hooks.rs b/src/runtime/jsc_hooks.rs
index cd6e9a438d65..54129cc2ea66 100644
--- a/src/runtime/jsc_hooks.rs
+++ b/src/runtime/jsc_hooks.rs
@@ -2025,6 +2025,20 @@ fn to_jsc_fetch_error(err: &crate::Error) -> bun_jsc::CrateError {
         _ => bun_jsc::CrateError::ParseError,
     }
 }
+/// Shared guard for the two parse-failure exits: register the module with the
+/// Node compile cache (Unknown module type maps to CJS, matching Node).
+fn note_compile_cache_parse_failure(
+    path: &bun_resolver::fs::Path<'_>,
+    loader: Loader,
+    module_type: ModuleType,
+) {
+    if bun_jsc::node_compile_cache::is_enabled() && loader.is_java_script_like() && path.is_file() {
+        bun_jsc::node_compile_cache::note_parse_failure(
+            path.text,
+            !matches!(module_type, ModuleType::Esm),
+        );
+    }
+}
 
 /// `ModuleLoader.transpileSourceCode(...)` — the runtime-transpiler path:
 /// read file → `Transpiler::parse`
@@ -2594,6 +2608,9 @@ fn transpile_source_code_inner(
                         );
                     }
                     arena_guard.2 = false; // give_back_arena = false
+                    // Node compile cache: record the failed module so exit-time
+                    // persist logs the "was not initialized" skip (Node parity).
+                    note_compile_cache_parse_failure(path, loader, module_type);
                     return Err(crate::Error::ParseError);
                 };
 
@@ -2647,6 +2664,9 @@ fn transpile_source_code_inner(
                 // `transpiler.log` was swapped to non-null `args.log` above.
                 if unsafe { (*(*jsc_vm).transpiler.log).errors > 0 } {
                     arena_guard.2 = false;
+                    // Node compile cache: record the failed module so exit-time
+                    // persist logs the "was not initialized" skip (Node parity).
+                    note_compile_cache_parse_failure(path, loader, module_type);
                     return Err(crate::Error::ParseError);
                 }
 
@@ -2834,6 +2854,23 @@ fn transpile_source_code_inner(
                     } else {
                         core::ptr::null_mut()
                     };
+                    let is_commonjs_module = entry.metadata.module_type == CacheModuleType::Cjs;
+                    // Node compile cache hook (transpiler-cache-hit path); must
+                    // read `output_code` before it is consumed below. UTF-16
+                    // output would hash differently than the print path — skip.
+                    let node_compile_cache_blob = if bun_jsc::node_compile_cache::is_enabled()
+                        && source.path.is_file()
+                        && loader.is_java_script_like()
+                        && !matches!(&entry.output_code, OutputCode::String(s) if s.is_utf16())
+                    {
+                        bun_jsc::node_compile_cache::fetch(
+                            source.path.text,
+                            is_commonjs_module,
+                            entry.output_code.byte_slice(),
+                        )
+                    } else {
+                        None
+                    };
                     let source_code = match &mut entry.output_code {
                         OutputCode::String(s) => *s,
                         OutputCode::Utf8(utf8) => {
@@ -2842,7 +2879,6 @@ fn transpile_source_code_inner(
                             result
                         }
                     };
-                    let is_commonjs_module = entry.metadata.module_type == CacheModuleType::Cjs;
                     // When the cached entry was detected as
                     // CJS but lives inside a `"type":"module"` package, emit
                     // `package_json_type_module` so the C++ loader applies the
@@ -2893,6 +2929,8 @@ fn transpile_source_code_inner(
                     } else {
                         ResolvedSourceTag::Javascript
                     };
+                    let (bytecode_cache, bytecode_cache_size) =
+                        node_compile_cache_blob.unwrap_or((core::ptr::null_mut(), 0));
                     return Ok(OwnedResolvedSource::from(ResolvedSource {
                         source_code,
                         specifier: input_specifier.dupe_ref(),
@@ -2900,6 +2938,8 @@ fn transpile_source_code_inner(
                         is_commonjs_module,
                         module_info,
                         tag,
+                        bytecode_cache,
+                        bytecode_cache_size,
                         ..Default::default()
                     }));
                 }
@@ -3080,11 +3120,20 @@ fn transpile_source_code_inner(
                     // (Stacked Borrows — see the matching note below).
                     let printer: &mut bun_js_printer::BufferPrinter =
                         unsafe { &mut *(*extra).source_code_printer };
+                    let written = printer.ctx.get_written();
+                    let node_compile_cache_blob = if bun_jsc::node_compile_cache::is_enabled()
+                        && path.is_file()
+                        && loader.is_java_script_like()
+                    {
+                        bun_jsc::node_compile_cache::fetch(path.text, is_commonjs_module, written)
+                    } else {
+                        None
+                    };
                     // SAFETY: per fn contract — `jsc_vm` is the live per-thread
                     // VM; `printer.ctx.get_written()` borrows thread-local data.
                     let mut resolved_source = unsafe {
                         (*jsc_vm).ref_counted_resolved_source::<false>(
-                            printer.ctx.get_written(),
+                            written,
                             input_specifier.dupe_ref(),
                             path.text,
                             None,
@@ -3092,6 +3141,10 @@ fn transpile_source_code_inner(
                     };
                     resolved_source.is_commonjs_module = is_commonjs_module;
                     resolved_source.module_info = module_info;
+                    if let Some((ptr, size)) = node_compile_cache_blob {
+                        resolved_source.bytecode_cache = ptr;
+                        resolved_source.bytecode_cache_size = size;
+                    }
                     return Ok(OwnedResolvedSource::from(resolved_source));
                 }
 
@@ -3152,6 +3205,16 @@ fn transpile_source_code_inner(
                 let printer: &mut bun_js_printer::BufferPrinter =
                     unsafe { &mut *(*extra).source_code_printer };
                 let written = printer.ctx.get_written();
+                // Node compile cache hook (sync transpile path). `fetch` copies
+                // `written`; the printer may be replaced below.
+                let node_compile_cache_blob = if bun_jsc::node_compile_cache::is_enabled()
+                    && path.is_file()
+                    && loader.is_java_script_like()
+                {
+                    bun_jsc::node_compile_cache::fetch(path.text, is_commonjs_module, written)
+                } else {
+                    None
+                };
                 // The `Jsc` vtable bridge `put()` does not write
                 // `cache.output_code` (only the `r#impl == None` fallback
                 // does, and `r#impl` is `Some(Jsc)` here), so it is always
@@ -3173,6 +3236,8 @@ fn transpile_source_code_inner(
                 // (fd close handled by `_fd_guard` registered above; spec
                 // :251-256 `defer` fires on every exit path.)
 
+                let (bytecode_cache, bytecode_cache_size) =
+                    node_compile_cache_blob.unwrap_or((core::ptr::null_mut(), 0));
                 return Ok(OwnedResolvedSource::from(ResolvedSource {
                     source_code,
                     specifier: input_specifier.dupe_ref(),
@@ -3180,6 +3245,8 @@ fn transpile_source_code_inner(
                     is_commonjs_module,
                     module_info,
                     tag,
+                    bytecode_cache,
+                    bytecode_cache_size,
                     ..Default::default()
                 }));
             }
@@ -4305,9 +4372,10 @@ unsafe fn transpile_file(
         .and_then(|pkg| (!pkg.name.is_empty()).then_some(&*pkg.name));
 
     // ── Concurrent-transpiler dispatch (`transpile_async:` block) ───────────
-    // We only run the transpiler concurrently when we can.
-    // Today that's: import statements (`import 'foo'`) and import expressions
-    // (`import('foo')`).
+    // We only run the transpiler concurrently when we can — today that's import statements and
+    // import expressions. Node compile cache: lazily initialize from env on the first fetch.
+    bun_jsc::node_compile_cache::init_from_env_once();
+
     'transpile_async: {
         let concurrent_loader = lr.loader.unwrap_or(Loader::File);
         // SAFETY: per fn contract — `jsc_vm` is the live per-thread VM.
@@ -4328,6 +4396,9 @@ unsafe fn transpile_file(
             // TODO: allow running concurrently when no onLoad handlers match a plugin.
             && plugin_runner_is_none
             && store_enabled
+            // With the Node compile cache enabled, transpile on-thread so the
+            // fetch hook sees every module.
+            && !bun_jsc::node_compile_cache::is_enabled()
         {
             // Disgusting workaround: polyfills like
             // `reflect-metadata` are CJS-with-side-effects that other ESM
diff --git a/src/runtime/node/node_fs.rs b/src/runtime/node/node_fs.rs
index da513be2cf3f..ced0457f206e 100644
--- a/src/runtime/node/node_fs.rs
+++ b/src/runtime/node/node_fs.rs
@@ -1309,9 +1309,12 @@ mod _async_tasks {
             // KeepAlive::ref_ now takes the type-erased aio EventLoopCtx; the JS
             // event loop is the only one that owns AsyncFSTask/UVFSRequest.
             task.r#ref.ref_(bun_io::js_vm_ctx());
-            let _ = vm;
             task.tracker.did_schedule(global_object);
             let promise = task.promise.value();
+            // Counted so shutdown's `wait_for_concurrent_posters` covers the
+            // work-pool completion post; paired in `work_pool_callback`.
+            // SAFETY: `event_loop()` is a value field of the live `vm`.
+            unsafe { (*vm.event_loop()).concurrent_poster_begin() };
             WorkPool::schedule(&raw mut bun_core::heap::release(task).task);
             promise
         }
@@ -1341,6 +1344,9 @@ mod _async_tasks {
             // `this` transfers to the JS thread here — no use after this call.
             unsafe {
                 (*(*vm).event_loop()).enqueue_task_concurrent(ConcurrentTask::create_from(this));
+                // Pairs with `concurrent_poster_begin` in `create()`. The JS thread may free `this`
+                // once popped and tear the VM down at zero — this is the pool thread's last touch.
+                (*(*vm).event_loop()).concurrent_poster_end();
             }
         }
 
@@ -1622,6 +1628,10 @@ mod _async_tasks {
             }
             task.tracker.did_schedule(global_object);
 
+            // Counted so shutdown's `wait_for_concurrent_posters` covers the completion post;
+            // paired in `on_subtask_done`'s Js arm (the mini path never touches the JS event loop).
+            // SAFETY: `event_loop()` is a value field of the live `vm`.
+            unsafe { (*vm.event_loop()).concurrent_poster_begin() };
             let raw = bun_core::heap::release(task);
             WorkPool::schedule(&raw mut raw.task);
             raw
@@ -1720,7 +1730,7 @@ mod _async_tasks {
             // Count reached zero ⇒ exclusive access. `this` carries mutable
             // provenance from `Box::leak`, so the enqueued callback may safely
             // form `&mut *this` on the JS thread.
-            if matches!(this_ref.evtloop, EventLoopHandle::Js { .. }) {
+            if let EventLoopHandle::Js { owner } = this_ref.evtloop {
                 this_ref.evtloop.enqueue_task_concurrent(EventLoopTaskPtr {
                     js: ConcurrentTask::from_callback(this, |p| {
                         // SAFETY: `p` is the `Box::leak`'d task; subtask count hit zero so this
@@ -1729,6 +1739,9 @@ mod _async_tasks {
                     })
                     .as_ptr(),
                 });
+                // Pairs with `concurrent_poster_begin` in `create_with_shell_task`. The JS thread
+                // may free the task once popped and tear the VM down at zero — last touch of loop.
+                owner.concurrent_poster_end();
             } else {
                 this_ref.evtloop.enqueue_task_concurrent(EventLoopTaskPtr {
                     mini: AnyTaskWithExtraContext::from_callback_auto_deinit(
@@ -2396,6 +2409,10 @@ mod _async_tasks {
             task.r#ref.ref_(bun_io::js_vm_ctx());
             task.tracker.did_schedule(global_object);
             let promise = task.promise.value();
+            // Counted so shutdown's `wait_for_concurrent_posters` covers the
+            // single CAS-gated completion post; paired in `finish_concurrently`.
+            // SAFETY: `event_loop()` is a value field of the live `vm`.
+            unsafe { (*vm.event_loop()).concurrent_poster_begin() };
             WorkPool::schedule(&raw mut bun_core::heap::release(task).task);
             promise
         }
@@ -2579,6 +2596,10 @@ mod _async_tasks {
                     std::ptr::from_mut::<Self>(self),
                 )));
             }
+            // Pairs with `concurrent_poster_begin` in `create()`. The JS thread may free `self`
+            // once popped and tear the VM down at zero — last touch of both.
+            // SAFETY: `event_loop()` is a value field of the process-static VM.
+            unsafe { (*(*vm).event_loop()).concurrent_poster_end() };
         }
 
         fn clear_result_list(&mut self) {
diff --git a/src/runtime/node/node_process.rs b/src/runtime/node/node_process.rs
index 088f0f53d1aa..437f4b06b3b1 100644
--- a/src/runtime/node/node_process.rs
+++ b/src/runtime/node/node_process.rs
@@ -58,6 +58,18 @@ pub(crate) extern "C" fn exit(global_object: &JSGlobalObject, code: u8) {
         // instead to terminate the worker sooner
         worker.exit();
     } else {
+        // A watch-reload kill-signal handler may call process.exit; node restarts the child
+        // regardless. `process.exit()` must never return control to JS, so replace the process
+        // here instead of unwinding — the 'exit' event has already been dispatched by the caller.
+        if bun_jsc::posix_signal_handle::is_emitting_watch_kill_signal() {
+            let should_clear_terminal =
+                !vm.env_loader().has_set_no_clear_terminal_on_reload(
+                    !bun_core::Output::enable_ansi_colors_stdout(),
+                );
+            bun_jsc::node_compile_cache::persist_now();
+            bun_core::Output::flush();
+            bun_core::reload_process(should_clear_terminal, false);
+        }
         vm.on_exit();
         vm.global_exit();
     }
@@ -331,6 +343,13 @@ mod _impl {
                             }
                         }
                     }
+                    // Node's whole-token aliases are not params, so they never
+                    // land above; an alias takes a value iff its target does.
+                    for (from, to) in crate::cli::arguments::NODE_SHORT_ALIASES {
+                        if set.contains(to) {
+                            bun_core::handle_oom(set.insert(from));
+                        }
+                    }
                     set
                 });
 
@@ -450,10 +469,34 @@ mod _impl {
     }
 
     fn get_cwd(global_object: &JSGlobalObject) -> JsResult<JSValue> {
+        // Real syscall (not the resolver's cached top_level_dir): Node's
+        // process.cwd() calls uv_cwd() so a deleted cwd must surface here.
         let mut buf = PathBuffer::uninit();
-        match crate::node::path::get_cwd(&mut buf) {
-            bun_sys::Result::Ok(r) => Ok(ZigString::init(r).with_encoding().to_js(global_object)),
-            bun_sys::Result::Err(e) => Err(global_object.throw_value(e.to_js(global_object))),
+        match bun_sys::getcwd(&mut buf[..]) {
+            bun_sys::Result::Ok(len) => Ok(ZigString::init(&buf[..len])
+                .with_encoding()
+                .to_js(global_object)),
+            bun_sys::Result::Err(e) => {
+                // Node's UVException from `Cwd` (node_process_methods.cc):
+                // "CODE: process.cwd failed with error <uv_strerror>[, hint], uv_cwd"
+                let (code, label) = e.uv_code_label().unwrap_or(("UNKNOWN", "unknown error"));
+                let hint = if e.get_errno() == bun_sys::E::ENOENT {
+                    ", the current working directory was likely removed \
+                     without changing the working directory"
+                } else {
+                    ""
+                };
+                let message =
+                    format!("{code}: process.cwd failed with error {label}{hint}, uv_cwd");
+                let err = bun_jsc::SystemError {
+                    errno: core::ffi::c_int::from(e.errno).wrapping_neg(),
+                    code: BunString::static_(code).into(),
+                    message: BunString::clone_utf8(message.as_bytes()).into(),
+                    syscall: BunString::static_("uv_cwd").into(),
+                    ..Default::default()
+                };
+                Err(global_object.throw_value(err.to_error_instance(global_object)))
+            }
         }
     }
 
diff --git a/src/runtime/node/node_util_binding.rs b/src/runtime/node/node_util_binding.rs
index 26479f7e6ba6..9dbd65253cba 100644
--- a/src/runtime/node/node_util_binding.rs
+++ b/src/runtime/node/node_util_binding.rs
@@ -22,6 +22,24 @@ pub(crate) fn internal_error_name(global: &JSGlobalObject, frame: &CallFrame) ->
     fmtstring.transfer_to_js(global)
 }
 
+#[bun_jsc::host_fn]
+pub(crate) fn internal_error_entries(
+    global: &JSGlobalObject,
+    _frame: &CallFrame,
+) -> JsResult<JSValue> {
+    // Flat [code, name, code, name, ...] pairs — libuv's full error table for
+    // this target. Consumed by node:util's getSystemErrorMap().
+    let entries = UV_E::ENTRIES;
+    JSValue::create_array_from_iter(global, 0..entries.len() * 2, |i| {
+        let (code, name) = entries[i / 2];
+        if i % 2 == 0 {
+            Ok(JSValue::js_number_from_int32(code))
+        } else {
+            BunString::static_(name).to_js(global)
+        }
+    })
+}
+
 #[bun_jsc::host_fn]
 pub(crate) fn etimedout_error_code(
     _global: &JSGlobalObject,
@@ -145,6 +163,13 @@ impl<'a, T: Copy + PartialEq + From<u8>> SplitNewlineIterator<'a, T> {
     fn next(&mut self) -> Option<&'a [T]> {
         let start = self.index?;
 
+        // A lookbehind split emits no trailing empty field when the input ends
+        // with '\n' (but "" still splits to [""]).
+        if start == self.buffer.len() && start != 0 {
+            self.index = None;
+            return None;
+        }
+
         if let Some(delim_start) = self.buffer[start..]
             .iter()
             .position(|&b| b == T::from(b'\n'))
diff --git a/src/runtime/node/path.rs b/src/runtime/node/path.rs
index 5750e07e314f..353690647807 100644
--- a/src/runtime/node/path.rs
+++ b/src/runtime/node/path.rs
@@ -323,9 +323,6 @@ fn get_cwd_t<T: PathCharCwd>(buf: &mut [T]) -> MaybeBuf<'_, T> {
     T::get_cwd(buf)
 }
 
-// Alias for naming consistency.
-pub(crate) use get_cwd_u8 as get_cwd;
-
 /// Based on Node v21.6.1 path.posix.basename:
 /// https://github.com/nodejs/node/blob/6ae20aa63de78294b18d5015481485b7cd8fbb60/lib/path.js#L1309
 pub(crate) fn basename_posix_t<'a, T: PathCharCwd>(path: &'a [T], suffix: Option<&[T]>) -> &'a [T] {
diff --git a/src/runtime/webcore/TextDecoder.rs b/src/runtime/webcore/TextDecoder.rs
index a5b999bd013d..d95f808a1f83 100644
--- a/src/runtime/webcore/TextDecoder.rs
+++ b/src/runtime/webcore/TextDecoder.rs
@@ -367,7 +367,9 @@ impl TextDecoder {
                                 return Err(global_this
                                     .err(
                                         jsc::ErrorCode::ERR_ENCODING_INVALID_ENCODED_DATA,
-                                        format_args!("Invalid byte sequence"),
+                                        format_args!(
+                                            "The encoded data was not valid for encoding utf-8"
+                                        ),
                                     )
                                     .throw());
                             }
@@ -450,11 +452,10 @@ impl TextDecoder {
                     return Err(global_this
                         .err(
                             jsc::ErrorCode::ERR_ENCODING_INVALID_ENCODED_DATA,
-                            // "UTF-16LE" / "UTF-16BE" (NOT `get_label()`,
-                            // which is lowercase "utf-16le"/"utf-16be").
+                            // Node formats the message with the lowercase canonical label.
                             format_args!(
-                                "The encoded data was not valid {} data",
-                                if big_endian { "UTF-16BE" } else { "UTF-16LE" }
+                                "The encoded data was not valid for encoding {}",
+                                if big_endian { "utf-16be" } else { "utf-16le" }
                             ),
                         )
                         .throw());
@@ -544,7 +545,7 @@ impl TextDecoder {
                         .err(
                             jsc::ErrorCode::ERR_ENCODING_INVALID_ENCODED_DATA,
                             format_args!(
-                                "The encoded data was not valid {} data",
+                                "The encoded data was not valid for encoding {}",
                                 bstr::BStr::new(encoding_name)
                             ),
                         )
diff --git a/src/sys/Error.rs b/src/sys/Error.rs
index 862800e0a622..9ed1d497815d 100644
--- a/src/sys/Error.rs
+++ b/src/sys/Error.rs
@@ -332,6 +332,13 @@ impl Error {
         Some((<&'static str>::from(e), e))
     }
 
+    /// (code, uv_strerror label) pair, e.g. `("ENOENT", "no such file or
+    /// directory")` — the pieces of Node's `UVException` message.
+    pub fn uv_code_label(&self) -> Option<(&'static str, &'static str)> {
+        let (code, system_errno) = self.get_error_code_tag_name()?;
+        Some((code, libuv_error_map::LIBUV_ERROR_MAP[system_errno]))
+    }
+
     pub fn msg(&self) -> Option<&'static [u8]> {
         let (_code, system_errno) = self.get_error_code_tag_name()?;
         // Both error maps are total (`initFull("unknown error")`), so the
diff --git a/src/watcher/Watcher.rs b/src/watcher/Watcher.rs
index 31080905b30d..796f0b07b17b 100644
--- a/src/watcher/Watcher.rs
+++ b/src/watcher/Watcher.rs
@@ -237,32 +237,40 @@ impl Watcher {
         // Watcher must be Send across the spawned thread boundary; we pass a
         // raw pointer (as usize) and uphold the safety contract manually.
         let this = std::ptr::from_mut::<Watcher>(self) as usize;
-        // SAFETY: Watcher outlives the thread; shutdown() coordinates teardown
-        // via `running`/`close_descriptors` and the thread frees the Box.
-        self.thread = Some(
+        let spawn = || {
             std::thread::Builder::new()
                 .name("FileWatcher".into())
-                .spawn(move || unsafe {
-                    let _ = Watcher::thread_main(this as *mut Watcher);
+                .spawn(move || {
+                    // SAFETY: Watcher outlives the thread; shutdown()
+                    // coordinates teardown via `running`/`close_descriptors`
+                    // and the thread frees the Box.
+                    let _ = unsafe { Watcher::thread_main(this as *mut Watcher) };
                 })
-                .map_err(|e| {
-                    self.watchloop_handle.store(false);
-                    // Windows: raw_os_error() is a Win32 GetLastError() code, so
-                    // route it through the u32 (Win32Error) mapper rather than
-                    // from_errno's i64 discriminant-cast path.
-                    #[cfg(windows)]
-                    let errno = e
-                        .raw_os_error()
-                        .and_then(|c| bun_errno::SystemErrno::init(c as u32))
-                        .unwrap_or(bun_errno::SystemErrno::EAGAIN);
-                    #[cfg(not(windows))]
-                    let errno = e
-                        .raw_os_error()
-                        .map(bun_errno::from_errno)
-                        .unwrap_or(bun_errno::SystemErrno::EAGAIN);
-                    crate::Error::Sys(errno)
-                })?,
-        );
+        };
+        // A --watch reload execve's and immediately re-enters here; under CI load the first
+        // pthread_create can see a transient EAGAIN before the old image's threads are reaped.
+        // One short retry covers that without masking real resource exhaustion.
+        let handle = spawn().or_else(|first| {
+            std::thread::sleep(std::time::Duration::from_millis(10));
+            spawn().map_err(|_| first)
+        });
+        self.thread = Some(handle.map_err(|e| {
+            self.watchloop_handle.store(false);
+            // Windows: raw_os_error() is a Win32 GetLastError() code, so
+            // route it through the u32 (Win32Error) mapper rather than
+            // from_errno's i64 discriminant-cast path.
+            #[cfg(windows)]
+            let errno = e
+                .raw_os_error()
+                .and_then(|c| bun_errno::SystemErrno::init(c as u32))
+                .unwrap_or(bun_errno::SystemErrno::EAGAIN);
+            #[cfg(not(windows))]
+            let errno = e
+                .raw_os_error()
+                .map(bun_errno::from_errno)
+                .unwrap_or(bun_errno::SystemErrno::EAGAIN);
+            crate::Error::Sys(errno)
+        })?);
         Ok(())
     }
 
diff --git a/test/cli/heap-prof.test.ts b/test/cli/heap-prof.test.ts
index 44dab5d61298..f94ce71e788e 100644
--- a/test/cli/heap-prof.test.ts
+++ b/test/cli/heap-prof.test.ts
@@ -4,7 +4,26 @@ import { join } from "path";
 
 const testScript = `const arr = []; for (let i = 0; i < 100; i++) arr.push({ x: i, y: "hello" + i }); console.log("done");`;
 
-test("--heap-prof generates V8 heap snapshot on exit", async () => {
+// Node's DiagnosticFilename format: Heap.<yyyymmdd>.<hhmmss>.<pid>.<tid>.<seq>.heapprofile
+const nodeFilenameRe = /^Heap\.\d{8}\.\d{6}\.\d+\.0\.\d{3}\.heapprofile$/;
+
+async function readProfile(dir: string, file: string) {
+  const content = await Bun.file(join(dir, file)).text();
+  return JSON.parse(content);
+}
+
+function expectV8HeapSnapshotShape(profile: any) {
+  // V8 heap snapshot: { snapshot: { meta, node_count, edge_count }, nodes, edges, strings }
+  expect(profile).toHaveProperty("snapshot");
+  expect(profile.snapshot).toHaveProperty("meta");
+  expect(typeof profile.snapshot.node_count).toBe("number");
+  expect(profile.snapshot.node_count).toBeGreaterThan(0);
+  expect(Array.isArray(profile.nodes)).toBe(true);
+  expect(Array.isArray(profile.edges)).toBe(true);
+  expect(Array.isArray(profile.strings)).toBe(true);
+}
+
+test("--heap-prof writes a .heapprofile with node's filename format on exit", async () => {
   using dir = tempDir("heap-prof-v8-test", {});
 
   await using proc = Bun.spawn({
@@ -15,29 +34,68 @@ test("--heap-prof generates V8 heap snapshot on exit", async () => {
     stderr: "pipe",
   });
 
-  const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+  const [stdout, exitCode] = await Promise.all([proc.stdout.text(), proc.exited]);
 
   expect(stdout.trim()).toBe("done");
-  expect(stderr).toContain("Heap profile written to:");
   expect(exitCode).toBe(0);
 
-  // Find the heap snapshot file (V8 format)
-  const glob = new Bun.Glob("Heap.*.heapsnapshot");
+  const glob = new Bun.Glob("*.heapprofile");
   const files = Array.from(glob.scanSync({ cwd: String(dir) }));
-  expect(files.length).toBeGreaterThan(0);
+  expect(files.length).toBe(1);
+  expect(files[0]).toMatch(nodeFilenameRe);
 
-  // Read and validate the heap snapshot content (should be valid JSON in V8 format)
-  const profilePath = join(String(dir), files[0]);
-  const content = await Bun.file(profilePath).text();
+  const profile = await readProfile(String(dir), files[0]);
+  expectV8HeapSnapshotShape(profile);
+  // The snapshot is real, so it always carries node data.
+  expect(profile.nodes.length).toBeGreaterThan(0);
+});
+
+test("--heap-prof writes the profile when the script calls process.exit", async () => {
+  using dir = tempDir("heap-prof-exit-test", {});
+
+  await using proc = Bun.spawn({
+    cmd: [bunExe(), "--heap-prof", "-e", `process.exit(55);`],
+    cwd: String(dir),
+    env: bunEnv,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
 
-  // V8 heap snapshot format is JSON with specific structure
-  const snapshot = JSON.parse(content);
-  expect(snapshot).toHaveProperty("snapshot");
-  expect(snapshot).toHaveProperty("nodes");
-  expect(snapshot).toHaveProperty("edges");
-  expect(snapshot).toHaveProperty("strings");
+  const [, , exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+  expect(exitCode).toBe(55);
+
+  const glob = new Bun.Glob("*.heapprofile");
+  const files = Array.from(glob.scanSync({ cwd: String(dir) }));
+  expect(files.length).toBe(1);
+  const profile = await readProfile(String(dir), files[0]);
+  expectV8HeapSnapshotShape(profile);
 });
 
+test.skipIf(process.platform === "win32")(
+  "--heap-prof writes the profile on a self-directed SIGINT with no JS handler",
+  async () => {
+    using dir = tempDir("heap-prof-sigint-test", {});
+
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), "--heap-prof", "-e", `process.kill(process.pid, "SIGINT");`],
+      cwd: String(dir),
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    const [, , exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+    expect(proc.signalCode).toBe("SIGINT");
+    expect(exitCode).not.toBe(0);
+
+    const glob = new Bun.Glob("*.heapprofile");
+    const files = Array.from(glob.scanSync({ cwd: String(dir) }));
+    expect(files.length).toBe(1);
+    const profile = await readProfile(String(dir), files[0]);
+    expectV8HeapSnapshotShape(profile);
+  },
+);
+
 test("--heap-prof-md generates markdown heap profile on exit", async () => {
   using dir = tempDir("heap-prof-md-test", {});
 
@@ -99,7 +157,7 @@ test("--heap-prof-md generates markdown heap profile on exit", async () => {
   expect(content).toContain("| Type | Count | Self Size | Retained Size | Largest ID |");
 });
 
-test("--heap-prof-dir specifies output directory for V8 format", async () => {
+test("--heap-prof-dir specifies the output directory", async () => {
   using dir = tempDir("heap-prof-dir-test", {
     "profiles": {},
   });
@@ -112,18 +170,15 @@ test("--heap-prof-dir specifies output directory for V8 format", async () => {
     stderr: "pipe",
   });
 
-  const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+  const [stdout, exitCode] = await Promise.all([proc.stdout.text(), proc.exited]);
 
   expect(stdout.trim()).toBe("hello");
-  expect(stderr).toContain("Heap profile written to:");
-  // Check for "profiles" directory in path (handles both / and \ separators)
-  expect(stderr).toMatch(/profiles[/\\]/);
   expect(exitCode).toBe(0);
 
-  // Check the profile is in the specified directory
-  const glob = new Bun.Glob("Heap.*.heapsnapshot");
+  const glob = new Bun.Glob("*.heapprofile");
   const files = Array.from(glob.scanSync({ cwd: join(String(dir), "profiles") }));
-  expect(files.length).toBeGreaterThan(0);
+  expect(files.length).toBe(1);
+  expect(files[0]).toMatch(nodeFilenameRe);
 });
 
 test("--heap-prof-dir specifies output directory for markdown format", async () => {
@@ -157,23 +212,20 @@ test("--heap-prof-name specifies output filename", async () => {
   using dir = tempDir("heap-prof-name-test", {});
 
   await using proc = Bun.spawn({
-    cmd: [bunExe(), "--heap-prof", "--heap-prof-name", "my-profile.heapsnapshot", "-e", `console.log("hello");`],
+    cmd: [bunExe(), "--heap-prof", "--heap-prof-name", "my-profile.heapprofile", "-e", `console.log("hello");`],
     cwd: String(dir),
     env: bunEnv,
     stdout: "pipe",
     stderr: "pipe",
   });
 
-  const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+  const [stdout, exitCode] = await Promise.all([proc.stdout.text(), proc.exited]);
 
   expect(stdout.trim()).toBe("hello");
-  expect(stderr).toContain("Heap profile written to:");
-  expect(stderr).toContain("my-profile.heapsnapshot");
   expect(exitCode).toBe(0);
 
-  // Check the profile exists with the specified name
-  const profilePath = join(String(dir), "my-profile.heapsnapshot");
-  expect(Bun.file(profilePath).size).toBeGreaterThan(0);
+  const profile = await readProfile(String(dir), "my-profile.heapprofile");
+  expectV8HeapSnapshotShape(profile);
 });
 
 test("--heap-prof-name and --heap-prof-dir work together", async () => {
@@ -188,7 +240,7 @@ test("--heap-prof-name and --heap-prof-dir work together", async () => {
       "--heap-prof-dir",
       "output",
       "--heap-prof-name",
-      "custom.heapsnapshot",
+      "custom.heapprofile",
       "-e",
       `console.log("hello");`,
     ],
@@ -198,17 +250,46 @@ test("--heap-prof-name and --heap-prof-dir work together", async () => {
     stderr: "pipe",
   });
 
-  const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+  const [stdout, exitCode] = await Promise.all([proc.stdout.text(), proc.exited]);
 
   expect(stdout.trim()).toBe("hello");
-  expect(stderr).toContain("Heap profile written to:");
   expect(exitCode).toBe(0);
 
-  // Check the profile exists in the specified location
-  const profilePath = join(String(dir), "output", "custom.heapsnapshot");
-  expect(Bun.file(profilePath).size).toBeGreaterThan(0);
+  const profile = await readProfile(join(String(dir), "output"), "custom.heapprofile");
+  expectV8HeapSnapshotShape(profile);
 });
 
+// Node parity: heap-profiler-scoped flags without --heap-prof exit 9 with
+// "<execPath>: <flag> must be used with --heap-prof" on stderr.
+for (const [flag, value] of [
+  ["--heap-prof-name", "test.heapprofile"],
+  ["--heap-prof-dir", "prof"],
+  ["--heap-prof-interval", "128"],
+] as const) {
+  test(`${flag} without --heap-prof exits 9 with node's message`, async () => {
+    using dir = tempDir("heap-prof-invalid-test", {});
+
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), flag, value, "-e", `console.log("hello");`],
+      cwd: String(dir),
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+
+    expect(stdout).toBe("");
+    expect(stderr.trim()).toBe(`${bunExe()}: ${flag} must be used with --heap-prof`);
+    expect(exitCode).toBe(9);
+
+    // No profile should be generated
+    const glob = new Bun.Glob("*.heap*");
+    const files = Array.from(glob.scanSync({ cwd: String(dir) }));
+    expect(files.length).toBe(0);
+  });
+}
+
 // On Windows the path buffer is ~98 KB and the CreateProcess command-line
 // limit is ~32 KB, so an overflowing CLI argument cannot be delivered. On
 // POSIX 5000 bytes exceeds the fixed path buffer (Linux 4096, macOS 1024);
@@ -241,25 +322,40 @@ test.skipIf(isWindows).each([
   expect(proc.signalCode).toBeNull();
 });
 
-test("--heap-prof-name without --heap-prof or --heap-prof-md shows warning", async () => {
-  using dir = tempDir("heap-prof-warn-test", {});
+test("--heap-prof-interval equal to the default is a noop without --heap-prof, like node", async () => {
+  using dir = tempDir("heap-prof-interval-noop-test", {});
 
   await using proc = Bun.spawn({
-    cmd: [bunExe(), "--heap-prof-name", "test.heapsnapshot", "-e", `console.log("hello");`],
+    cmd: [bunExe(), "--heap-prof-interval", "524288", "-e", `console.log("hello");`],
     cwd: String(dir),
     env: bunEnv,
     stdout: "pipe",
     stderr: "pipe",
   });
 
-  const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+  const [stdout, exitCode] = await Promise.all([proc.stdout.text(), proc.exited]);
+
+  expect(stdout.trim()).toBe("hello");
+  expect(exitCode).toBe(0);
+});
+
+test("--heap-prof --heap-prof-interval is accepted", async () => {
+  using dir = tempDir("heap-prof-interval-test", {});
+
+  await using proc = Bun.spawn({
+    cmd: [bunExe(), "--heap-prof", "--heap-prof-interval", "128", "-e", `console.log("hello");`],
+    cwd: String(dir),
+    env: bunEnv,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  const [stdout, exitCode] = await Promise.all([proc.stdout.text(), proc.exited]);
 
   expect(stdout.trim()).toBe("hello");
-  expect(stderr).toContain("--heap-prof-name requires --heap-prof or --heap-prof-md to be enabled");
   expect(exitCode).toBe(0);
 
-  // No profile should be generated
-  const glob = new Bun.Glob("*.heap*");
+  const glob = new Bun.Glob("*.heapprofile");
   const files = Array.from(glob.scanSync({ cwd: String(dir) }));
-  expect(files.length).toBe(0);
+  expect(files.length).toBe(1);
 });
diff --git a/test/cli/run/garbage-env.test.ts b/test/cli/run/garbage-env.test.ts
index 299e0f213b6a..1ec09ceb0bc3 100644
--- a/test/cli/run/garbage-env.test.ts
+++ b/test/cli/run/garbage-env.test.ts
@@ -1,13 +1,16 @@
 import { describe, expect, test } from "bun:test";
-import { bunExe, isPosix } from "harness";
+import { bunExe, isPosix, tempDir } from "harness";
 import path from "path";
 
 describe.if(isPosix)("garbage env", () => {
   test("garbage env", async () => {
     const cfile = path.join(import.meta.dirname, "garbage-env.c");
+    // Compile into a temp dir so the binary never lands in the repo root.
+    using dir = tempDir("garbage-env", {});
+    const exe = path.join(String(dir), "garbage-env");
     {
       const cc = Bun.which("clang") || Bun.which("gcc") || Bun.which("cc");
-      const { exitCode, stderr } = await Bun.$`${cc} -o garbage-env ${cfile}`;
+      const { exitCode, stderr } = await Bun.$`${cc} -o ${exe} ${cfile}`;
       const stderrText = stderr.toString();
       if (stderrText.length > 0) {
         console.error(stderrText);
@@ -15,7 +18,7 @@ describe.if(isPosix)("garbage env", () => {
       expect(exitCode).toBe(0);
     }
 
-    const { exitCode, stderr } = await Bun.$`./garbage-env`.env({ BUN_PATH: bunExe() });
+    const { exitCode, stderr } = await Bun.$`${exe}`.env({ BUN_PATH: bunExe() });
     const stderrText = stderr.toString();
     if (stderrText.length > 0) {
       console.error(stderrText);
diff --git a/test/cli/watch/watch.test.ts b/test/cli/watch/watch.test.ts
index 3ddfe6ea182e..e1c3d566f8f0 100644
--- a/test/cli/watch/watch.test.ts
+++ b/test/cli/watch/watch.test.ts
@@ -2,11 +2,27 @@ import type { Subprocess } from "bun";
 import { spawn } from "bun";
 import { afterEach, expect, it } from "bun:test";
 import { bunEnv, bunExe, isBroken, isLinux, isWindows, tempDir, tmpdirSync } from "harness";
-import { rmSync } from "node:fs";
+import { readdirSync, rmSync } from "node:fs";
 import { join } from "node:path";
 
 let watchee: Subprocess;
 
+function stdoutWaiter(proc: Subprocess<"ignore", "pipe", any>) {
+  const reader = proc.stdout.getReader();
+  const decoder = new TextDecoder();
+  let output = "";
+  return {
+    waitFor: async (needle: string) => {
+      while (!output.includes(needle)) {
+        const { value, done } = await reader.read();
+        if (done) throw new Error(`stream closed, output so far: ${JSON.stringify(output)}`);
+        output += decoder.decode(value, { stream: true });
+      }
+    },
+    release: () => reader.releaseLock(),
+  };
+}
+
 for (const dir of ["dir", "©️"]) {
   it.todoIf(isBroken && isWindows)(
     `should watch files${dir === "dir" ? "" : " (non-ascii path)"}`,
@@ -43,9 +59,74 @@ for (const dir of ["dir", "©️"]) {
   );
 }
 
-afterEach(() => {
-  watchee?.kill();
+afterEach(async () => {
+  // SIGKILL, not the default SIGTERM: the wedge fixtures below register a
+  // SIGTERM handler and never yield, so SIGTERM can't kill them — a leaked
+  // pair spins at full CPU until someone notices. Await the exit so a test
+  // failure can't strand the child past the suite.
+  if (watchee) {
+    watchee.kill("SIGKILL");
+    await watchee.exited;
+    watchee = undefined;
+  }
+});
+
+it.skipIf(isWindows)(
+  "process.exit() in a watch kill-signal handler never returns to JS",
+  async () => {
+    using dir = tempDir("watch-exit-in-sigterm", {
+      "exiter.js": `process.on("SIGTERM", () => {
+  process.exit(0);
+  require("fs").writeFileSync("should-not-write.txt", "hello");
+});
+process.on("SIGTERM", () => {
+  require("fs").writeFileSync("second-listener-ran.txt", "hello");
 });
+console.log("started");
+setInterval(() => {}, 1000);
+`,
+    });
+    const cwd = String(dir);
+    const path = join(cwd, "exiter.js");
+    watchee = spawn({
+      cwd,
+      cmd: [bunExe(), "--watch", "exiter.js"],
+      env: bunEnv,
+      stdout: "pipe",
+      stderr: "inherit",
+      stdin: "ignore",
+    });
+    let starts = 0;
+    let touched = false;
+    const decoder = new TextDecoder();
+    await (async () => {
+      // Output written before this reader attaches waits in the kernel pipe
+      // buffer, so no start can be missed. Lines are reassembled across chunk
+      // boundaries before matching.
+      let buffered = "";
+      for await (const chunk of watchee.stdout) {
+        buffered += decoder.decode(chunk);
+        let newline;
+        while ((newline = buffered.indexOf("\n")) !== -1) {
+          const line = buffered.slice(0, newline);
+          buffered = buffered.slice(newline + 1);
+          if (line.includes("started") && ++starts === 2) return;
+          if (starts === 1 && !touched) {
+            touched = true;
+            // First boot seen: touch the file to trigger the kill-signal reload.
+            await Bun.write(path, (await Bun.file(path).text()) + "\n// touched");
+          }
+        }
+      }
+      // The child exiting before the reload start is a failure of the watch
+      // path itself; without this the absent-file expects below pass vacuously.
+      throw new Error(`watchee stdout ended after ${starts} start(s); expected 2`);
+    })();
+    expect(await Bun.file(join(cwd, "should-not-write.txt")).exists()).toBe(false);
+    expect(await Bun.file(join(cwd, "second-listener-ran.txt")).exists()).toBe(false);
+  },
+  10000,
+);
 
 // Watcher::start() must propagate a failed thread spawn as an Err through its
 // Result return instead of aborting inside start() with `.expect()`. An
@@ -73,14 +154,15 @@ __attribute__((constructor)) static void no_core(void) {
 
 int inotify_init1(int flags) {
   if (!real_inotify_init1) real_inotify_init1 = dlsym(RTLD_NEXT, "inotify_init1");
-  armed = 1;
+  /* Watcher::start() retries once on EAGAIN; fail both attempts. */
+  armed = 2;
   return real_inotify_init1(flags);
 }
 
 int pthread_create(pthread_t *t, const pthread_attr_t *a, void *(*f)(void *), void *arg) {
   if (!real_pthread_create) real_pthread_create = dlsym(RTLD_NEXT, "pthread_create");
   if (armed) {
-    armed = 0;
+    armed--;
     return EAGAIN;
   }
   return real_pthread_create(t, a, f, arg);
@@ -119,3 +201,157 @@ int pthread_create(pthread_t *t, const pthread_attr_t *a, void *(*f)(void *), vo
   expect(stdout).not.toContain("unreachable");
   expect(exitCode).not.toBe(0);
 });
+
+// A script that registers a SIGTERM handler and then spins in synchronous
+// code must still restart on file change: the watcher thread posts the reload
+// to the JS thread first (so listeners can run), but forces the reload itself
+// after a bounded grace window when the JS thread never drains the task.
+it("--watch forces a restart when the kill-signal listener thread is stuck in sync code", async () => {
+  using dir = tempDir("watch-busy-sigterm", {
+    "busy.js": `
+      process.on("SIGTERM", () => {});
+      console.log("iter first");
+      // The busy loop never yields to the event loop, so the posted
+      // WatchReloadTask cannot run and the watcher-thread fallback must
+      // fire. Self-limiting: it spins far past the 500ms fallback window
+      // but exits on its own, so a leaked watch pair cannot burn CPU
+      // forever if the test dies before killing it.
+      const end = Date.now() + 30_000;
+      while (Date.now() < end) {}
+      process.exit(1);
+    `,
+  });
+
+  watchee = spawn({
+    cmd: [bunExe(), "--watch", "busy.js"],
+    cwd: String(dir),
+    env: bunEnv,
+    stdout: "pipe",
+    stderr: "inherit",
+  });
+
+  const { waitFor, release } = stdoutWaiter(watchee);
+
+  await waitFor("iter first");
+  await Bun.write(
+    join(String(dir), "busy.js"),
+    `process.on("SIGTERM", () => {});
+     console.log("iter second");
+     process.exit(0);`,
+  );
+  await waitFor("iter second");
+
+  release();
+  watchee.kill("SIGKILL");
+  await watchee.exited;
+}, 30000);
+
+// Same fallback, but the wedge is *inside* the handler rather than before
+// the posted task drains: the emit-flag stays true for the handler's full
+// synchronous duration, and the grace thread must still force the reload
+// when the handler never returns.
+it("--watch forces a restart when the kill-signal handler itself never returns", async () => {
+  using dir = tempDir("watch-sigterm-wedged-handler", {
+    "busy.js": `
+      process.on("SIGTERM", () => {
+        const end = Date.now() + 30_000;
+        while (Date.now() < end) {}
+        process.exit(1);
+      });
+      console.log("iter first");
+      setInterval(() => {}, 1000);
+    `,
+  });
+
+  watchee = spawn({
+    cmd: [bunExe(), "--watch", "busy.js"],
+    cwd: String(dir),
+    env: bunEnv,
+    stdout: "pipe",
+    stderr: "inherit",
+  });
+
+  const { waitFor, release } = stdoutWaiter(watchee);
+
+  await waitFor("iter first");
+  await Bun.write(
+    join(String(dir), "busy.js"),
+    `console.log("iter second");
+     process.exit(0);`,
+  );
+  await waitFor("iter second");
+
+  release();
+  watchee.kill("SIGKILL");
+  await watchee.exited;
+}, 30000);
+
+// execve replaces the process without reaching on_exit(), so the compile
+// cache must be flushed explicitly on the reload path; otherwise
+// NODE_COMPILE_CACHE never writes anything under --watch.
+it("NODE_COMPILE_CACHE persists across a --watch reload", async () => {
+  using dir = tempDir("watch-compile-cache", {
+    "dep.js": `module.exports = 1;`,
+    "app.js": `require("./dep.js"); console.log("iter first");`,
+  });
+  const cacheDir = join(String(dir), ".cc");
+
+  watchee = spawn({
+    cmd: [bunExe(), "--watch", "app.js"],
+    cwd: String(dir),
+    env: { ...bunEnv, NODE_COMPILE_CACHE: cacheDir },
+    stdout: "pipe",
+    stderr: "inherit",
+  });
+
+  const { waitFor, release } = stdoutWaiter(watchee);
+
+  await waitFor("iter first");
+  await Bun.write(join(String(dir), "app.js"), `require("./dep.js"); console.log("iter second");`);
+  await waitFor("iter second");
+
+  release();
+  watchee.kill("SIGKILL");
+  await watchee.exited;
+
+  // The first iteration persisted before execve; the <version-tag>/<hash>
+  // files must now exist on disk.
+  const entries = readdirSync(cacheDir, { recursive: true, withFileTypes: true });
+  expect(entries.filter(e => e.isFile()).length).toBeGreaterThan(0);
+}, 30000);
+
+// NODE_CHANNEL_FD survives in environ across execve; the fd it names must
+// survive too, so the reloaded image re-attaches to a live socket instead
+// of a closed one and the parent keeps receiving 'message' events.
+it.skipIf(isWindows)(
+  "IPC to the parent survives a --watch reload",
+  async () => {
+    using dir = tempDir("watch-ipc-reload", {
+      "app.js": `process.send?.("iter first"); setInterval(() => {}, 1000);`,
+    });
+
+    const messages: string[] = [];
+    watchee = spawn({
+      cmd: [bunExe(), "--watch", "app.js"],
+      cwd: String(dir),
+      env: bunEnv,
+      stdout: "inherit",
+      stderr: "inherit",
+      ipc(message) {
+        messages.push(String(message));
+      },
+    });
+
+    const deadline = Date.now() + 20000;
+    while (!messages.includes("iter first") && Date.now() < deadline) await Bun.sleep(10);
+    expect(messages).toContain("iter first");
+
+    await Bun.write(join(String(dir), "app.js"), `process.send?.("iter second");`);
+    while (!messages.includes("iter second") && Date.now() < deadline) await Bun.sleep(10);
+    expect(messages).toContain("iter second");
+
+    watchee.kill("SIGKILL");
+    await watchee.exited;
+  },
+  30000,
+);
diff --git a/test/js/bun/resolve/import-meta.test.js b/test/js/bun/resolve/import-meta.test.js
index c0b746c52c17..b2a3cc54b06b 100644
--- a/test/js/bun/resolve/import-meta.test.js
+++ b/test/js/bun/resolve/import-meta.test.js
@@ -73,7 +73,7 @@ it("Module.createRequire does not use file url as the referrer (err message chec
     expect(e.name).not.toBe("UnreachableError");
     expect(e.message).not.toInclude("file:///");
     expect(e.message).toInclude(`'whaaat'`);
-    expect(e.message).toInclude(`'` + import.meta.path + `'`);
+    expect(e.message).toInclude(import.meta.path);
   }
 });
 
diff --git a/test/js/bun/resolve/resolve-error.test.ts b/test/js/bun/resolve/resolve-error.test.ts
index cb82e69a01d0..c608c2800a83 100644
--- a/test/js/bun/resolve/resolve-error.test.ts
+++ b/test/js/bun/resolve/resolve-error.test.ts
@@ -117,7 +117,7 @@ describe("ResolveMessage", () => {
     expect(async () => {
       // @ts-ignore
       await import(":://filesystem");
-    }).toThrow("Cannot find module");
+    }).toThrow("Cannot find package '::'");
   });
 
   it("referrer is not freed before it is read", () => {
diff --git a/test/js/bun/spawn/spawn.ipc.test.ts b/test/js/bun/spawn/spawn.ipc.test.ts
index ab186a0a87a7..33c4de396cba 100644
--- a/test/js/bun/spawn/spawn.ipc.test.ts
+++ b/test/js/bun/spawn/spawn.ipc.test.ts
@@ -88,6 +88,47 @@ describe.each(["advanced", "json"])("ipc mode %s", mode => {
 });
 
 describe("ipc mode advanced", () => {
+  it("unwraps the Buffer envelope before cmd dispatch", async () => {
+    // A cmd-bearing message whose payload holds a Buffer travels as the
+    // [message, buffers] envelope. The receiver's cmd fast-path reads
+    // message.cmd straight off the decoded value, so the envelope must be
+    // restored first — otherwise the fast-get sees an array (no cmd), the
+    // NODE_HANDLE interception is skipped, and user listeners receive the
+    // raw envelope instead of the message.
+    const childSource = [
+      // A non-NODE cmd goes through the same fast-get, then to the user.
+      `process.send({ cmd: "USER_CMD", payload: Buffer.from("through-dispatch") });`,
+      // A NODE_HANDLE cmd (no fd attached) must be intercepted, NACKed and
+      // withheld from user listeners — proving cmd was readable post-restore.
+      `process.send({ cmd: "NODE_HANDLE", type: "net.Socket", msg: { buf: Buffer.from("hidden") } });`,
+      `process.send({ done: true });`,
+      `process.on("message", () => {});`,
+    ].join("\n");
+    const { promise, resolve, reject } = Promise.withResolvers<any[]>();
+    const messages: any[] = [];
+    await using child = spawn([bunExe(), "-e", childSource], {
+      env: bunEnv,
+      stdio: ["ignore", "inherit", "inherit"],
+      serialization: "advanced",
+      ipc(message) {
+        messages.push(message);
+        if (message?.done) resolve(messages);
+      },
+      onExit(_subprocess, exitCode, signalCode) {
+        reject(new Error(`child exited (${exitCode}, ${signalCode}) after ${messages.length} messages`));
+      },
+    });
+    const received = await promise;
+    const userCmd = received.filter(message => message?.cmd === "USER_CMD");
+    expect(userCmd).toHaveLength(1);
+    expect(Buffer.isBuffer(userCmd[0].payload)).toBe(true);
+    expect(userCmd[0].payload.toString()).toBe("through-dispatch");
+    // The NODE_HANDLE message is protocol traffic, not a user message.
+    expect(received.filter(message => message?.cmd === "NODE_HANDLE")).toHaveLength(0);
+    // And no raw [message, buffers] envelope may leak through.
+    expect(received.filter(message => Array.isArray(message))).toHaveLength(0);
+  });
+
   it("a message_len that overflows header_length + message_len does not crash the receiver", async () => {
     // The advanced IPC framing is [u8 type][u32-le length][payload]. Decoding previously
     // checked `data.len < header_length + message_len`, which is u32 arithmetic: a child
@@ -189,3 +230,33 @@ it("child with unusable NODE_CHANNEL_FD tears down IPC without crashing", async
   expect(stdout).toBe("err ERR_IPC_CHANNEL_CLOSED\nok\n");
   expect(exitCode).toBe(0);
 });
+
+it.skipIf(isWindows)("advanced serialization advertises wire format version 2", async () => {
+  // The version packet is the first frame on the channel:
+  // [type=Version(1), u32 LE version]. Read it raw off fd 3 before the
+  // child's own channel machinery starts consuming the socket.
+  await using child = Bun.spawn({
+    cmd: [
+      bunExe(),
+      "-e",
+      `const fs = require("fs");
+      const buf = Buffer.alloc(5);
+      let n = 0;
+      while (n < 5) {
+        try {
+          n += fs.readSync(3, buf, n, 5 - n);
+        } catch (e) {
+          if (e.code !== "EAGAIN") throw e;
+        }
+      }
+      console.log(JSON.stringify([...buf]));`,
+    ],
+    env: bunEnv,
+    stdio: ["ignore", "pipe", "inherit"],
+    serialization: "advanced",
+    ipc() {},
+  });
+  const [stdout, exitCode] = await Promise.all([child.stdout.text(), child.exited]);
+  expect(JSON.parse(stdout.trim())).toEqual([1, 2, 0, 0, 0]);
+  expect(exitCode).toBe(0);
+});
diff --git a/test/js/node/assert/assert.spec.ts b/test/js/node/assert/assert.spec.ts
index c2c10d2db079..930bc6f701d8 100644
--- a/test/js/node/assert/assert.spec.ts
+++ b/test/js/node/assert/assert.spec.ts
@@ -11,8 +11,11 @@ describe("assert(expr)", () => {
     expect(() => assert(expr)).toThrow(AssertionError);
   });
 
-  it("is an alias for assert.ok", () => {
-    expect(assert as Function).toBe(assert.ok);
+  it("behaves like assert.ok (a distinct function since node 25)", () => {
+    // node >= 25 builds the namespace from Assert.prototype, so assert !== assert.ok.
+    expect(assert as Function).not.toBe(assert.ok);
+    expect(() => assert.ok(1)).not.toThrow();
+    expect(() => assert.ok(0)).toThrow(AssertionError);
   });
 });
 
diff --git a/test/js/node/assert/assert.test.cjs b/test/js/node/assert/assert.test.cjs
index 57115f427efc..3629333dd86c 100644
--- a/test/js/node/assert/assert.test.cjs
+++ b/test/js/node/assert/assert.test.cjs
@@ -14,6 +14,16 @@ describe("assert.partialDeepStrictEqual", () => {
     expect(() => assert.partialDeepStrictEqual([1, 2, 3, 4], [4, 2])).toThrow(assert.AssertionError);
   });
 
+  test("failure message uses the kReadableOperator header", () => {
+    let err;
+    try {
+      assert.partialDeepStrictEqual({ a: 1 }, { b: 2 });
+    } catch (e) {
+      err = e;
+    }
+    expect(err.message.split("\n")[0]).toBe("Expected values to be partially and strictly deep-equal:");
+  });
+
   test("array subsequence scan skips candidates missing an expected key", () => {
     assert.partialDeepStrictEqual([{ a: 1 }, { b: 2 }], [{ b: 2 }]);
     assert.partialDeepStrictEqual({ items: [{ a: 1 }, { b: 2 }] }, { items: [{ b: 2 }] });
diff --git a/test/js/node/assert/deep-equal.test.ts b/test/js/node/assert/deep-equal.test.ts
index 2948f9bc7655..9e391b7706ec 100644
--- a/test/js/node/assert/deep-equal.test.ts
+++ b/test/js/node/assert/deep-equal.test.ts
@@ -202,7 +202,6 @@ const cases: Case[] = [
     b: () => ({}),
     strict: false,
     loose: true,
-    strictBug: "reports equal",
   },
   {
     name: "two null-prototype objects with the same keys",
@@ -240,7 +239,6 @@ const cases: Case[] = [
     b: anonymousClassInstance,
     strict: false,
     loose: true,
-    strictBug: "matches classes by name, so reports equal",
   },
   {
     name: "instances of two distinct identically named classes",
@@ -248,7 +246,6 @@ const cases: Case[] = [
     b: sameNameClassInstance,
     strict: false,
     loose: true,
-    strictBug: "matches classes by name, so reports equal",
   },
   {
     name: "an Array subclass instance and an array",
@@ -256,7 +253,6 @@ const cases: Case[] = [
     b: () => [],
     strict: false,
     loose: true,
-    strictBug: "reports equal",
   },
   {
     name: "[] and Object.create(Array.prototype)",
@@ -342,7 +338,6 @@ const cases: Case[] = [
     b: () => new Date(0),
     strict: false,
     loose: false,
-    strictBug: "reports equal",
     looseBug: "reports equal",
   },
 
@@ -355,7 +350,6 @@ const cases: Case[] = [
     b: () => /a/g,
     strict: false,
     loose: false,
-    strictBug: "reports equal",
     looseBug: "reports equal",
   },
 
@@ -441,7 +435,6 @@ const cases: Case[] = [
     b: () => new Map(),
     strict: false,
     loose: false,
-    strictBug: "reports equal",
     looseBug: "reports equal",
   },
   {
@@ -462,7 +455,6 @@ const cases: Case[] = [
     b: () => new WeakMap(),
     strict: false,
     loose: false,
-    strictBug: "reports equal",
     looseBug: "reports equal",
   },
   {
@@ -471,7 +463,6 @@ const cases: Case[] = [
     b: () => new WeakSet(),
     strict: false,
     loose: false,
-    strictBug: "reports equal",
     looseBug: "reports equal",
   },
   {
@@ -533,13 +524,29 @@ const cases: Case[] = [
     strict: true,
     loose: true,
   },
+  {
+    name: "a DataView with an extra own string-named property",
+    a: () => withExtraProperty(new DataView(new ArrayBuffer(2))),
+    b: () => new DataView(new ArrayBuffer(2)),
+    strict: false,
+    loose: false,
+  },
+  {
+    // node's DataView compare uses getOwnNonIndexProperties; an integer-index
+    // own property is ignored, like on typed arrays.
+    name: "a DataView with an extra integer-index own property",
+    a: () => Object.assign(new DataView(new ArrayBuffer(2)), { 0: 1 }),
+    b: () => new DataView(new ArrayBuffer(2)),
+    strict: true,
+    loose: true,
+    looseBug: "reports not equal",
+  },
   {
     name: "a Buffer and a Uint8Array with the same bytes",
     a: () => Buffer.from([1]),
     b: () => new Uint8Array([1]),
     strict: false,
     loose: true,
-    strictBug: "reports equal",
   },
   {
     name: "a typed array with an extra own property",
@@ -582,7 +589,6 @@ const cases: Case[] = [
     b: () => [1],
     strict: false,
     loose: false,
-    strictBug: "reports equal",
     looseBug: "reports equal",
   },
   { name: "arrays of different length", a: () => [1, 2], b: () => [1], strict: false, loose: false },
@@ -690,6 +696,18 @@ describe("util.isDeepStrictEqual", () => {
     expect(util.isDeepStrictEqual(Object.create(null), Object.create(null))).toBe(true);
   });
 
+  test("reads an array's own symbol-keyed getter once per side", () => {
+    const s = Symbol("k");
+    let calls = 0;
+    const make = () => {
+      const a = [1];
+      Object.defineProperty(a, s, { enumerable: true, get: () => (calls++, 42) });
+      return a;
+    };
+    expect(util.isDeepStrictEqual(make(), make())).toBe(true);
+    expect(calls).toBe(2);
+  });
+
   // The third argument was added in Node v26.
   describe("skipPrototype", () => {
     class Foo {
@@ -759,10 +777,40 @@ describe("detached ArrayBuffer", () => {
     });
   }
 
+  test("deepStrictEqual throws Node's DataView TypeError on a detached view", () => {
+    const detachedView = () => {
+      const ab = new ArrayBuffer(4);
+      const dv = new DataView(ab);
+      structuredClone(ab, { transfer: [ab] });
+      return dv;
+    };
+    const error = caught(() => assert.deepStrictEqual(detachedView(), new DataView(new ArrayBuffer(0))));
+    expect(error).toBeInstanceOf(TypeError);
+    expect(error?.message).toBe(
+      "Cannot perform get DataView.prototype.byteLength on a detached or out-of-bounds ArrayBuffer",
+    );
+    expect(() => util.isDeepStrictEqual(detachedView(), new DataView(new ArrayBuffer(0)))).toThrow(TypeError);
+    // Bun.deepEquals keeps its own-properties DataView surface: no throw.
+    expect(Bun.deepEquals(detachedView(), new DataView(new ArrayBuffer(0)), true)).toBe(true);
+  });
+
   test("assert.partialDeepStrictEqual throws TypeError on a detached ArrayBuffer", () => {
     expect(() => assert.partialDeepStrictEqual(detached(), new ArrayBuffer(0))).toThrow(TypeError);
   });
 
+  test("assert.partialDeepStrictEqual checks own properties on a KeyObject after equals()", () => {
+    const crypto = require("node:crypto");
+    const key = crypto.createSecretKey(Buffer.from("secret"));
+    const key2 = crypto.createSecretKey(Buffer.from("secret"));
+    Object.assign(key2, { x: 1 });
+    // expected has {x:1} that actual lacks: node throws ERR_ASSERTION.
+    expect(() => assert.partialDeepStrictEqual(key, key2)).toThrow(assert.AssertionError);
+    // subset direction: extra own prop on actual is fine.
+    expect(() =>
+      assert.partialDeepStrictEqual(Object.assign(key, { x: 1 }), crypto.createSecretKey(Buffer.from("secret"))),
+    ).not.toThrow();
+  });
+
   test("error matches Node's message", () => {
     const error = caught(() => assert.deepStrictEqual(detached(), new ArrayBuffer(0)));
     expect(error).toBeInstanceOf(TypeError);
diff --git a/test/js/node/buffer.test.js b/test/js/node/buffer.test.js
index 65d94b53c996..c33e319a2c2c 100644
--- a/test/js/node/buffer.test.js
+++ b/test/js/node/buffer.test.js
@@ -2786,10 +2786,58 @@ for (let withOverridenBufferWrite of [false, true]) {
       });
 
       it("transcode", () => {
-        expect(typeof BufferModule.transcode).toBe("undefined");
+        expect(typeof BufferModule.transcode).toBe("function");
+        const transcode = BufferModule.transcode;
 
-        // This is a masqueradesAsUndefined function
-        expect(() => BufferModule.transcode()).toThrow("Not implemented");
+        expect(transcode(Buffer.from("hä", "latin1"), "latin1", "utf8")).toStrictEqual(Buffer.from("hä", "utf8"));
+        expect(() => transcode(Buffer.from("a"), "b", "utf8")).toThrow(
+          "Unable to transcode Buffer [U_ILLEGAL_ARGUMENT_ERROR]",
+        );
+        expect(() => transcode()).toThrow(
+          'The "source" argument must be an instance of Buffer or Uint8Array. Received undefined',
+        );
+
+        // Substitution matrix, verified against node v25.2.1.
+        const cases = [
+          [[0xe4], "ascii", "utf8", [239, 191, 189]], // invalid ascii decodes to U+FFFD
+          [[0xe4], "ascii", "latin1", [0x3f]], // ...and U+FFFD narrows to '?'
+          [[0xe4], "ascii", "ucs2", [0xe4, 0x00]], // ascii->ucs2 widens like latin1
+          [[0xc0], "utf8", "utf8", [239, 191, 189]],
+          [[0xc0, 0x41], "utf8", "latin1", [0x3f, 0x41]],
+          [[0xf0, 0x80, 0x80], "utf8", "latin1", [0x3f, 0x3f, 0x3f]], // one U+FFFD per ill-formed byte
+          [[0xe1, 0x80], "utf8", "latin1", [0x3f]], // truncated sequence at EOF is one U+FFFD
+          [[0x41], "ucs2", "ucs2", [0xfd, 0xff]], // trailing odd byte becomes U+FFFD
+          [[0x41, 0x00, 0x42], "ucs2", "ucs2", [0x41, 0x00, 0xfd, 0xff]],
+          [[0x00, 0xd8], "ucs2", "ucs2", [0xfd, 0xff]], // lone surrogate becomes U+FFFD
+          [[0x00, 0xd8], "ucs2", "latin1", [0x3f]],
+          [[0x3d, 0xd8, 0x00, 0xde], "ucs2", "latin1", [0x3f]], // a full pair is one '?'
+          [[0x41], "ucs2", "latin1", []], // odd byte dropped for narrow targets
+          [[0x41, 0x00, 0x42], "ucs2", "utf8", [0x41]],
+          [[0x41], "utf8", "utf8", [0x41]],
+          [[0x41], undefined, undefined, [0x41]], // normalizeEncoding defaults to utf8
+          [[0x41], "", "ascii", [0x41]],
+        ];
+        for (const [bytes, from, to, expected] of cases) {
+          expect([...transcode(Buffer.from(bytes), from, to)]).toEqual(expected);
+        }
+
+        // Failures keep node's error contract.
+        for (const [bytes, from, to] of [
+          [[0xc0, 0x41], "utf8", "ucs2"],
+          [[0x00, 0xd8], "ucs2", "utf8"],
+          [[0x41], "ucs2", "utf8"],
+        ]) {
+          expect(() => transcode(Buffer.from(bytes), from, to)).toThrow(
+            expect.objectContaining({
+              message: "Unable to transcode Buffer [U_INVALID_CHAR_FOUND]",
+              code: "U_INVALID_CHAR_FOUND",
+              errno: 10,
+            }),
+          );
+        }
+        expect(() => transcode(Buffer.from("a"), "base64", "utf8")).toThrow(
+          expect.objectContaining({ code: "U_ILLEGAL_ARGUMENT_ERROR", errno: 1 }),
+        );
       });
 
       it("Buffer.from (Node.js test/test-buffer-from.js)", () => {
diff --git a/test/js/node/fs/fs.test.ts b/test/js/node/fs/fs.test.ts
index fc1e6dcb8cbf..8f6ed6d8eac8 100644
--- a/test/js/node/fs/fs.test.ts
+++ b/test/js/node/fs/fs.test.ts
@@ -6002,3 +6002,102 @@ describe("fs.close on stdio descriptors", () => {
     expect(exitCode).toBe(0);
   });
 });
+
+// A throw inside a node-style async callback must surface as an
+// uncaughtException, as in node, where these callbacks run off the libuv
+// request completion rather than from a promise reaction.
+describe("a throw from a node-style callback is an uncaughtException", () => {
+  const dir = tempDirWithFiles("callback-throw-uncaught", { "file.txt": "hello" });
+  const file = JSON.stringify(join(dir, "file.txt"));
+  const dirLit = JSON.stringify(dir);
+
+  async function runScript(source: string) {
+    await using proc = Bun.spawn({ cmd: [bunExe(), "-e", source], env: bunEnv, stdout: "pipe", stderr: "pipe" });
+    // Drain stderr too so a noisy child can't fill the pipe and deadlock.
+    const [stdout, , exitCode] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+      proc.exited,
+    ]);
+    return { stdout: stdout.trim(), exitCode };
+  }
+
+  const cases: Array<[string, string]> = [
+    ["fs.exists", `require("fs").exists("/definitely/not/here", () => { throw new Error("boom"); })`],
+    ["fs.stat", `require("fs").stat("/definitely/not/here", () => { throw new Error("boom"); })`],
+    ["fs.stat (success)", `require("fs").stat(${file}, () => { throw new Error("boom"); })`],
+    ["fs.readFile", `require("fs").readFile(${file}, () => { throw new Error("boom"); })`],
+    ["fs.readdir", `require("fs").readdir(${dirLit}, () => { throw new Error("boom"); })`],
+    ["fs.open", `require("fs").open("/definitely/not/here", "r", () => { throw new Error("boom"); })`],
+    ["fs.access", `require("fs").access(${file}, () => { throw new Error("boom"); })`],
+    ["fs.realpath", `require("fs").realpath(${file}, () => { throw new Error("boom"); })`],
+    [
+      "fs.close",
+      `const fs = require("fs"); fs.open(${file}, "r", (e, fd) => fs.close(fd, () => { throw new Error("boom"); }))`,
+    ],
+    [
+      "fs.read",
+      `const fs = require("fs"); fs.open(${file}, "r", (e, fd) => fs.read(fd, Buffer.alloc(4), 0, 4, 0, () => { throw new Error("boom"); }))`,
+    ],
+    // Both symlink overloads: the 4-argument form takes a different path.
+    ["fs.symlink (3-arg)", `require("fs").symlink(${file}, ${dirLit} + "/l3", () => { throw new Error("boom"); })`],
+    [
+      "fs.symlink (4-arg)",
+      `require("fs").symlink(${file}, ${dirLit} + "/l4", "file", () => { throw new Error("boom"); })`,
+    ],
+    ["dns.lookup", `require("dns").lookup("localhost", () => { throw new Error("boom"); })`],
+    ["dns.reverse", `require("dns").reverse("127.0.0.1", () => { throw new Error("boom"); })`],
+    ["crypto.pbkdf2", `require("crypto").pbkdf2("pw", "salt", 10, 16, "sha256", () => { throw new Error("boom"); })`],
+  ];
+
+  it.each(cases)("%s", async (_name, snippet) => {
+    const { stdout, exitCode } = await runScript(`
+      process.on("uncaughtException", e => { console.log("UNCAUGHT:" + e.message); process.exit(0); });
+      process.on("unhandledRejection", e => { console.log("REJECTED:" + (e && e.message)); process.exit(0); });
+      setTimeout(() => { console.log("NOTHING"); process.exit(0); }, 5000);
+      ${snippet};
+    `);
+    expect(stdout).toBe("UNCAUGHT:boom");
+    expect(exitCode).toBe(0);
+  });
+
+  it("keeps a non-throwing callback in the same place in the event loop", async () => {
+    const { stdout, exitCode } = await runScript(`
+      const fs = require("fs");
+      const log = [];
+      fs.stat(${file}, (err, st) => {
+        log.push("fs-cb:" + (err === null) + ":" + st.isFile());
+        process.nextTick(() => log.push("tick-from-fs-cb"));
+      });
+      setImmediate(() => log.push("setImmediate"));
+      process.on("exit", () => console.log(log.join(",")));
+    `);
+    expect(stdout).toBe("fs-cb:true:true,tick-from-fs-cb,setImmediate");
+    expect(exitCode).toBe(0);
+  });
+
+  it("is transparent to fs.Dir callbacks", async () => {
+    const { stdout, exitCode } = await runScript(`
+      const odir = require("fs").mkdtempSync(require("os").tmpdir() + "/cb-throw-opendir-");
+      require("fs").writeFileSync(odir + "/file.txt", "x");
+      require("fs").opendir(odir, (err, dir) => {
+        if (err) throw err;
+        dir.read((e, ent) => {
+          console.log(ent && ent.name);
+          dir.close(() => console.log("closed"));
+        });
+      });
+    `);
+    expect(stdout.split("\n")).toEqual(["file.txt", "closed"]);
+    expect(exitCode).toBe(0);
+  });
+
+  it("leaves a non-callable symlink callback as an ignored handler, like node", async () => {
+    const { stdout, exitCode } = await runScript(`
+      require("fs").symlink(${file}, ${dirLit} + "/lnc", "file", "notafunc");
+      setTimeout(() => console.log("quiet"), 50);
+    `);
+    expect(stdout).toBe("quiet");
+    expect(exitCode).toBe(0);
+  });
+});
diff --git a/test/js/node/missing-module.test.js b/test/js/node/missing-module.test.js
index 9481948fb4e0..144f647e72df 100644
--- a/test/js/node/missing-module.test.js
+++ b/test/js/node/missing-module.test.js
@@ -12,7 +12,7 @@ test("not implemented yet module throws an error", () => {
     code: "ERR_UNKNOWN_BUILTIN_MODULE",
   });
   assert.throws(() => require.resolve(missingModule), {
-    message: /Cannot find package 'node:missing' from/,
+    message: /^Cannot find module 'node:missing'\nRequire stack:\n- /,
     code: "MODULE_NOT_FOUND",
   });
   assert.rejects(() => import(missingModule), {
@@ -21,15 +21,15 @@ test("not implemented yet module throws an error", () => {
   });
 
   assert.throws(() => require(missingBun), {
-    message: /^Cannot find package 'bun:missing' from/,
+    message: /^Cannot find module 'bun:missing'\nRequire stack:\n- /,
     code: "MODULE_NOT_FOUND",
   });
   assert.throws(() => require.resolve(missingBun), {
-    message: /^Cannot find package 'bun:missing' from/,
+    message: /^Cannot find module 'bun:missing'\nRequire stack:\n- /,
     code: "MODULE_NOT_FOUND",
   });
   assert.rejects(() => import(missingBun), {
-    message: /^Cannot find package 'bun:missing' from/,
+    message: /^Cannot find package 'bun:missing' imported from /,
     code: "ERR_MODULE_NOT_FOUND",
   });
 
@@ -47,15 +47,15 @@ test("not implemented yet module throws an error", () => {
   });
 
   assert.throws(() => require(missingPackage), {
-    message: /^Cannot find package 'package-that-doesnt-exist'/,
+    message: /^Cannot find module 'package-that-doesnt-exist'\nRequire stack:\n- /,
     code: "MODULE_NOT_FOUND",
   });
   assert.throws(() => require.resolve(missingPackage), {
-    message: /^Cannot find package 'package-that-doesnt-exist'/,
+    message: /^Cannot find module 'package-that-doesnt-exist'\nRequire stack:\n- /,
     code: "MODULE_NOT_FOUND",
   });
   assert.rejects(() => import(missingPackage), {
-    message: /^Cannot find package 'package-that-doesnt-exist'/,
+    message: /^Cannot find package 'package-that-doesnt-exist' imported from /,
     code: "ERR_MODULE_NOT_FOUND",
   });
 });
diff --git a/test/js/node/module/node-module-module.test.js b/test/js/node/module/node-module-module.test.js
index 5bf58dc0e07c..748e80f1d955 100644
--- a/test/js/node/module/node-module-module.test.js
+++ b/test/js/node/module/node-module-module.test.js
@@ -1,5 +1,6 @@
 import { describe, expect, test } from "bun:test";
-import { bunEnv, bunExe, ospath } from "harness";
+import fs from "fs";
+import { bunEnv, bunExe, isWindows, ospath, tempDir } from "harness";
 import Module, { _nodeModulePaths, builtinModules, createRequire, isBuiltin, wrap } from "module";
 import path from "path";
 
@@ -66,20 +67,128 @@ describe.concurrent("node-module-module", () => {
       }),
     ).toThrow(new RangeError("portable boom"));
     expect(order).toEqual(["directory", "portable"]);
-    // Valid shapes: string | {directory?, portable?} | undefined.
-    for (const ok of [
-      undefined,
-      "/tmp/cache",
-      {},
-      [],
-      Object.create(null),
-      { directory: "/tmp/cache" },
-      { directory: undefined },
-    ]) {
-      expect(Module.enableCompileCache(ok)).toEqual({
-        status: Module.constants.compileCacheStatus.FAILED,
-        message: expect.any(String),
+  });
+
+  test("module.enableCompileCache accepts valid shapes", async () => {
+    // Run in a child so enabling the cache doesn't affect this test process.
+    using dir = tempDir("compile-cache-shapes", {});
+    const cacheDir = JSON.stringify(path.join(String(dir), "cc"));
+    // Valid shapes: string | {directory?, portable?} | undefined. The first
+    // call enables the cache; the rest report ALREADY_ENABLED.
+    const code = `
+      const Module = require("module");
+      const { ENABLED, ALREADY_ENABLED } = Module.constants.compileCacheStatus;
+      const shapes = [
+        ${cacheDir},
+        undefined,
+        {},
+        [],
+        Object.create(null),
+        { directory: ${cacheDir} },
+        { directory: undefined },
+      ];
+      for (const shape of shapes) {
+        const r = Module.enableCompileCache(shape);
+        if (r.status !== ENABLED && r.status !== ALREADY_ENABLED) {
+          console.error("unexpected status", r.status, JSON.stringify(r));
+          process.exit(1);
+        }
+        if (typeof r.directory !== "string") {
+          console.error("missing directory", JSON.stringify(r));
+          process.exit(1);
+        }
+      }
+      console.log("shapes-ok");
+    `;
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), "-e", code],
+      env: bunEnv,
+      stderr: "pipe",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+    expect(stdout.trim()).toBe("shapes-ok");
+    expect(stderr).toBe("");
+    expect(exitCode).toBe(0);
+  });
+
+  test.skipIf(process.platform === "win32")(
+    "compile cache persists modules loaded after a non-fatal self-kill",
+    async () => {
+      // A self-directed signal that proves non-fatal (SIGWINCH is ignored by
+      // default) must not latch the exit-time persist: modules loaded after
+      // the kill still reach the cache when the process really exits.
+      using dir = tempDir("compile-cache-selfkill", {
+        "late.js": "module.exports = 42;",
+        "main.js": `process.kill(process.pid, "SIGWINCH");
+console.log("survived", require("./late.js"));`,
       });
+      const cacheDir = path.join(String(dir), "cc");
+      await using proc = Bun.spawn({
+        cmd: [bunExe(), "main.js"],
+        env: { ...bunEnv, NODE_COMPILE_CACHE: cacheDir },
+        cwd: String(dir),
+        stderr: "pipe",
+      });
+      const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+      expect(stdout.trim()).toBe("survived 42");
+      expect(exitCode).toBe(0);
+      // Both main.js and late.js are cached; pre-fix only main.js was.
+      const files = [...new Bun.Glob("**/*").scanSync({ cwd: cacheDir, onlyFiles: true })];
+      expect(files.length).toBe(2);
+    },
+  );
+
+  test.skipIf(!isWindows)("enableCompileCache default dir prefers TEMP over TMP like os.tmpdir", async () => {
+    using dir = tempDir("compile-cache-tmporder", {});
+    const temp = path.join(String(dir), "from-temp");
+    const tmp = path.join(String(dir), "from-tmp");
+    fs.mkdirSync(temp);
+    fs.mkdirSync(tmp);
+    const env = { ...bunEnv, TEMP: temp, TMP: tmp };
+    delete env.NODE_COMPILE_CACHE;
+    await using proc = Bun.spawn({
+      cmd: [
+        bunExe(),
+        "-e",
+        `const r = require("module").enableCompileCache();
+        console.log(JSON.stringify(r.directory));`,
+      ],
+      env,
+      stderr: "pipe",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+    expect(stderr).toBe("");
+    expect(JSON.parse(stdout.trim())).toStartWith(path.join(temp, "node-compile-cache"));
+    expect(exitCode).toBe(0);
+  });
+
+  test("compile cache entries are keyed by sha256 and accepted on re-run", async () => {
+    using dir = tempDir("compile-cache-sha", {
+      "main.js": `console.log(require("./dep.js"));`,
+      "dep.js": "module.exports = 7;",
+    });
+    const cacheDir = path.join(String(dir), "cc");
+    const env = { ...bunEnv, NODE_COMPILE_CACHE: cacheDir, NODE_DEBUG_NATIVE: "COMPILE_CACHE" };
+    {
+      await using proc = Bun.spawn({ cmd: [bunExe(), "main.js"], env, cwd: String(dir), stderr: "pipe" });
+      const [stdout, exitCode] = await Promise.all([proc.stdout.text(), proc.exited]);
+      expect(stdout.trim()).toBe("7");
+      expect(exitCode).toBe(0);
+    }
+    // Entry names are the first 8 bytes of SHA256(type byte || path) in hex.
+    const files = [...new Bun.Glob("**/*").scanSync({ cwd: cacheDir, onlyFiles: true })];
+    expect(files.length).toBe(2);
+    for (const f of files) {
+      expect(path.basename(f)).toMatch(/^[0-9a-f]{16}$/);
+    }
+    {
+      await using proc = Bun.spawn({ cmd: [bunExe(), "main.js"], env, cwd: String(dir), stderr: "pipe" });
+      const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+      expect(stdout.trim()).toBe("7");
+      // The second run accepts both entries from disk and rewrites nothing.
+      expect(stderr).toContain("was accepted");
+      expect(stderr).not.toContain("writing cache");
+      expect(exitCode).toBe(0);
     }
   });
 
diff --git a/test/js/node/process-binding.test.ts b/test/js/node/process-binding.test.ts
index e2f2120cb3db..420aab936270 100644
--- a/test/js/node/process-binding.test.ts
+++ b/test/js/node/process-binding.test.ts
@@ -22,7 +22,7 @@ describe("process.binding", () => {
     expect(uv.errname(uv.UV_EINTR - 1.9 + Number("1.9"))).toBe("EINTR");
     expect(uv.errname(uv.UV_EINTR)).toBe("EINTR");
 
-    expect(uv.errname(5)).toBe("Unknown system error: 5");
+    expect(uv.errname(5)).toBe("Unknown system error 5");
 
     const map = uv.getErrorMap();
     expect(map).toBeDefined();
diff --git a/test/js/node/process/process.test.js b/test/js/node/process/process.test.js
index 67cc45c27da1..2dc2a4617c76 100644
--- a/test/js/node/process/process.test.js
+++ b/test/js/node/process/process.test.js
@@ -1965,6 +1965,36 @@ it("proxy env vars assigned at runtime propagate to spawned children via {...pro
   expect(got).toEqual({ HTTP_PROXY: "http://x:8080", HTTPS_PROXY: "http://y:8080", NO_PROXY: "z" });
 });
 
+// DEP0111/DEP0119 latch once per thread, like node's per-Environment
+// deprecate() closures: a worker warns again even after the main thread did.
+it("process.binding deprecation warnings latch per thread, not per process", () => {
+  using dir = tempDir("binding-deprecation-latch", {
+    "main.js": `const { Worker } = require("worker_threads");
+let count = 0;
+process.on("warning", w => { if (w.code === "DEP0119") count++; });
+process.binding("uv").errname(-2);
+process.binding("uv").errname(-2); // second call must not warn again
+const w = new Worker(require("path").join(__dirname, "worker.js"));
+w.on("message", m => console.log(m));
+w.on("exit", () => console.log("main-warned:" + count));`,
+    "worker.js": `const { parentPort } = require("worker_threads");
+let warned = 0;
+process.on("warning", x => { if (x.code === "DEP0119") warned++; });
+process.binding("uv").errname(-2);
+process.binding("uv").errname(-2); // the worker-local latch must hold too
+setImmediate(() => parentPort.postMessage("worker-warned:" + warned));`,
+  });
+  const child = spawnSync({
+    cmd: [bunExe(), "--pending-deprecation", "main.js"],
+    env: bunEnv,
+    cwd: String(dir),
+  });
+  const out = child.stdout.toString();
+  expect(out).toContain("worker-warned:1");
+  expect(out).toContain("main-warned:1");
+  expect(child.exitCode).toBe(0);
+});
+
 it("delete process.env.TZ invalidates existing Date instances", async () => {
   await using proc = Bun.spawn({
     cmd: [
diff --git a/test/js/node/readline/readline.node.test.ts b/test/js/node/readline/readline.node.test.ts
index 26b97be82a69..3a0a8544d67f 100644
--- a/test/js/node/readline/readline.node.test.ts
+++ b/test/js/node/readline/readline.node.test.ts
@@ -1332,7 +1332,10 @@ describe("readline.Interface", () => {
     assert.strictEqual(getStringWidth("你好"), 4);
     assert.strictEqual(getStringWidth("안녕하세요"), 10);
     assert.strictEqual(getStringWidth("A\ud83c\ude00BC"), 5);
-    assert.strictEqual(getStringWidth("👨‍👩‍👦‍👦"), 2);
+    // Node v26.3.0 measures each emoji in a ZWJ sequence individually:
+    // internalBinding("icu").getStringWidth's expand_emoji_sequence defaults
+    // on (src/node_i18n.cc:649), so the family emoji is 2+0+2+0+2+0+2.
+    assert.strictEqual(getStringWidth("👨‍👩‍👦‍👦"), 8);
     assert.strictEqual(getStringWidth("🐕𐐷あ💻😀"), 9);
     // TODO(BridgeAR): This should have a width of 4.
     assert.strictEqual(getStringWidth("⓬⓪"), 2);
diff --git a/test/js/node/test/.gitignore b/test/js/node/test/.gitignore
index d8c99a70d948..790c5e93c0ec 100644
--- a/test/js/node/test/.gitignore
+++ b/test/js/node/test/.gitignore
@@ -1,11 +1,17 @@
-fixtures/wpt
+# Keep the wpt tree unvendored except the url resources the vendored
+# whatwg-url tests require.
+fixtures/wpt/*
+!fixtures/wpt/LICENSE.md
+!fixtures/wpt/README.md
+!fixtures/wpt/url/
 fixtures/tools
 fixtures/v8-coverage
 fixtures/test-runner/*
 !fixtures/test-runner/index.js
 !fixtures/test-runner/tagged.js
 fixtures/source-map
-fixtures/snapshot
+fixtures/snapshot/*
+!fixtures/snapshot/typescript.js
 fixtures/repl*
 .tmp.*
 **/fails.txt
diff --git a/test/js/node/test/common/assertSnapshot.js b/test/js/node/test/common/assertSnapshot.js
index dbd4a6079861..53445f366ba6 100644
--- a/test/js/node/test/common/assertSnapshot.js
+++ b/test/js/node/test/common/assertSnapshot.js
@@ -77,7 +77,7 @@ async function spawnAndAssert(filename, transform = (x) => x, { tty = false, ...
     test({ skip: 'Skipping pseudo-tty tests, as pseudo terminals are not available on Windows.' });
     return;
   }
-  let flags = common.parseTestFlags(filename);
+  let { flags } = common.parseTestMetadata(filename);
   if (options.flags) {
     flags = [...options.flags, ...flags];
   }
diff --git a/test/js/node/test/common/index.js b/test/js/node/test/common/index.js
index f53f938450a5..49dfc2cd69f0 100644
--- a/test/js/node/test/common/index.js
+++ b/test/js/node/test/common/index.js
@@ -59,6 +59,11 @@ const hasCrypto = Boolean(process.versions.openssl) &&
 
 const hasSQLite = Boolean(process.versions.sqlite);
 
+// Node gates these on build variables (v8_enable_temporal_support and
+// --localstorage-file). Bun has no equivalent knobs, so feature-detect.
+const hasTemporal = typeof globalThis.Temporal === 'object' && globalThis.Temporal !== null;
+const hasLocalStorage = Object.getOwnPropertyDescriptor(globalThis, 'localStorage')?.enumerable === true;
+
 // Synthesize OPENSSL_VERSION_NUMBER format with the layout 0xMNN00PPSL
 const opensslVersionNumber = (major = 0, minor = 0, patch = 0) => {
   assert(major >= 0 && major <= 0xf);
@@ -83,8 +88,8 @@ const hasOpenSSL = (major = 0, minor = 0, patch = 0) => {
 
 const hasQuic = hasCrypto && !!process.features.quic;
 
-function parseTestFlags(filename = process.argv[1]) {
-  // The copyright notice is relatively big and the flags could come afterwards.
+function parseTestMetadata(filename = process.argv[1]) {
+  // The copyright notice is relatively big and the metadata could come afterwards.
   const bytesToRead = 1500;
   const buffer = Buffer.allocUnsafe(bytesToRead);
   const fd = fs.openSync(filename, 'r');
@@ -92,28 +97,40 @@ function parseTestFlags(filename = process.argv[1]) {
   fs.closeSync(fd);
   const source = buffer.toString('utf8', 0, bytesRead);
 
-  const flags = [];
   const flagStart = source.search(/\/\/ Flags:\s+--/) + 10;
-
-  const isNodeTest = source.includes('node:test');
-  if (isNodeTest) {
-    flags.push('test');
+  let flags = [];
+  if (flagStart !== 9) {
+    let flagEnd = source.indexOf('\n', flagStart);
+    // Normalize different EOL.
+    if (source[flagEnd - 1] === '\r') {
+      flagEnd--;
+    }
+    flags = source
+      .substring(flagStart, flagEnd)
+      .split(/\s+/)
+      .filter(Boolean);
   }
 
-  if (flagStart === 9) {
-    return flags;
+  // Bun: node:test files re-spawn as `bun test <file>` when a flag needs it.
+  if (source.includes('node:test')) {
+    flags = flags.concat('test');
   }
-  let flagEnd = source.indexOf('\n', flagStart);
-  // Normalize different EOL.
-  if (source[flagEnd - 1] === '\r') {
-    flagEnd--;
+
+  const envStart = source.search(/\/\/ Env:\s+/) + 8;
+  let envs = {};
+  if (envStart !== 7) {
+    let envEnd = source.indexOf('\n', envStart);
+    if (source[envEnd - 1] === '\r') {
+      envEnd--;
+    }
+    const envArray = source
+      .substring(envStart, envEnd)
+      .split(/\s+/)
+      .filter(Boolean);
+    envs = Object.fromEntries(envArray.map((env) => env.split('=')));
   }
 
-  return source
-    .substring(flagStart, flagEnd)
-    .split(/\s+/)
-    .filter(Boolean)
-    .concat(flags);
+  return { flags, envs };
 }
 
 // Check for flags. Skip this for workers (both, the `cluster` module and
@@ -126,11 +143,21 @@ if (process.argv.length === 2 &&
     hasCrypto &&
     require('cluster').isPrimary &&
     fs.existsSync(process.argv[1])) {
-  const flags = parseTestFlags();
+  const { flags, envs } = parseTestMetadata();
   if (process.versions.bun && process.execArgv.includes("--expose-internals")) {
     installBunExposeInternalsRequireInterceptor();
   }
+  const envsTriggerSpawn = Object.keys(envs).some((key) => process.env[key] !== envs[key]);
+  let flagsTriggerSpawn = false;
   for (const flag of flags) {
+    if (flag === "--expose-internals" && process.versions.bun) {
+      // Bun accepts the flag but it does not expose internals, so install the
+      // shim even in a re-spawned child that already has it in execArgv. Keep
+      // scanning so a later --expose-gc on the same Flags line still applies.
+      process.env.SKIP_FLAG_CHECK = "1";
+      installBunExposeInternalsRequireInterceptor();
+      continue;
+    }
     if (!process.execArgv.includes(flag) &&
         // If the binary is build without `intl` the inspect option is
         // invalid. The test itself should handle this case.
@@ -169,11 +196,6 @@ if (process.argv.length === 2 &&
         };
         break;
       }
-      if (flag === "--expose-internals" && process.versions.bun) {
-        process.env.SKIP_FLAG_CHECK = "1";
-        installBunExposeInternalsRequireInterceptor();
-        break;
-      }
       if ((flag === "--experimental-sqlite" || flag === "--no-experimental-sqlite") && process.versions.bun) {
         // node:sqlite is always available in Bun; the Node experimental gate
         // does not exist, so don't re-spawn just to pass the flag through.
@@ -183,19 +205,33 @@ if (process.argv.length === 2 &&
         process.env.SKIP_FLAG_CHECK = "1";
         break;
       }
-      console.log(
-        'NOTE: The test started as a child_process using these flags:',
-        inspect(flags),
-        'Use NODE_SKIP_FLAG_CHECK to run the test with the original flags.',
-      );
-      const args = [...flags, ...process.execArgv, ...process.argv.slice(1)];
-      const options = { encoding: 'utf8', stdio: 'inherit' };
-      const result = spawnSync(process.execPath, args, options);
-      if (result.signal) {
-        process.kill(process.pid, result.signal);
-      } else {
-        process.exit(result.status);
-      }
+      flagsTriggerSpawn = true;
+      break;
+    }
+  }
+
+  if (flagsTriggerSpawn || envsTriggerSpawn) {
+    console.log(
+      'NOTE: The test started as a child_process using these flags:',
+      inspect(flags),
+      'And these environment variables:',
+      inspect(envs),
+      'Use NODE_SKIP_FLAG_CHECK to run the test with the original flags.',
+    );
+    const args = [...flags, ...process.execArgv, ...process.argv.slice(1)];
+    const options = {
+      encoding: 'utf8',
+      stdio: 'inherit',
+      env: {
+        ...process.env,
+        ...envs,
+      },
+    };
+    const result = spawnSync(process.execPath, args, options);
+    if (result.signal) {
+      process.kill(process.pid, result.signal);
+    } else {
+      process.exit(result.status);
     }
   }
 }
@@ -209,7 +245,7 @@ if (process.versions.bun &&
     isMainThread &&
     !require('cluster').isPrimary &&
     fs.existsSync(process.argv[1]) &&
-    parseTestFlags().includes('--expose-internals')) {
+    parseTestMetadata().flags.includes('--expose-internals')) {
   installBunExposeInternalsRequireInterceptor();
 }
 
@@ -219,14 +255,42 @@ if (process.versions.bun &&
 // for release). Unknown internal/* specifiers fall through to the
 // original require and fail exactly as before.
 function installBunExposeInternalsRequireInterceptor() {
+  if (installBunExposeInternalsRequireInterceptor.installed) return;
+  installBunExposeInternalsRequireInterceptor.installed = true;
   const BunModule = require('module');
   const originalRequire = BunModule.prototype.require;
   let exposedInternals;
+  let requireVendoredNodeInternal;
+  const mergedInternals = { __proto__: null };
   BunModule.prototype.require = function require(id) {
     if (typeof id === 'string' && id.startsWith('internal/')) {
       exposedInternals ??= originalRequire.call(this, 'bun:internal-for-testing').exposedInternals;
-      if (exposedInternals[id] !== undefined) {
-        return exposedInternals[id];
+      // Pure-JS node internals vendored under common/nodeinternals/ (webidl,
+      // socket_list, fs/utils, webcrypto helpers). undefined = not vendored.
+      requireVendoredNodeInternal ??= originalRequire.call(this, path.join(__dirname, 'nodeinternals.js')).requireVendoredNodeInternal;
+      const exposed = exposedInternals[id];
+      if (exposed !== undefined) {
+        // A native entry may cover only part of the module's surface; fill
+        // the gaps from the vendored port, with the real implementations
+        // winning key-for-key (internal/fs/utils: native stringToFlags /
+        // validateRmOptionsSync + vendored getDirents/getDirent). Cached so
+        // repeated requires return the same module object, like node.
+        if (typeof exposed === 'object' && exposed !== null && !Array.isArray(exposed)) {
+          const cached = mergedInternals[id];
+          if (cached !== undefined) {
+            return cached;
+          }
+          const vendored = requireVendoredNodeInternal(id);
+          if (vendored !== undefined && typeof vendored === 'object' && vendored !== null) {
+            return (mergedInternals[id] = { ...vendored, ...exposed });
+          }
+          return (mergedInternals[id] = exposed);
+        }
+        return exposed;
+      }
+      const vendored = requireVendoredNodeInternal(id);
+      if (vendored !== undefined) {
+        return vendored;
       }
     }
     return originalRequire.apply(this, arguments);
@@ -1153,6 +1217,8 @@ const common = {
   hasOpenSSL,
   hasQuic,
   hasSQLite,
+  hasTemporal,
+  hasLocalStorage,
   hasMultiLocalhost,
   invalidArgTypeHelper,
   isAlive,
@@ -1176,7 +1242,7 @@ const common = {
   nodeProcessAborted,
   openSSLIsBoringSSL,
   PIPE,
-  parseTestFlags,
+  parseTestMetadata,
   platformTimeout,
   printSkipMessage,
   pwdCommand,
@@ -1418,6 +1484,17 @@ function installBunExposeInternalsShim() {
         loader: "object",
         exports: { getDefaultHighWaterMark: require("node:stream").getDefaultHighWaterMark },
       }));
+      // node's internal/net: normalizedArgsSymbol is a module-private symbol in
+      // Bun's node:net. Recover the real one from a real _normalizeArgs result
+      // rather than minting a look-alike.
+      build.module("internal/net", () => {
+        const net = require("node:net");
+        const probe = net._normalizeArgs([]);
+        const normalizedArgsSymbol = Object.getOwnPropertySymbols(probe).find(
+          s => s.description === "normalizedArgs",
+        );
+        return { loader: "object", exports: { normalizedArgsSymbol } };
+      });
       // node's internal/options: map the few CLI options vendored http tests ask
       // about onto the equivalent runtime values. Unknown options return undefined.
       build.module("internal/options", () => ({
@@ -1425,10 +1502,20 @@ function installBunExposeInternalsShim() {
         exports: {
           getOptionValue(name) {
             switch (name) {
+              case "--expose-internals":
+                // This shim is only installed for tests whose Flags line
+                // carries --expose-internals, so the answer is always true.
+                return true;
               case "--max-http-header-size":
                 return require("node:http").maxHeaderSize;
               case "--insecure-http-parser":
                 return process.execArgv.includes("--insecure-http-parser");
+              case "--test-isolation": {
+                // Present in execArgv when a `// Flags:` respawn passed it
+                // through; node's default is "process".
+                const arg = process.execArgv.find(a => a.startsWith("--test-isolation="));
+                return arg ? arg.slice("--test-isolation=".length) : "process";
+              }
               default:
                 return undefined;
             }
diff --git a/test/js/node/test/common/index.mjs b/test/js/node/test/common/index.mjs
index 753b6078d7d8..9679b1fd2a7c 100644
--- a/test/js/node/test/common/index.mjs
+++ b/test/js/node/test/common/index.mjs
@@ -45,7 +45,7 @@ const {
   mustSucceed,
   nodeProcessAborted,
   opensslCli,
-  parseTestFlags,
+  parseTestMetadata,
   PIPE,
   platformTimeout,
   printSkipMessage,
@@ -106,7 +106,7 @@ export {
   mustSucceed,
   nodeProcessAborted,
   opensslCli,
-  parseTestFlags,
+  parseTestMetadata,
   PIPE,
   platformTimeout,
   printSkipMessage,
diff --git a/test/js/node/test/common/nodeinternals.js b/test/js/node/test/common/nodeinternals.js
new file mode 100644
index 000000000000..7228cd9ece06
--- /dev/null
+++ b/test/js/node/test/common/nodeinternals.js
@@ -0,0 +1,560 @@
+'use strict';
+// Serves require('internal/*') for byte-identical node v26.3.0 lib/internal
+// copies under ./nodeinternals/, evaluated with an emulated `primordials` and
+// a scoped require mapping their dependencies onto bun's real machinery.
+
+const fs = require('fs');
+const path = require('path');
+const util = require('util');
+
+const VENDORED = new Set([
+  'internal/webidl',
+  'internal/socket_list',
+  'internal/fs/utils',
+  'internal/crypto/util',
+  'internal/crypto/webidl',
+  'internal/crypto/hashnames',
+]);
+
+// ---------------- primordials emulator ----------------
+const globalsMap = {
+  Array, ArrayBuffer, BigInt, Boolean, DataView, Date, Error, EvalError,
+  FinalizationRegistry, Function, JSON, Map, Math, Number, Object, Promise,
+  Proxy, RangeError, ReferenceError, Reflect, RegExp, Set, String, Symbol,
+  SyntaxError, TypeError, URIError, WeakMap, WeakRef, WeakSet,
+  BigInt64Array, BigUint64Array, Float32Array, Float64Array, Int8Array,
+  Int16Array, Int32Array, Uint8Array, Uint16Array, Uint32Array,
+  Uint8ClampedArray,
+};
+if (typeof SharedArrayBuffer !== 'undefined') globalsMap.SharedArrayBuffer = SharedArrayBuffer;
+const TypedArray = Object.getPrototypeOf(Uint8Array);
+
+const uncurryThis = fn => (thisArg, ...args) => Reflect.apply(fn, thisArg, args);
+
+function lowerFirst(s) {
+  return s.charAt(0).toLowerCase() + s.slice(1);
+}
+
+function resolveOnCtor(ctor, rest, name) {
+  if (rest in ctor) {
+    const v = ctor[rest];
+    return typeof v === 'function' ? v.bind(ctor) : v;
+  }
+  const lowered = lowerFirst(rest);
+  if (lowered in ctor) {
+    const v = ctor[lowered];
+    return typeof v === 'function' ? v.bind(ctor) : v;
+  }
+  if (ctor === Symbol) {
+    const sym = Symbol[lowerFirst(rest)];
+    if (sym !== undefined) return sym;
+  }
+  throw new Error(`nodeinternals primordials: cannot resolve ${name}`);
+}
+
+function findDesc(proto, key) {
+  let p = proto;
+  while (p) {
+    const d = Object.getOwnPropertyDescriptor(p, key);
+    if (d) return d;
+    p = Object.getPrototypeOf(p);
+  }
+}
+
+function resolveOnProto(proto, rest, name) {
+  if (rest.startsWith('Get') && rest.length > 3) {
+    const propName = rest.slice(3);
+    const key = propName === 'SymbolToStringTag' ? Symbol.toStringTag : lowerFirst(propName);
+    const desc = findDesc(proto, key);
+    if (desc && desc.get) return uncurryThis(desc.get);
+  }
+  if (rest.startsWith('Symbol') && rest.length > 6) {
+    const sym = Symbol[lowerFirst(rest.slice(6))];
+    if (sym !== undefined && proto[sym]) return uncurryThis(proto[sym]);
+  }
+  const key = lowerFirst(rest);
+  const desc = findDesc(proto, key);
+  if (desc) {
+    if (desc.get && !desc.value) return uncurryThis(desc.get);
+    return uncurryThis(desc.value);
+  }
+  throw new Error(`nodeinternals primordials: cannot resolve ${name}`);
+}
+
+class SafeArrayIterator {
+  #arr;
+  constructor(arr) { this.#arr = arr; }
+  [Symbol.iterator]() { return this.#arr[Symbol.iterator](); }
+}
+
+function computePrimordial(name) {
+  if (name === 'uncurryThis') return uncurryThis;
+  if (name === 'makeSafe') return (_unsafe, safe) => safe;
+  if (name === 'globalThis') return globalThis;
+  if (name === 'SafeArrayIterator') return SafeArrayIterator;
+  if (name === 'SafeStringIterator') return SafeArrayIterator;
+  if (name === 'SafeMap') return Map;
+  if (name === 'SafeSet') return Set;
+  if (name === 'SafeWeakMap') return WeakMap;
+  if (name === 'SafeWeakSet') return WeakSet;
+  if (name === 'SafeWeakRef') return WeakRef;
+  if (name === 'SafeFinalizationRegistry') return FinalizationRegistry;
+  if (name === 'SafePromiseAll') return (arr, mapFn) => Promise.all(mapFn ? arr.map(mapFn) : arr);
+  if (name === 'SafePromiseAllReturnVoid') return (arr, mapFn) => Promise.all(mapFn ? arr.map(mapFn) : arr).then(() => {});
+  if (name === 'SafePromiseAllSettled') return (arr, mapFn) => Promise.allSettled(mapFn ? arr.map(mapFn) : arr);
+  if (name === 'SafePromisePrototypeFinally') return (p, fn) => p.finally(fn);
+  if (name === 'SafeRegExp') return RegExp;
+  if (name === 'PromiseResolve') return Promise.resolve.bind(Promise);
+  if (name === 'PromiseReject') return Promise.reject.bind(Promise);
+  if (name === 'PromiseWithResolvers') return Promise.withResolvers.bind(Promise);
+
+  if (name === 'TypedArray') return TypedArray;
+  if (name.startsWith('TypedArrayPrototype')) {
+    return resolveOnProto(TypedArray.prototype, name.slice('TypedArrayPrototype'.length), name);
+  }
+
+  for (const g of Object.keys(globalsMap)) {
+    if (name === g) return globalsMap[g];
+    if (name.startsWith(g + 'Prototype')) {
+      return resolveOnProto(globalsMap[g].prototype, name.slice(g.length + 'Prototype'.length), name);
+    }
+  }
+  let best = null;
+  for (const g of Object.keys(globalsMap)) {
+    if (name.startsWith(g) && name.length > g.length && (!best || g.length > best.length)) best = g;
+  }
+  if (best) return resolveOnCtor(globalsMap[best], name.slice(best.length), name);
+  throw new Error(`nodeinternals primordials: cannot resolve ${name}`);
+}
+
+const primCache = new Map();
+const primordials = new Proxy({}, {
+  get(_t, name) {
+    if (typeof name !== 'string') return undefined;
+    if (primCache.has(name)) return primCache.get(name);
+    const v = computePrimordial(name);
+    primCache.set(name, v);
+    return v;
+  },
+  has() { return true; },
+});
+
+// ---------------- node-message-compatible error classes ----------------
+// Formatters ported from node's lib/internal/errors.js so vendored internals
+// throw byte-identical messages.
+const classRegExp = /^[A-Z][a-zA-Z0-9]*$/;
+const kTypes = ['string', 'function', 'number', 'object', 'Function', 'Object', 'boolean', 'bigint', 'symbol'];
+
+function formatList(array, type = 'and') {
+  switch (array.length) {
+    case 0: return '';
+    case 1: return `${array[0]}`;
+    case 2: return `${array[0]} ${type} ${array[1]}`;
+    case 3: return `${array[0]}, ${array[1]}, ${type} ${array[2]}`;
+    default:
+      return `${array.slice(0, -1).join(', ')}, ${type} ${array[array.length - 1]}`;
+  }
+}
+
+function addNumericalSeparator(val) {
+  let res = '';
+  let i = val.length;
+  const start = val[0] === '-' ? 1 : 0;
+  for (; i >= start + 4; i -= 3) {
+    res = `_${val.slice(i - 3, i)}${res}`;
+  }
+  return `${val.slice(0, i)}${res}`;
+}
+
+function determineSpecificType(value) {
+  if (value === null) return 'null';
+  if (value === undefined) return 'undefined';
+  const type = typeof value;
+  switch (type) {
+    case 'bigint':
+      return `type bigint (${value}n)`;
+    case 'number':
+      if (value === 0) return 1 / value === -Infinity ? 'type number (-0)' : 'type number (0)';
+      if (value !== value) return 'type number (NaN)';
+      if (value === Infinity) return 'type number (Infinity)';
+      if (value === -Infinity) return 'type number (-Infinity)';
+      return `type number (${value})`;
+    case 'boolean':
+      return value ? 'type boolean (true)' : 'type boolean (false)';
+    case 'symbol':
+      return `type symbol (${String(value)})`;
+    case 'function':
+      return `function ${value.name}`;
+    case 'object':
+      if (value.constructor && 'name' in value.constructor) {
+        return `an instance of ${value.constructor.name}`;
+      }
+      return `${util.inspect(value, { depth: -1 })}`;
+    case 'string':
+      if (value.length > 28) value = `${value.slice(0, 25)}...`;
+      if (value.indexOf("'") === -1) return `type string ('${value}')`;
+      return `type string (${JSON.stringify(value)})`;
+    default: {
+      let inspected = util.inspect(value, { colors: false });
+      if (inspected.length > 28) inspected = `${inspected.slice(0, 25)}...`;
+      return `type ${type} (${inspected})`;
+    }
+  }
+}
+
+function invalidArgTypeMsg(name, expected, actual) {
+  if (!Array.isArray(expected)) expected = [expected];
+
+  let msg = 'The ';
+  if (name.endsWith(' argument')) {
+    msg += `${name} `;
+  } else {
+    const type = name.includes('.') ? 'property' : 'argument';
+    msg += `"${name}" ${type} `;
+  }
+  msg += 'must be ';
+
+  const types = [];
+  const instances = [];
+  const other = [];
+  for (const value of expected) {
+    if (kTypes.includes(value)) {
+      types.push(value.toLowerCase());
+    } else if (classRegExp.test(value)) {
+      instances.push(value);
+    } else {
+      other.push(value);
+    }
+  }
+  if (instances.length > 0) {
+    const pos = types.indexOf('object');
+    if (pos !== -1) {
+      types.splice(pos, 1);
+      instances.push('Object');
+    }
+  }
+  if (types.length > 0) {
+    msg += `${types.length > 1 ? 'one of type' : 'of type'} ${formatList(types, 'or')}`;
+    if (instances.length > 0 || other.length > 0) msg += ' or ';
+  }
+  if (instances.length > 0) {
+    msg += `an instance of ${formatList(instances, 'or')}`;
+    if (other.length > 0) msg += ' or ';
+  }
+  if (other.length > 0) {
+    if (other.length > 1) {
+      msg += `one of ${formatList(other, 'or')}`;
+    } else {
+      if (other[0].toLowerCase() !== other[0]) msg += 'an ';
+      msg += `${other[0]}`;
+    }
+  }
+  msg += `. Received ${determineSpecificType(actual)}`;
+  return msg;
+}
+
+function outOfRangeMsg(str, range, input, replaceDefaultBoolean = false) {
+  let msg = replaceDefaultBoolean ? str : `The value of "${str}" is out of range.`;
+  let received;
+  if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {
+    received = addNumericalSeparator(String(input));
+  } else if (typeof input === 'bigint') {
+    received = String(input);
+    if (input > 2n ** 32n || input < -(2n ** 32n)) {
+      received = addNumericalSeparator(received);
+    }
+    received += 'n';
+  } else {
+    received = util.inspect(input);
+  }
+  msg += ` It must be ${range}. Received ${received}`;
+  return msg;
+}
+
+// node's SystemError (context-object errors like ERR_FS_EISDIR).
+function makeSystemErrorClass(code, prefix) {
+  class NodeSystemError extends Error {
+    constructor(context) {
+      let message = `${prefix}: ${context.syscall} returned ${context.code} (${context.message})`;
+      if (context.path !== undefined) message += ` ${context.path}`;
+      if (context.dest !== undefined) message += ` => ${context.dest}`;
+      super(message);
+      this.code = code;
+      Object.defineProperties(this, {
+        name: { __proto__: null, value: 'SystemError', enumerable: false, writable: true, configurable: true },
+        info: { __proto__: null, value: context, enumerable: true, configurable: true, writable: false },
+        errno: {
+          __proto__: null,
+          get() { return context.errno; },
+          set: (value) => { context.errno = value; },
+          enumerable: true,
+          configurable: true,
+        },
+        syscall: {
+          __proto__: null,
+          get() { return context.syscall; },
+          set: (value) => { context.syscall = value; },
+          enumerable: true,
+          configurable: true,
+        },
+      });
+      if (context.path !== undefined) this.path = context.path;
+      if (context.dest !== undefined) this.dest = context.dest;
+    }
+    toString() {
+      return `${this.name} [${this.code}]: ${this.message}`;
+    }
+  }
+  Object.defineProperty(NodeSystemError, 'name', { value: code });
+  NodeSystemError.HideStackFramesError = NodeSystemError;
+  return NodeSystemError;
+}
+
+const errDefs = {
+  ERR_CHILD_CLOSED_BEFORE_REPLY: [Error, () => 'Child closed before reply received'],
+  ERR_INVALID_ARG_TYPE: [TypeError, invalidArgTypeMsg],
+  ERR_INVALID_ARG_VALUE: [TypeError, (name, value, reason = 'is invalid') => {
+    let inspected = util.inspect(value);
+    if (inspected.length > 128) inspected = `${inspected.slice(0, 128)}...`;
+    const type = name.includes('.') ? 'property' : 'argument';
+    return `The ${type} '${name}' ${reason}. Received ${inspected}`;
+  }],
+  ERR_OUT_OF_RANGE: [RangeError, outOfRangeMsg],
+  ERR_MISSING_ARGS: [TypeError, (...args) => {
+    const names = args.map((a) => (Array.isArray(a) ? a.map((x) => `"${x}"`).join(' or ') : `"${a}"`));
+    let msg = 'The ';
+    switch (names.length) {
+      case 1: msg += `${names[0]} argument`; break;
+      case 2: msg += `${names[0]} and ${names[1]} arguments`; break;
+      default: msg += `${names.slice(0, -1).join(', ')}, and ${names[names.length - 1]} arguments`;
+    }
+    return `${msg} must be specified`;
+  }],
+  ERR_MISSING_OPTION: [TypeError, (n) => `${n} is required`],
+  ERR_INVALID_THIS: [TypeError, (t) => `Value of "this" must be of type ${t}`],
+  ERR_INCOMPATIBLE_OPTION_PAIR: [TypeError, (a, b) => `Option "${a}" cannot be used in combination with option "${b}"`],
+  ERR_NO_TEMPORAL: [Error, () => 'Temporal unavailable'],
+  ERR_CRYPTO_CUSTOM_ENGINE_NOT_SUPPORTED: [Error, () => 'Custom engines not supported by this OpenSSL'],
+  ERR_CRYPTO_ENGINE_UNKNOWN: [Error, (e) => `Engine "${e}" was not found`],
+};
+
+const systemErrDefs = {
+  ERR_FS_EISDIR: 'Path is a directory',
+};
+
+const errClassCache = new Map();
+function getErrClass(code) {
+  if (errClassCache.has(code)) return errClassCache.get(code);
+  let cls;
+  if (Object.prototype.hasOwnProperty.call(systemErrDefs, code)) {
+    cls = makeSystemErrorClass(code, systemErrDefs[code]);
+  } else {
+    const [Base, fmt] = errDefs[code] || [Error, (...a) => a.join(' ')];
+    cls = class extends Base {
+      constructor(...args) {
+        super(typeof fmt === 'function' ? fmt(...args) : String(fmt));
+        this.code = code;
+      }
+      toString() {
+        return `${this.name} [${this.code}]: ${this.message}`;
+      }
+    };
+    Object.defineProperty(cls, 'name', { value: code });
+    cls.HideStackFramesError = cls;
+  }
+  errClassCache.set(code, cls);
+  return cls;
+}
+const codes = new Proxy({}, { get: (_t, code) => (typeof code === 'string' ? getErrClass(code) : undefined) });
+
+// node's UVException: composes `CODE: message, syscall 'path'` from a context
+// object; the uv code/message pair comes from the real system error map.
+class UVException extends Error {
+  constructor(ctx) {
+    const entry = util.getSystemErrorMap().get(ctx.errno);
+    const code = entry ? entry[0] : 'UNKNOWN';
+    const uvmsg = entry ? entry[1] : 'unknown error';
+    let message = `${code}: ${ctx.message || uvmsg}, ${ctx.syscall}`;
+    let path;
+    let dest;
+    if (ctx.path) {
+      path = ctx.path.toString();
+      message += ` '${path}'`;
+    }
+    if (ctx.dest) {
+      dest = ctx.dest.toString();
+      message += ` -> '${dest}'`;
+    }
+    super(message);
+    for (const prop of Object.keys(ctx)) {
+      if (prop === 'message' || prop === 'path' || prop === 'dest') continue;
+      this[prop] = ctx[prop];
+    }
+    this.code = code;
+    if (path) this.path = path;
+    if (dest) this.dest = dest;
+  }
+  get ['constructor']() {
+    return Error;
+  }
+}
+
+function hideStackFrames(fn) {
+  fn.withoutStackTrace = fn;
+  return fn;
+}
+
+// ---------------- scoped require + internalBinding ----------------
+let realInternalBinding;
+function internalBinding(name) {
+  if (name === 'crypto') {
+    // Only what internal/crypto/util's module-level destructure touches.
+    // BoringSSL has no OpenSSL security-level machinery: level 0 (= no
+    // seclevel-based restrictions) is the honest answer.
+    return new Proxy({
+      getOpenSSLSecLevelCrypto: () => 0,
+      getCachedAliases: () => ({ __proto__: null }),
+      getCiphers: () => require('crypto').getCiphers(),
+      getCurves: () => require('crypto').getCurves(),
+      getHashes: () => require('crypto').getHashes(),
+      timingSafeEqual: require('crypto').timingSafeEqual,
+      secureHeapUsed: () => ({}),
+    }, { get: (t, k) => (k in t ? t[k] : undefined), has: () => true });
+  }
+  realInternalBinding ??= require('internal/test/binding').internalBinding;
+  return realInternalBinding(name);
+}
+
+let overrides;
+function getOverrides() {
+  if (overrides) return overrides;
+  const X = require('bun:internal-for-testing').exposedInternals;
+  const iu = X['internal/util'];
+
+  function setOwnProperty(obj, key, value) {
+    return Object.defineProperty(obj, key, {
+      __proto__: null,
+      configurable: true,
+      enumerable: true,
+      value,
+      writable: true,
+    });
+  }
+
+  const iuExtended = {
+    ...iu,
+    setOwnProperty,
+    once(callback, { preserveReturnValue = false } = {}) {
+      let called = false;
+      let returnValue;
+      return function (...args) {
+        if (called) return returnValue;
+        called = true;
+        const result = Reflect.apply(callback, this, args);
+        returnValue = preserveReturnValue ? result : undefined;
+        return result;
+      };
+    },
+    isWindows: process.platform === 'win32',
+    deprecate: util.deprecate,
+    lazyDOMException: (message, name) => new DOMException(message, name),
+    cachedResult(fn) {
+      // node returns a fresh copy per call so callers cannot corrupt the cache.
+      let result;
+      return () => {
+        if (result === undefined) result = fn();
+        return result.slice();
+      };
+    },
+    filterDuplicateStrings(items = [], low) {
+      const map = new Map();
+      for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        const key = item.toLowerCase();
+        if (low) map.set(key, key);
+        else map.set(key, item);
+      }
+      return Array.from(map.values()).sort();
+    },
+    emitExperimentalWarning: () => {},
+    getConstructorOf(obj) {
+      while (obj) {
+        const descriptor = Object.getOwnPropertyDescriptor(obj, 'constructor');
+        if (descriptor !== undefined && typeof descriptor.value === 'function' && descriptor.value.name !== '') {
+          return descriptor.value;
+        }
+        obj = Object.getPrototypeOf(obj);
+      }
+      return null;
+    },
+  };
+
+  overrides = {
+    'internal/errors': {
+      ...(X['internal/errors'] || {}),
+      codes,
+      hideStackFrames,
+      isErrorStackTraceLimitWritable: () => true,
+      UVException,
+    },
+    'internal/util': iuExtended,
+    'internal/util/types': require('util/types'),
+    'internal/util/inspect': X['internal/util/inspect'],
+    'internal/validators': X['internal/validators'],
+    'internal/assert': Object.assign(
+      (v, msg) => { if (!v) throw new Error(msg || 'internal assertion failed'); },
+      { fail: (m) => { throw new Error(m); } },
+    ),
+    'internal/url': {
+      toPathIfFileURL: (p) => (p instanceof URL ? require('url').fileURLToPath(p) : p),
+    },
+    'internal/options': { getOptionValue: () => undefined },
+    'internal/v8/startup_snapshot': {
+      namespace: { isBuildingSnapshot: () => false, addSerializeCallback: () => {} },
+    },
+    'internal/crypto/webcrypto': { CryptoKey: globalThis.CryptoKey },
+    'internal/crypto/keys': {
+      getCryptoKeyAlgorithm: (k) => k.algorithm,
+      getCryptoKeyType: (k) => k.type,
+    },
+  };
+  return overrides;
+}
+
+// ---------------- module evaluation ----------------
+const cache = new Map();
+
+function scopedRequire(id) {
+  const ov = getOverrides();
+  if (Object.prototype.hasOwnProperty.call(ov, id)) return ov[id];
+  if (VENDORED.has(id)) return loadVendored(id);
+  if (id.startsWith('internal/')) {
+    throw new Error(`nodeinternals: vendored module requires unmapped '${id}'`);
+  }
+  return require(id);
+}
+
+function loadVendored(id) {
+  if (cache.has(id)) return cache.get(id).exports;
+  const file = path.join(__dirname, 'nodeinternals', id + '.js');
+  const src = fs.readFileSync(file, 'utf8');
+  const module = { exports: {} };
+  cache.set(id, module);
+  const fn = new Function('require', 'module', 'exports', 'primordials', 'internalBinding', 'process', src);
+  try {
+    fn(scopedRequire, module, module.exports, primordials, internalBinding, process);
+  } catch (e) {
+    cache.delete(id);
+    throw e;
+  }
+  return module.exports;
+}
+
+// Entry point for the interceptor: returns the module or undefined for
+// non-vendored ids.
+function requireVendoredNodeInternal(id) {
+  if (!VENDORED.has(id)) return undefined;
+  return loadVendored(id);
+}
+
+module.exports = { requireVendoredNodeInternal };
diff --git a/test/js/node/test/common/nodeinternals/internal/crypto/hashnames.js b/test/js/node/test/common/nodeinternals/internal/crypto/hashnames.js
new file mode 100644
index 000000000000..7a625c47e2f4
--- /dev/null
+++ b/test/js/node/test/common/nodeinternals/internal/crypto/hashnames.js
@@ -0,0 +1,99 @@
+'use strict';
+
+const {
+  ObjectKeys,
+} = primordials;
+
+const kHashContextNode = 1;
+const kHashContextWebCrypto = 2;
+const kHashContextJwkRsa = 3;
+const kHashContextJwkRsaPss = 4;
+const kHashContextJwkRsaOaep = 5;
+const kHashContextJwkHmac = 6;
+
+// WebCrypto and JWK use a bunch of different names for the
+// standard set of SHA-* digest algorithms... which is ... fun.
+// Here we provide a utility for mapping between them in order
+// make it easier in the code.
+
+const kHashNames = {
+  'sha1': {
+    [kHashContextNode]: 'sha1',
+    [kHashContextWebCrypto]: 'SHA-1',
+    [kHashContextJwkRsa]: 'RS1',
+    [kHashContextJwkRsaPss]: 'PS1',
+    [kHashContextJwkRsaOaep]: 'RSA-OAEP',
+    [kHashContextJwkHmac]: 'HS1',
+  },
+  'sha256': {
+    [kHashContextNode]: 'sha256',
+    [kHashContextWebCrypto]: 'SHA-256',
+    [kHashContextJwkRsa]: 'RS256',
+    [kHashContextJwkRsaPss]: 'PS256',
+    [kHashContextJwkRsaOaep]: 'RSA-OAEP-256',
+    [kHashContextJwkHmac]: 'HS256',
+  },
+  'sha384': {
+    [kHashContextNode]: 'sha384',
+    [kHashContextWebCrypto]: 'SHA-384',
+    [kHashContextJwkRsa]: 'RS384',
+    [kHashContextJwkRsaPss]: 'PS384',
+    [kHashContextJwkRsaOaep]: 'RSA-OAEP-384',
+    [kHashContextJwkHmac]: 'HS384',
+  },
+  'sha512': {
+    [kHashContextNode]: 'sha512',
+    [kHashContextWebCrypto]: 'SHA-512',
+    [kHashContextJwkRsa]: 'RS512',
+    [kHashContextJwkRsaPss]: 'PS512',
+    [kHashContextJwkRsaOaep]: 'RSA-OAEP-512',
+    [kHashContextJwkHmac]: 'HS512',
+  },
+  'shake128': {
+    [kHashContextNode]: 'shake128',
+    [kHashContextWebCrypto]: 'cSHAKE128',
+  },
+  'shake256': {
+    [kHashContextNode]: 'shake256',
+    [kHashContextWebCrypto]: 'cSHAKE256',
+  },
+  'sha3-256': {
+    [kHashContextNode]: 'sha3-256',
+    [kHashContextWebCrypto]: 'SHA3-256',
+  },
+  'sha3-384': {
+    [kHashContextNode]: 'sha3-384',
+    [kHashContextWebCrypto]: 'SHA3-384',
+  },
+  'sha3-512': {
+    [kHashContextNode]: 'sha3-512',
+    [kHashContextWebCrypto]: 'SHA3-512',
+  },
+};
+
+{
+  // Index the aliases
+  const keys = ObjectKeys(kHashNames);
+  for (let n = 0; n < keys.length; n++) {
+    const contexts = ObjectKeys(kHashNames[keys[n]]);
+    for (let i = 0; i < contexts.length; i++) {
+      const alias = kHashNames[keys[n]][contexts[i]];
+      if (kHashNames[alias] === undefined)
+        kHashNames[alias] = kHashNames[keys[n]];
+    }
+  }
+}
+
+function normalizeHashName(name, context = kHashContextNode) {
+  return kHashNames[name]?.[context];
+}
+
+
+normalizeHashName.kContextNode = kHashContextNode;
+normalizeHashName.kContextWebCrypto = kHashContextWebCrypto;
+normalizeHashName.kContextJwkRsa = kHashContextJwkRsa;
+normalizeHashName.kContextJwkRsaPss = kHashContextJwkRsaPss;
+normalizeHashName.kContextJwkRsaOaep = kHashContextJwkRsaOaep;
+normalizeHashName.kContextJwkHmac = kHashContextJwkHmac;
+
+module.exports = normalizeHashName;
diff --git a/test/js/node/test/common/nodeinternals/internal/crypto/util.js b/test/js/node/test/common/nodeinternals/internal/crypto/util.js
new file mode 100644
index 000000000000..7fcc09d9442f
--- /dev/null
+++ b/test/js/node/test/common/nodeinternals/internal/crypto/util.js
@@ -0,0 +1,983 @@
+'use strict';
+
+const {
+  ArrayBufferIsView,
+  ArrayBufferPrototypeGetByteLength,
+  ArrayPrototypeIncludes,
+  ArrayPrototypePush,
+  BigInt,
+  DataViewPrototypeGetBuffer,
+  DataViewPrototypeGetByteLength,
+  DataViewPrototypeGetByteOffset,
+  Number,
+  ObjectDefineProperty,
+  ObjectEntries,
+  ObjectKeys,
+  ObjectPrototypeHasOwnProperty,
+  PromisePrototypeThen,
+  PromiseReject,
+  PromiseWithResolvers,
+  SafeMap,
+  SafeSet,
+  StringPrototypeToUpperCase,
+  Symbol,
+  TypedArrayPrototypeGetBuffer,
+  TypedArrayPrototypeGetByteLength,
+  TypedArrayPrototypeGetByteOffset,
+  TypedArrayPrototypeSlice,
+  Uint8Array,
+} = primordials;
+
+const {
+  getCiphers: _getCiphers,
+  getCurves: _getCurves,
+  getHashes: _getHashes,
+  setEngine: _setEngine,
+  secureHeapUsed: _secureHeapUsed,
+  getCachedAliases,
+  getOpenSSLSecLevelCrypto: getOpenSSLSecLevel,
+  EVP_PKEY_ML_DSA_44,
+  EVP_PKEY_ML_DSA_65,
+  EVP_PKEY_ML_DSA_87,
+  EVP_PKEY_ML_KEM_512,
+  EVP_PKEY_ML_KEM_768,
+  EVP_PKEY_ML_KEM_1024,
+  kKeyVariantAES_OCB_128: hasAesOcbMode,
+  Argon2Job,
+  KmacJob,
+} = internalBinding('crypto');
+
+const { getOptionValue } = require('internal/options');
+
+const {
+  crypto: {
+    ENGINE_METHOD_ALL,
+  },
+} = internalBinding('constants');
+
+const normalizeHashName = require('internal/crypto/hashnames');
+
+const {
+  codes: {
+    ERR_CRYPTO_CUSTOM_ENGINE_NOT_SUPPORTED,
+    ERR_CRYPTO_ENGINE_UNKNOWN,
+    ERR_INVALID_ARG_TYPE,
+  },
+  hideStackFrames,
+} = require('internal/errors');
+
+const {
+  validateArray,
+  validateNumber,
+  validateString,
+} = require('internal/validators');
+
+const { Buffer } = require('buffer');
+
+const {
+  cachedResult,
+  emitExperimentalWarning,
+  filterDuplicateStrings,
+  lazyDOMException,
+  setOwnProperty,
+} = require('internal/util');
+
+const {
+  namespace: {
+    isBuildingSnapshot,
+    addSerializeCallback,
+  },
+} = require('internal/v8/startup_snapshot');
+
+const {
+  isDataView,
+  isArrayBufferView,
+  isAnyArrayBuffer,
+  isPromise,
+} = require('internal/util/types');
+
+const kHandle = Symbol('kHandle');
+
+// This is here because many functions accepted binary strings without
+// any explicit encoding in older versions of node, and we don't want
+// to break them unnecessarily.
+function toBuf(val, encoding) {
+  if (typeof val === 'string') {
+    if (encoding === 'buffer')
+      encoding = 'utf8';
+    return Buffer.from(val, encoding);
+  }
+  return val;
+}
+
+let _hashCache;
+function getHashCache() {
+  if (_hashCache === undefined) {
+    _hashCache = getCachedAliases();
+    if (isBuildingSnapshot()) {
+      // For dynamic linking, clear the map.
+      addSerializeCallback(() => { _hashCache = undefined; });
+    }
+  }
+  return _hashCache;
+}
+
+function getCachedHashId(algorithm) {
+  const result = getHashCache()[algorithm];
+  return result === undefined ? -1 : result;
+}
+
+const getCiphers = cachedResult(() => filterDuplicateStrings(_getCiphers()));
+const getHashes = cachedResult(() => filterDuplicateStrings(_getHashes()));
+const getCurves = cachedResult(() => filterDuplicateStrings(_getCurves()));
+
+function setEngine(id, flags) {
+  validateString(id, 'id');
+  if (flags)
+    validateNumber(flags, 'flags');
+  flags = flags >>> 0;
+
+  // Use provided engine for everything by default
+  if (flags === 0)
+    flags = ENGINE_METHOD_ALL;
+
+  if (typeof _setEngine !== 'function')
+    throw new ERR_CRYPTO_CUSTOM_ENGINE_NOT_SUPPORTED();
+  if (!_setEngine(id, flags))
+    throw new ERR_CRYPTO_ENGINE_UNKNOWN(id);
+}
+
+const getArrayBufferOrView = hideStackFrames((buffer, name, encoding) => {
+  if (isAnyArrayBuffer(buffer))
+    return buffer;
+  if (typeof buffer === 'string') {
+    if (encoding === 'buffer')
+      encoding = 'utf8';
+    return Buffer.from(buffer, encoding);
+  }
+  if (!isArrayBufferView(buffer)) {
+    throw new ERR_INVALID_ARG_TYPE.HideStackFramesError(
+      name,
+      [
+        'string',
+        'ArrayBuffer',
+        'Buffer',
+        'TypedArray',
+        'DataView',
+      ],
+      buffer,
+    );
+  }
+  return buffer;
+});
+
+// The maximum buffer size that we'll support in the WebCrypto impl
+const kMaxBufferLength = (2 ** 31) - 1;
+
+// The EC named curves that we currently support via the Web Crypto API.
+const kNamedCurveAliases = {
+  'P-256': 'prime256v1',
+  'P-384': 'secp384r1',
+  'P-521': 'secp521r1',
+};
+
+// Algorithm definitions organized by algorithm name
+const kAlgorithmDefinitions = {
+  'AES-CBC': {
+    'generateKey': 'AesKeyGenParams',
+    'exportKey': null,
+    'importKey': null,
+    'encrypt': 'AesCbcParams',
+    'decrypt': 'AesCbcParams',
+    'get key length': 'AesDerivedKeyParams',
+  },
+  'AES-CTR': {
+    'generateKey': 'AesKeyGenParams',
+    'exportKey': null,
+    'importKey': null,
+    'encrypt': 'AesCtrParams',
+    'decrypt': 'AesCtrParams',
+    'get key length': 'AesDerivedKeyParams',
+  },
+  'AES-GCM': {
+    'generateKey': 'AesKeyGenParams',
+    'exportKey': null,
+    'importKey': null,
+    'encrypt': 'AeadParams',
+    'decrypt': 'AeadParams',
+    'get key length': 'AesDerivedKeyParams',
+  },
+  'AES-KW': {
+    'generateKey': 'AesKeyGenParams',
+    'exportKey': null,
+    'importKey': null,
+    'get key length': 'AesDerivedKeyParams',
+    'wrapKey': null,
+    'unwrapKey': null,
+  },
+  'AES-OCB': {
+    'generateKey': 'AesKeyGenParams',
+    'exportKey': null,
+    'importKey': null,
+    'encrypt': 'AeadParams',
+    'decrypt': 'AeadParams',
+    'get key length': 'AesDerivedKeyParams',
+  },
+  'Argon2d': {
+    'deriveBits': 'Argon2Params',
+    'get key length': null,
+    'importKey': null,
+  },
+  'Argon2i': {
+    'deriveBits': 'Argon2Params',
+    'get key length': null,
+    'importKey': null,
+  },
+  'Argon2id': {
+    'deriveBits': 'Argon2Params',
+    'get key length': null,
+    'importKey': null,
+  },
+  'ChaCha20-Poly1305': {
+    'generateKey': null,
+    'exportKey': null,
+    'importKey': null,
+    'encrypt': 'AeadParams',
+    'decrypt': 'AeadParams',
+    'get key length': null,
+  },
+  'cSHAKE128': { 'digest': 'CShakeParams' },
+  'cSHAKE256': { 'digest': 'CShakeParams' },
+  'KT128': { 'digest': 'KangarooTwelveParams' },
+  'KT256': { 'digest': 'KangarooTwelveParams' },
+  'TurboSHAKE128': { 'digest': 'TurboShakeParams' },
+  'TurboSHAKE256': { 'digest': 'TurboShakeParams' },
+  'ECDH': {
+    'generateKey': 'EcKeyGenParams',
+    'exportKey': null,
+    'importKey': 'EcKeyImportParams',
+    'deriveBits': 'EcdhKeyDeriveParams',
+  },
+  'ECDSA': {
+    'generateKey': 'EcKeyGenParams',
+    'exportKey': null,
+    'importKey': 'EcKeyImportParams',
+    'sign': 'EcdsaParams',
+    'verify': 'EcdsaParams',
+  },
+  'Ed25519': {
+    'generateKey': null,
+    'exportKey': null,
+    'importKey': null,
+    'sign': null,
+    'verify': null,
+  },
+  'Ed448': {
+    'generateKey': null,
+    'exportKey': null,
+    'importKey': null,
+    'sign': 'ContextParams',
+    'verify': 'ContextParams',
+  },
+  'HKDF': {
+    'importKey': null,
+    'deriveBits': 'HkdfParams',
+    'get key length': null,
+  },
+  'HMAC': {
+    'generateKey': 'HmacKeyGenParams',
+    'exportKey': null,
+    'importKey': 'HmacImportParams',
+    'sign': null,
+    'verify': null,
+    'get key length': 'HmacImportParams',
+  },
+  'KMAC128': {
+    'generateKey': 'KmacKeyGenParams',
+    'exportKey': null,
+    'importKey': 'KmacImportParams',
+    'sign': 'KmacParams',
+    'verify': 'KmacParams',
+    'get key length': 'KmacImportParams',
+  },
+  'KMAC256': {
+    'generateKey': 'KmacKeyGenParams',
+    'exportKey': null,
+    'importKey': 'KmacImportParams',
+    'sign': 'KmacParams',
+    'verify': 'KmacParams',
+    'get key length': 'KmacImportParams',
+  },
+  'ML-DSA-44': {
+    'generateKey': null,
+    'exportKey': null,
+    'importKey': null,
+    'sign': 'ContextParams',
+    'verify': 'ContextParams',
+  },
+  'ML-DSA-65': {
+    'generateKey': null,
+    'exportKey': null,
+    'importKey': null,
+    'sign': 'ContextParams',
+    'verify': 'ContextParams',
+  },
+  'ML-DSA-87': {
+    'generateKey': null,
+    'exportKey': null,
+    'importKey': null,
+    'sign': 'ContextParams',
+    'verify': 'ContextParams',
+  },
+  'ML-KEM-512': {
+    'generateKey': null,
+    'exportKey': null,
+    'importKey': null,
+    'encapsulate': null,
+    'decapsulate': null,
+  },
+  'ML-KEM-768': {
+    'generateKey': null,
+    'exportKey': null,
+    'importKey': null,
+    'encapsulate': null,
+    'decapsulate': null,
+  },
+  'ML-KEM-1024': {
+    'generateKey': null,
+    'exportKey': null,
+    'importKey': null,
+    'encapsulate': null,
+    'decapsulate': null,
+  },
+  'PBKDF2': {
+    'importKey': null,
+    'deriveBits': 'Pbkdf2Params',
+    'get key length': null,
+  },
+  'RSA-OAEP': {
+    'generateKey': 'RsaHashedKeyGenParams',
+    'exportKey': null,
+    'importKey': 'RsaHashedImportParams',
+    'encrypt': 'RsaOaepParams',
+    'decrypt': 'RsaOaepParams',
+  },
+  'RSA-PSS': {
+    'generateKey': 'RsaHashedKeyGenParams',
+    'exportKey': null,
+    'importKey': 'RsaHashedImportParams',
+    'sign': 'RsaPssParams',
+    'verify': 'RsaPssParams',
+  },
+  'RSASSA-PKCS1-v1_5': {
+    'generateKey': 'RsaHashedKeyGenParams',
+    'exportKey': null,
+    'importKey': 'RsaHashedImportParams',
+    'sign': null,
+    'verify': null,
+  },
+  'SHA-1': { 'digest': null },
+  'SHA-256': { 'digest': null },
+  'SHA-384': { 'digest': null },
+  'SHA-512': { 'digest': null },
+  'SHA3-256': { 'digest': null },
+  'SHA3-384': { 'digest': null },
+  'SHA3-512': { 'digest': null },
+  'X25519': {
+    'generateKey': null,
+    'exportKey': null,
+    'importKey': null,
+    'deriveBits': 'EcdhKeyDeriveParams',
+  },
+  'X448': {
+    'generateKey': null,
+    'exportKey': null,
+    'importKey': null,
+    'deriveBits': 'EcdhKeyDeriveParams',
+  },
+};
+
+// Conditionally supported algorithms
+const conditionalAlgorithms = {
+  'AES-OCB': !!hasAesOcbMode,
+  'Argon2d': !!Argon2Job,
+  'Argon2i': !!Argon2Job,
+  'Argon2id': !!Argon2Job,
+  'ChaCha20-Poly1305': process.features.openssl_is_boringssl ||
+    ArrayPrototypeIncludes(getCiphers(), 'chacha20-poly1305'),
+  'cSHAKE128': !process.features.openssl_is_boringssl ||
+    ArrayPrototypeIncludes(getHashes(), 'shake128'),
+  'cSHAKE256': !process.features.openssl_is_boringssl ||
+    ArrayPrototypeIncludes(getHashes(), 'shake256'),
+  'Ed448': !process.features.openssl_is_boringssl,
+  'KMAC128': !!KmacJob,
+  'KMAC256': !!KmacJob,
+  'ML-DSA-44': !!EVP_PKEY_ML_DSA_44,
+  'ML-DSA-65': !!EVP_PKEY_ML_DSA_65,
+  'ML-DSA-87': !!EVP_PKEY_ML_DSA_87,
+  'ML-KEM-512': !!EVP_PKEY_ML_KEM_512,
+  'ML-KEM-768': !!EVP_PKEY_ML_KEM_768,
+  'ML-KEM-1024': !!EVP_PKEY_ML_KEM_1024,
+  'SHA3-256': !process.features.openssl_is_boringssl ||
+    ArrayPrototypeIncludes(getHashes(), 'sha3-256'),
+  'SHA3-384': !process.features.openssl_is_boringssl ||
+    ArrayPrototypeIncludes(getHashes(), 'sha3-384'),
+  'SHA3-512': !process.features.openssl_is_boringssl ||
+    ArrayPrototypeIncludes(getHashes(), 'sha3-512'),
+  'X448': !process.features.openssl_is_boringssl,
+};
+
+// Experimental algorithms
+const experimentalAlgorithms = [
+  'AES-OCB',
+  'Argon2d',
+  'Argon2i',
+  'Argon2id',
+  'ChaCha20-Poly1305',
+  'cSHAKE128',
+  'cSHAKE256',
+  'Ed448',
+  'KMAC128',
+  'KMAC256',
+  'ML-DSA-44',
+  'ML-DSA-65',
+  'ML-DSA-87',
+  'ML-KEM-512',
+  'ML-KEM-768',
+  'ML-KEM-1024',
+  'SHA3-256',
+  'SHA3-384',
+  'SHA3-512',
+  'TurboSHAKE128',
+  'TurboSHAKE256',
+  'KT128',
+  'KT256',
+  'X448',
+];
+
+// Transform the algorithm definitions into the operation-keyed structure
+// Also builds a parallel Map<UPPERCASED_NAME, canonicalName> per operation
+// for O(1) case-insensitive algorithm name lookup in normalizeAlgorithm.
+function createSupportedAlgorithms(algorithmDefs) {
+  const result = {};
+  const nameMap = {};
+
+  for (const { 0: algorithmName, 1: operations } of ObjectEntries(algorithmDefs)) {
+    // Skip algorithms that are conditionally not supported
+    if (ObjectPrototypeHasOwnProperty(conditionalAlgorithms, algorithmName) &&
+        !conditionalAlgorithms[algorithmName]) {
+      continue;
+    }
+
+    for (const { 0: operation, 1: dict } of ObjectEntries(operations)) {
+      result[operation] ||= {};
+      nameMap[operation] ||= new SafeMap();
+      nameMap[operation].set(StringPrototypeToUpperCase(algorithmName), algorithmName);
+
+      // Add experimental warnings for experimental algorithms
+      if (ArrayPrototypeIncludes(experimentalAlgorithms, algorithmName)) {
+        ObjectDefineProperty(result[operation], algorithmName, {
+          get() {
+            emitExperimentalWarning(`The ${algorithmName} Web Crypto API algorithm`);
+            return dict;
+          },
+          __proto__: null,
+          enumerable: true,
+        });
+      } else {
+        result[operation][algorithmName] = dict;
+      }
+    }
+  }
+
+  return { algorithms: result, nameMap };
+}
+
+const { algorithms: kSupportedAlgorithms, nameMap: kAlgorithmNameMap } =
+  createSupportedAlgorithms(kAlgorithmDefinitions);
+
+const simpleAlgorithmDictionaries = {
+  AesCbcParams: { iv: 'BufferSource' },
+  AesCtrParams: { counter: 'BufferSource' },
+  AeadParams: { iv: 'BufferSource', additionalData: 'BufferSource' },
+  // publicExponent is not strictly a BufferSource but it is a Uint8Array that we normalize
+  // this way
+  RsaHashedKeyGenParams: { hash: 'HashAlgorithmIdentifier', publicExponent: 'BufferSource' },
+  EcKeyGenParams: {},
+  HmacKeyGenParams: { hash: 'HashAlgorithmIdentifier' },
+  RsaPssParams: {},
+  EcdsaParams: { hash: 'HashAlgorithmIdentifier' },
+  HmacImportParams: { hash: 'HashAlgorithmIdentifier' },
+  HkdfParams: {
+    hash: 'HashAlgorithmIdentifier',
+    salt: 'BufferSource',
+    info: 'BufferSource',
+  },
+  ContextParams: { context: 'BufferSource' },
+  Pbkdf2Params: { hash: 'HashAlgorithmIdentifier', salt: 'BufferSource' },
+  RsaOaepParams: { label: 'BufferSource' },
+  RsaHashedImportParams: { hash: 'HashAlgorithmIdentifier' },
+  EcKeyImportParams: {},
+  CShakeParams: {
+    functionName: 'BufferSource',
+    customization: 'BufferSource',
+  },
+  Argon2Params: {
+    associatedData: 'BufferSource',
+    nonce: 'BufferSource',
+    secretValue: 'BufferSource',
+  },
+  KmacParams: {
+    customization: 'BufferSource',
+  },
+  KangarooTwelveParams: {
+    customization: 'BufferSource',
+  },
+  TurboShakeParams: {},
+};
+
+// Pre-compute ObjectKeys() for each dictionary entry at module init
+// to avoid allocating a new keys array on every normalizeAlgorithm call.
+for (const { 0: name, 1: types } of ObjectEntries(simpleAlgorithmDictionaries)) {
+  simpleAlgorithmDictionaries[name] = { keys: ObjectKeys(types), types };
+}
+
+function validateMaxBufferLength(data, name, max = kMaxBufferLength) {
+  if (data.byteLength > max) {
+    throw lazyDOMException(
+      `${name} must be at most ${max} bytes`,
+      'OperationError');
+  }
+}
+
+let webidl;
+
+// Keep this as a regular object. The WebIDL converters read and spread these
+// options on the normalizeAlgorithm hot path, and a null-prototype object
+// measurably regresses benchmark/misc/webcrypto-webidl normalizeAlgorithm-*.
+const kNormalizeAlgorithmOpts = {
+  prefix: 'Failed to normalize algorithm',
+  context: 'passed algorithm',
+};
+
+// https://w3c.github.io/webcrypto/#algorithm-normalization-normalize-an-algorithm
+// adapted for Node.js from Deno's implementation
+// https://github.com/denoland/deno/blob/v1.29.1/ext/crypto/00_crypto.js#L195
+function normalizeAlgorithm(algorithm, op) {
+  if (typeof algorithm === 'string')
+    return normalizeAlgorithm({ name: algorithm }, op);
+
+  webidl ??= require('internal/crypto/webidl');
+
+  // 1.
+  const registeredAlgorithms = kSupportedAlgorithms[op];
+  // 2. 3.
+  const initialAlg = webidl.converters.Algorithm(algorithm,
+                                                 kNormalizeAlgorithmOpts);
+  // 4.
+  let algName = initialAlg.name;
+
+  // 5. Case-insensitive lookup via pre-built Map (O(1) instead of O(n)).
+  const canonicalName = kAlgorithmNameMap[op]?.get(
+    StringPrototypeToUpperCase(algName));
+  if (canonicalName === undefined)
+    throw lazyDOMException('Unrecognized algorithm name', 'NotSupportedError');
+
+  algName = canonicalName;
+  const desiredType = registeredAlgorithms[algName];
+
+  // Fast path everything below if the registered dictionary is null
+  if (desiredType === null)
+    return { name: algName };
+
+  // 6.
+  const normalizedAlgorithm = webidl.converters[desiredType](
+    { __proto__: algorithm, name: algName },
+    kNormalizeAlgorithmOpts,
+  );
+  // 7.
+  normalizedAlgorithm.name = algName;
+
+  // 9. 10. Pre-computed keys and types from simpleAlgorithmDictionaries.
+  const dictMeta = simpleAlgorithmDictionaries[desiredType];
+  if (dictMeta) {
+    const { keys: dictKeys, types: dictTypes } = dictMeta;
+    for (let i = 0; i < dictKeys.length; i++) {
+      const member = dictKeys[i];
+      const idlType = dictTypes[member];
+      const idlValue = normalizedAlgorithm[member];
+      // 3.
+      if (idlType === 'BufferSource' && idlValue) {
+        const isView = ArrayBufferIsView(idlValue);
+        normalizedAlgorithm[member] = TypedArrayPrototypeSlice(
+          new Uint8Array(
+            isView ? getDataViewOrTypedArrayBuffer(idlValue) : idlValue,
+            isView ? getDataViewOrTypedArrayByteOffset(idlValue) : 0,
+            isView ? getDataViewOrTypedArrayByteLength(idlValue) : ArrayBufferPrototypeGetByteLength(idlValue),
+          ),
+        );
+      } else if (idlType === 'HashAlgorithmIdentifier') {
+        normalizedAlgorithm[member] = normalizeAlgorithm(idlValue, 'digest');
+      } else if (idlType === 'AlgorithmIdentifier') {
+        // This extension point is not used by any supported algorithm (yet?)
+        throw lazyDOMException('Not implemented.', 'NotSupportedError');
+      }
+    }
+  }
+
+  return normalizedAlgorithm;
+}
+
+function getDataViewOrTypedArrayBuffer(V) {
+  return isDataView(V) ?
+    DataViewPrototypeGetBuffer(V) : TypedArrayPrototypeGetBuffer(V);
+}
+
+function getDataViewOrTypedArrayByteOffset(V) {
+  return isDataView(V) ?
+    DataViewPrototypeGetByteOffset(V) : TypedArrayPrototypeGetByteOffset(V);
+}
+
+function getDataViewOrTypedArrayByteLength(V) {
+  return isDataView(V) ?
+    DataViewPrototypeGetByteLength(V) : TypedArrayPrototypeGetByteLength(V);
+}
+
+function hasAnyNotIn(set, checks) {
+  for (const s of set)
+    if (!ArrayPrototypeIncludes(checks, s))
+      return true;
+  return false;
+}
+
+const validateByteSource = hideStackFrames((val, name) => {
+  val = toBuf(val);
+
+  if (isAnyArrayBuffer(val) || isArrayBufferView(val))
+    return val;
+
+  throw new ERR_INVALID_ARG_TYPE.HideStackFramesError(
+    name,
+    [
+      'string',
+      'ArrayBuffer',
+      'TypedArray',
+      'DataView',
+      'Buffer',
+    ],
+    val);
+});
+
+// CryptoJob constructors can synchronously throw while running their native
+// AdditionalConfig hook. WebCrypto needs those operation-specific setup
+// failures to reject with an OperationError.
+function jobPromise(getJob) {
+  try {
+    return getJob().run();
+  } catch (err) {
+    return PromiseReject(lazyDOMException(
+      'The operation failed for an operation-specific reason',
+      { name: 'OperationError', cause: err }));
+  }
+}
+
+// Temporarily shadow inherited then accessors on WebCrypto result objects.
+// Promise resolution reads "then" synchronously for thenable assimilation.
+// Returning an own undefined data property keeps that lookup from reaching
+// user-mutated prototypes.
+function prepareWebCryptoResult(value) {
+  if ((value === null || typeof value !== 'object') &&
+      typeof value !== 'function') {
+    return false;
+  }
+  if (isPromise(value) || ObjectPrototypeHasOwnProperty(value, 'then'))
+    return false;
+  setOwnProperty(value, 'then', undefined);
+  return true;
+}
+
+// Remove the temporary then property installed by prepareWebCryptoResult().
+function cleanupWebCryptoResult(value) {
+  delete value.then;
+}
+
+// Resolve a WebCrypto promise while inherited then accessors are shadowed.
+function resolveWebCryptoResult(resolve, value) {
+  const shouldCleanupResult = prepareWebCryptoResult(value);
+  try {
+    resolve(value);
+  } finally {
+    if (shouldCleanupResult)
+      cleanupWebCryptoResult(value);
+  }
+}
+
+// Run a WebCrypto promise reaction and settle the outer promise.
+function settleJobPromise(handler, resolve, reject, value, isRejected) {
+  try {
+    if (typeof handler === 'function') {
+      resolveWebCryptoResult(resolve, handler(value));
+    } else if (isRejected) {
+      reject(value);
+    } else {
+      resolveWebCryptoResult(resolve, value);
+    }
+  } catch (err) {
+    reject(err);
+  }
+}
+
+// Promise.prototype.then gets promise.constructor to determine the result
+// promise's species. These promises are internal WebCrypto intermediates, so
+// make that lookup stay on the promise itself instead of user-mutated state.
+function jobPromiseThen(promise, onFulfilled, onRejected) {
+  const {
+    promise: resultPromise,
+    resolve,
+    reject,
+  } = PromiseWithResolvers();
+  setOwnProperty(promise, 'constructor', undefined);
+  PromisePrototypeThen(
+    promise,
+    (value) => settleJobPromise(onFulfilled, resolve, reject, value, false),
+    (value) => settleJobPromise(onRejected, resolve, reject, value, true));
+  return resultPromise;
+}
+
+// In WebCrypto, the publicExponent option in RSA is represented as a
+// WebIDL "BigInteger"... that is, a Uint8Array that allows an arbitrary
+// number of leading zero bits. Our conventional APIs for reading
+// an unsigned int from a Buffer are not adequate. The implementation
+// here is adapted from the chromium implementation here:
+// https://github.com/chromium/chromium/blob/HEAD/third_party/blink/public/platform/web_crypto_algorithm_params.h, but ported to JavaScript
+// Returns undefined if the conversion was unsuccessful.
+function bigIntArrayToUnsignedInt(input) {
+  let result = 0;
+
+  for (let n = 0; n < input.length; ++n) {
+    const n_reversed = input.length - n - 1;
+    if (n_reversed >= 4 && input[n])
+      return;  // Too large
+    result |= input[n] << 8 * n_reversed;
+  }
+
+  return result >>> 0;
+}
+
+function bigIntArrayToUnsignedBigInt(input) {
+  let result = 0n;
+
+  for (let n = 0; n < input.length; ++n) {
+    const n_reversed = input.length - n - 1;
+    result |= BigInt(input[n]) << 8n * BigInt(n_reversed);
+  }
+
+  return result;
+}
+
+function getStringOption(options, key) {
+  let value;
+  if (options && (value = options[key]) != null)
+    validateString(value, `options.${key}`);
+  return value;
+}
+
+/**
+ * Returns the requested usages that are present in `usageSet`.
+ * @param {SafeSet<string>} usageSet
+ * @param {...string} usages
+ * @returns {SafeSet<string>}
+ */
+function getUsagesUnion(usageSet, ...usages) {
+  const newset = new SafeSet();
+  for (let n = 0; n < usages.length; n++) {
+    if (usageSet.has(usages[n]))
+      newset.add(usages[n]);
+  }
+  return newset;
+}
+
+// Must be at most 31 entries.
+const kCanonicalUsageOrder = [
+  'encrypt', 'decrypt',
+  'sign', 'verify',
+  'deriveKey', 'deriveBits',
+  'wrapKey', 'unwrapKey',
+  'encapsulateKey', 'encapsulateBits',
+  'decapsulateKey', 'decapsulateBits',
+];
+
+const kUsageMasks = {
+  __proto__: null,
+};
+const kUsageByMask = {
+  __proto__: null,
+};
+// Derive both lookup tables from kCanonicalUsageOrder so adding a new
+// usage only requires updating the canonical list above. The numeric
+// mask uses the usage's canonical index as its bit position.
+for (let n = 0; n < kCanonicalUsageOrder.length; n++) {
+  const usage = kCanonicalUsageOrder[n];
+  const mask = 1 << n;
+  kUsageMasks[usage] = mask;
+  kUsageByMask[mask] = usage;
+}
+
+/**
+ * Returns a bit mask representing the usages from `usageSet`.
+ * @param {SafeSet<string>} usageSet
+ * @returns {number}
+ */
+function getUsagesMask(usageSet) {
+  // No usages is a valid state for some public keys, represented by a
+  // zero mask.
+  if (usageSet.size === 0) return 0;
+  let mask = 0;
+  for (const usage of usageSet) {
+    mask |= kUsageMasks[usage];
+  }
+  return mask;
+}
+
+/**
+ * Returns whether `mask` contains `usage`.
+ * @param {number} mask
+ * @param {string} usage
+ * @returns {boolean}
+ */
+function hasUsage(mask, usage) {
+  return (mask & kUsageMasks[usage]) !== 0;
+}
+
+/**
+ * Returns the usages represented by `mask` in canonical order.
+ * @param {number} mask
+ * @returns {string[]}
+ */
+function getUsagesFromMask(mask) {
+  // Short circuit most common cases, empty and single usage
+  // No usages is a valid state for some public keys
+  if (mask === 0) return [];
+  // A mask with exactly one bit set maps directly to one usage
+  if ((mask & (mask - 1)) === 0) {
+    return [kUsageByMask[mask]];
+  }
+  // Multiple usages need to be expanded in canonical order.
+  const result = [];
+  for (let n = 0; n < kCanonicalUsageOrder.length; n++) {
+    if (mask & (1 << n))
+      ArrayPrototypePush(result, kCanonicalUsageOrder[n]);
+  }
+  return result;
+}
+
+function getBlockSize(name) {
+  switch (name) {
+    case 'SHA-1':
+      // Fall through
+    case 'SHA-256':
+      return 512;
+    case 'SHA-384':
+      // Fall through
+    case 'SHA-512':
+      return 1024;
+    case 'SHA3-256':
+      // Fall through
+    case 'SHA3-384':
+      // Fall through
+    case 'SHA3-512':
+      // This interaction is not defined for now.
+      // https://github.com/WICG/webcrypto-modern-algos/issues/23
+      throw lazyDOMException('Explicit algorithm length member is required', 'NotSupportedError');
+  }
+}
+
+function getDigestSizeInBytes(name) {
+  switch (name) {
+    case 'SHA-1':
+      return 20;
+    case 'SHA-256': // Fall through
+    case 'SHA3-256':
+      return 32;
+    case 'SHA-384': // Fall through
+    case 'SHA3-384':
+      return 48;
+    case 'SHA-512': // Fall through
+    case 'SHA3-512':
+      return 64;
+  }
+}
+
+function validateKeyOps(keyOps, usagesSet) {
+  if (keyOps === undefined) return;
+  validateArray(keyOps, 'keyData.key_ops');
+  let keyOpsMask = 0;
+  for (let n = 0; n < keyOps.length; n++) {
+    const op = keyOps[n];
+    const opMask = kUsageMasks[op];
+    // Skipping unknown key ops
+    if (opMask === undefined)
+      continue;
+    // Have we seen it already? if so, error
+    if (keyOpsMask & opMask)
+      throw lazyDOMException('Duplicate key operation', 'DataError');
+    keyOpsMask |= opMask;
+  }
+
+  if (usagesSet !== undefined) {
+    const usagesMask = getUsagesMask(usagesSet);
+    if ((keyOpsMask & usagesMask) !== usagesMask) {
+      throw lazyDOMException(
+        'Key operations and usage mismatch',
+        'DataError');
+    }
+  }
+}
+
+function secureHeapUsed() {
+  const val = _secureHeapUsed();
+  if (val === undefined)
+    return { total: 0, used: 0, utilization: 0, min: 0 };
+  const used = Number(_secureHeapUsed());
+  const total = Number(getOptionValue('--secure-heap'));
+  const min = Number(getOptionValue('--secure-heap-min'));
+  const utilization = used / total;
+  return { total, used, utilization, min };
+}
+
+module.exports = {
+  getArrayBufferOrView,
+  getCiphers,
+  getCurves,
+  getDataViewOrTypedArrayBuffer,
+  getHashes,
+  kHandle,
+  setEngine,
+  toBuf,
+
+  kNamedCurveAliases,
+  kSupportedAlgorithms,
+  normalizeAlgorithm,
+  normalizeHashName,
+  hasAnyNotIn,
+  validateByteSource,
+  validateKeyOps,
+  jobPromise,
+  jobPromiseThen,
+  cleanupWebCryptoResult,
+  prepareWebCryptoResult,
+  validateMaxBufferLength,
+  bigIntArrayToUnsignedBigInt,
+  bigIntArrayToUnsignedInt,
+  getBlockSize,
+  getDigestSizeInBytes,
+  getStringOption,
+  getUsagesUnion,
+  getUsagesMask,
+  getUsagesFromMask,
+  hasUsage,
+  secureHeapUsed,
+  getCachedHashId,
+  getHashCache,
+  getOpenSSLSecLevel,
+};
diff --git a/test/js/node/test/common/nodeinternals/internal/crypto/webidl.js b/test/js/node/test/common/nodeinternals/internal/crypto/webidl.js
new file mode 100644
index 000000000000..8b0d3bcdaf80
--- /dev/null
+++ b/test/js/node/test/common/nodeinternals/internal/crypto/webidl.js
@@ -0,0 +1,780 @@
+'use strict';
+
+const {
+  ArrayPrototypeIncludes,
+  MathPow,
+  NumberParseInt,
+  ObjectPrototypeHasOwnProperty,
+  StringPrototypeStartsWith,
+  StringPrototypeToLowerCase,
+} = primordials;
+
+const {
+  lazyDOMException,
+  kEmptyObject,
+} = require('internal/util');
+const { CryptoKey } = require('internal/crypto/webcrypto');
+const {
+  getCryptoKeyAlgorithm,
+  getCryptoKeyType,
+} = require('internal/crypto/keys');
+const {
+  validateMaxBufferLength,
+  kNamedCurveAliases,
+} = require('internal/crypto/util');
+const {
+  converters: webidl,
+  createDictionaryConverter,
+  createEnumConverter,
+  createInterfaceConverter,
+  createSequenceConverter,
+  requiredArguments,
+  type,
+} = require('internal/webidl');
+
+function validateByteLength(buf, name, target) {
+  if (buf.byteLength !== target) {
+    throw lazyDOMException(
+      `${name} must contain exactly ${target} bytes`,
+      'OperationError');
+  }
+}
+
+function AESLengthValidator(V, dict) {
+  if (V !== 128 && V !== 192 && V !== 256)
+    throw lazyDOMException(
+      'AES key length must be 128, 192, or 256 bits',
+      'OperationError');
+}
+
+function namedCurveValidator(V, dict) {
+  if (!ObjectPrototypeHasOwnProperty(kNamedCurveAliases, V))
+    throw lazyDOMException(
+      'Unrecognized namedCurve',
+      'NotSupportedError');
+}
+
+const converters = { __proto__: null, ...webidl };
+
+/**
+ * @param {string | object} V - The hash algorithm identifier (string or object).
+ * @param {string} label - The dictionary name for the error message.
+ */
+function ensureSHA(V, label) {
+  const name = typeof V === 'string' ? V : V.name;
+  if (typeof name !== 'string' ||
+      !StringPrototypeStartsWith(StringPrototypeToLowerCase(name), 'sha'))
+    throw lazyDOMException(
+      `Only SHA hashes are supported in ${label}`, 'NotSupportedError');
+}
+
+converters.AlgorithmIdentifier = (V, opts) => {
+  // Union for (object or DOMString)
+  if (type(V) === 'Object') {
+    return converters.object(V, opts);
+  }
+  return converters.DOMString(V, opts);
+};
+
+converters.KeyFormat = createEnumConverter('KeyFormat', [
+  'raw',
+  'raw-public',
+  'raw-seed',
+  'raw-secret',
+  'raw-private',
+  'pkcs8',
+  'spki',
+  'jwk',
+]);
+
+converters.KeyUsage = createEnumConverter('KeyUsage', [
+  'encrypt',
+  'decrypt',
+  'sign',
+  'verify',
+  'deriveKey',
+  'deriveBits',
+  'wrapKey',
+  'unwrapKey',
+  'encapsulateBits',
+  'decapsulateBits',
+  'encapsulateKey',
+  'decapsulateKey',
+]);
+
+converters['sequence<KeyUsage>'] = createSequenceConverter(converters.KeyUsage);
+
+converters.HashAlgorithmIdentifier = converters.AlgorithmIdentifier;
+
+/**
+ * Builds conversion options for Web Crypto integer members that use Web IDL
+ * [EnforceRange]. Keep this helper instead of spreading opts in each member
+ * converter so the hot dictionary paths allocate stable-shape objects.
+ * @param {object} opts Parent conversion options.
+ * @returns {object}
+ */
+function enforceRangeOptions(opts) {
+  return {
+    prefix: opts.prefix,
+    context: opts.context,
+    code: opts.code,
+    enforceRange: true,
+  };
+}
+
+const dictAlgorithm = [
+  {
+    key: 'name',
+    converter: converters.DOMString,
+    required: true,
+  },
+];
+
+converters.Algorithm = createDictionaryConverter(
+  'Algorithm', dictAlgorithm);
+
+converters.BigInteger = (V, opts = kEmptyObject) => {
+  return webidl.Uint8Array(V, {
+    prefix: opts.prefix,
+    context: opts.context,
+    code: opts.code,
+    allowResizable: true,
+    allowShared: false,
+  });
+};
+
+converters.BufferSource = (V, opts = kEmptyObject) => {
+  return webidl.BufferSource(V, {
+    prefix: opts.prefix,
+    context: opts.context,
+    code: opts.code,
+    allowResizable: opts.allowResizable === undefined ?
+      true : opts.allowResizable,
+    allowShared: opts.allowShared,
+  });
+};
+
+const dictRsaKeyGenParams = [
+  {
+    key: 'modulusLength',
+    converter: (V, opts) =>
+      converters['unsigned long'](V, enforceRangeOptions(opts)),
+    required: true,
+  },
+  {
+    key: 'publicExponent',
+    converter: converters.BigInteger,
+    required: true,
+  },
+];
+
+converters.RsaKeyGenParams = createDictionaryConverter(
+  'RsaKeyGenParams', [
+    dictAlgorithm,
+    dictRsaKeyGenParams,
+  ]);
+
+converters.RsaHashedKeyGenParams = createDictionaryConverter(
+  'RsaHashedKeyGenParams', [
+    dictAlgorithm,
+    dictRsaKeyGenParams,
+    [
+      {
+        key: 'hash',
+        converter: converters.HashAlgorithmIdentifier,
+        validator: (V, dict) => ensureSHA(V, 'RsaHashedKeyGenParams'),
+        required: true,
+      },
+    ],
+  ]);
+
+converters.RsaHashedImportParams = createDictionaryConverter(
+  'RsaHashedImportParams', [
+    dictAlgorithm,
+    [
+      {
+        key: 'hash',
+        converter: converters.HashAlgorithmIdentifier,
+        validator: (V, dict) => ensureSHA(V, 'RsaHashedImportParams'),
+        required: true,
+      },
+    ],
+  ]);
+
+converters.NamedCurve = converters.DOMString;
+
+converters.EcKeyImportParams = createDictionaryConverter(
+  'EcKeyImportParams', [
+    dictAlgorithm,
+    [
+      {
+        key: 'namedCurve',
+        converter: converters.NamedCurve,
+        validator: namedCurveValidator,
+        required: true,
+      },
+    ],
+  ]);
+
+converters.EcKeyGenParams = createDictionaryConverter(
+  'EcKeyGenParams', [
+    dictAlgorithm,
+    [
+      {
+        key: 'namedCurve',
+        converter: converters.NamedCurve,
+        validator: namedCurveValidator,
+        required: true,
+      },
+    ],
+  ]);
+
+converters.AesKeyGenParams = createDictionaryConverter(
+  'AesKeyGenParams', [
+    dictAlgorithm,
+    [
+      {
+        key: 'length',
+        converter: (V, opts) =>
+          converters['unsigned short'](V, enforceRangeOptions(opts)),
+        validator: AESLengthValidator,
+        required: true,
+      },
+    ],
+  ]);
+
+function validateZeroLength(parameterName) {
+  return (V, dict) => {
+    if (V.byteLength) {
+      throw lazyDOMException(
+        `Non zero-length ${parameterName} is not supported.`, 'NotSupportedError');
+    }
+  };
+}
+
+converters.RsaPssParams = createDictionaryConverter(
+  'RsaPssParams', [
+    dictAlgorithm,
+    [
+      {
+        key: 'saltLength',
+        converter: (V, opts) =>
+          converters['unsigned long'](V, enforceRangeOptions(opts)),
+        required: true,
+      },
+    ],
+  ]);
+
+converters.RsaOaepParams = createDictionaryConverter(
+  'RsaOaepParams', [
+    dictAlgorithm,
+    [
+      {
+        key: 'label',
+        converter: converters.BufferSource,
+      },
+    ],
+  ]);
+
+converters.EcdsaParams = createDictionaryConverter(
+  'EcdsaParams', [
+    dictAlgorithm,
+    [
+      {
+        key: 'hash',
+        converter: converters.HashAlgorithmIdentifier,
+        validator: (V, dict) => ensureSHA(V, 'EcdsaParams'),
+        required: true,
+      },
+    ],
+  ]);
+
+for (const { 0: name, 1: zeroError } of [['HmacKeyGenParams', 'OperationError'], ['HmacImportParams', 'DataError']]) {
+  converters[name] = createDictionaryConverter(
+    name, [
+      dictAlgorithm,
+      [
+        {
+          key: 'hash',
+          converter: converters.HashAlgorithmIdentifier,
+          validator: (V, dict) => ensureSHA(V, name),
+          required: true,
+        },
+        {
+          key: 'length',
+          converter: (V, opts) =>
+            converters['unsigned long'](V, enforceRangeOptions(opts)),
+          validator: validateMacKeyLength(`${name}.length`, zeroError),
+        },
+      ],
+    ]);
+}
+
+const simpleDomStringKey = (key) => ({ key, converter: converters.DOMString });
+
+converters.RsaOtherPrimesInfo = createDictionaryConverter(
+  'RsaOtherPrimesInfo', [
+    simpleDomStringKey('r'),
+    simpleDomStringKey('d'),
+    simpleDomStringKey('t'),
+  ]);
+converters['sequence<RsaOtherPrimesInfo>'] = createSequenceConverter(
+  converters.RsaOtherPrimesInfo);
+
+converters.JsonWebKey = createDictionaryConverter(
+  'JsonWebKey', [
+    simpleDomStringKey('kty'),
+    simpleDomStringKey('use'),
+    {
+      key: 'key_ops',
+      converter: converters['sequence<DOMString>'],
+    },
+    simpleDomStringKey('alg'),
+    {
+      key: 'ext',
+      converter: converters.boolean,
+    },
+    simpleDomStringKey('crv'),
+    simpleDomStringKey('x'),
+    simpleDomStringKey('y'),
+    simpleDomStringKey('d'),
+    simpleDomStringKey('n'),
+    simpleDomStringKey('e'),
+    simpleDomStringKey('p'),
+    simpleDomStringKey('q'),
+    simpleDomStringKey('dp'),
+    simpleDomStringKey('dq'),
+    simpleDomStringKey('qi'),
+    {
+      key: 'oth',
+      converter: converters['sequence<RsaOtherPrimesInfo>'],
+    },
+    simpleDomStringKey('k'),
+    simpleDomStringKey('pub'),
+    simpleDomStringKey('priv'),
+  ]);
+
+converters.HkdfParams = createDictionaryConverter(
+  'HkdfParams', [
+    dictAlgorithm,
+    [
+      {
+        key: 'hash',
+        converter: converters.HashAlgorithmIdentifier,
+        validator: (V, dict) => ensureSHA(V, 'HkdfParams'),
+        required: true,
+      },
+      {
+        key: 'salt',
+        converter: converters.BufferSource,
+        required: true,
+      },
+      {
+        key: 'info',
+        converter: converters.BufferSource,
+        validator: (V, dict) => validateMaxBufferLength(V, 'algorithm.info', 1024),
+        required: true,
+      },
+    ],
+  ]);
+
+converters.CShakeParams = createDictionaryConverter(
+  'CShakeParams', [
+    dictAlgorithm,
+    [
+      {
+        key: 'outputLength',
+        converter: (V, opts) =>
+          converters['unsigned long'](V, enforceRangeOptions(opts)),
+        validator: (V, opts) => {
+          // The Web Crypto spec allows for SHAKE output length that are not multiples of
+          // 8. We don't.
+          if (V % 8)
+            throw lazyDOMException('Unsupported CShakeParams outputLength', 'NotSupportedError');
+        },
+        required: true,
+      },
+      {
+        key: 'functionName',
+        converter: converters.BufferSource,
+        validator: validateZeroLength('CShakeParams.functionName'),
+      },
+      {
+        key: 'customization',
+        converter: converters.BufferSource,
+        validator: validateZeroLength('CShakeParams.customization'),
+      },
+    ],
+  ]);
+
+converters.Pbkdf2Params = createDictionaryConverter(
+  'Pbkdf2Params', [
+    dictAlgorithm,
+    [
+      {
+        key: 'salt',
+        converter: converters.BufferSource,
+        required: true,
+      },
+      {
+        key: 'iterations',
+        converter: (V, opts) =>
+          converters['unsigned long'](V, enforceRangeOptions(opts)),
+        validator: (V, dict) => {
+          if (V === 0)
+            throw lazyDOMException('iterations cannot be zero', 'OperationError');
+        },
+        required: true,
+      },
+      {
+        key: 'hash',
+        converter: converters.HashAlgorithmIdentifier,
+        validator: (V, dict) => ensureSHA(V, 'Pbkdf2Params'),
+        required: true,
+      },
+    ],
+  ]);
+
+converters.AesDerivedKeyParams = createDictionaryConverter(
+  'AesDerivedKeyParams', [
+    dictAlgorithm,
+    [
+      {
+        key: 'length',
+        converter: (V, opts) =>
+          converters['unsigned short'](V, enforceRangeOptions(opts)),
+        validator: AESLengthValidator,
+        required: true,
+      },
+    ],
+  ]);
+
+converters.AesCbcParams = createDictionaryConverter(
+  'AesCbcParams', [
+    dictAlgorithm,
+    [
+      {
+        key: 'iv',
+        converter: converters.BufferSource,
+        validator: (V, dict) => validateByteLength(V, 'algorithm.iv', 16),
+        required: true,
+      },
+    ],
+  ]);
+
+converters.AeadParams = createDictionaryConverter(
+  'AeadParams', [
+    dictAlgorithm,
+    [
+      {
+        key: 'iv',
+        converter: converters.BufferSource,
+        validator: (V, dict) => {
+          switch (StringPrototypeToLowerCase(dict.name)) {
+            case 'chacha20-poly1305':
+              validateByteLength(V, 'algorithm.iv', 12);
+              break;
+            case 'aes-gcm':
+              validateMaxBufferLength(V, 'algorithm.iv');
+              break;
+            case 'aes-ocb':
+              if (V.byteLength > 15) {
+                throw lazyDOMException(
+                  'AES-OCB algorithm.iv must be no more than 15 bytes',
+                  'OperationError');
+              }
+              break;
+          }
+        },
+        required: true,
+      },
+      {
+        key: 'additionalData',
+        converter: converters.BufferSource,
+        validator: (V, dict) => validateMaxBufferLength(V, 'algorithm.additionalData'),
+      },
+      {
+        key: 'tagLength',
+        converter: (V, opts) =>
+          converters.octet(V, enforceRangeOptions(opts)),
+        validator: (V, dict) => {
+          switch (StringPrototypeToLowerCase(dict.name)) {
+            case 'chacha20-poly1305':
+              if (V !== 128) {
+                throw lazyDOMException(
+                  `${V} is not a valid ChaCha20-Poly1305 tag length`,
+                  'OperationError');
+              }
+              break;
+            case 'aes-gcm':
+              if (!ArrayPrototypeIncludes([32, 64, 96, 104, 112, 120, 128], V)) {
+                throw lazyDOMException(
+                  `${V} is not a valid AES-GCM tag length`,
+                  'OperationError');
+              }
+              break;
+            case 'aes-ocb':
+              if (!ArrayPrototypeIncludes([64, 96, 128], V)) {
+                throw lazyDOMException(
+                  `${V} is not a valid AES-OCB tag length`,
+                  'OperationError');
+              }
+              break;
+          }
+        },
+      },
+    ],
+  ]);
+
+converters.AesCtrParams = createDictionaryConverter(
+  'AesCtrParams', [
+    dictAlgorithm,
+    [
+      {
+        key: 'counter',
+        converter: converters.BufferSource,
+        validator: (V, dict) => validateByteLength(V, 'algorithm.counter', 16),
+        required: true,
+      },
+      {
+        key: 'length',
+        converter: (V, opts) =>
+          converters.octet(V, enforceRangeOptions(opts)),
+        validator: (V, dict) => {
+          if (V === 0 || V > 128)
+            throw lazyDOMException(
+              'AES-CTR algorithm.length must be between 1 and 128',
+              'OperationError');
+        },
+        required: true,
+      },
+    ],
+  ]);
+
+converters.CryptoKey = createInterfaceConverter(
+  'CryptoKey', CryptoKey.prototype);
+
+converters.EcdhKeyDeriveParams = createDictionaryConverter(
+  'EcdhKeyDeriveParams', [
+    dictAlgorithm,
+    [
+      {
+        key: 'public',
+        converter: converters.CryptoKey,
+        validator: (V, dict) => {
+          if (getCryptoKeyType(V) !== 'public')
+            throw lazyDOMException(
+              'algorithm.public must be a public key', 'InvalidAccessError');
+
+          if (StringPrototypeToLowerCase(getCryptoKeyAlgorithm(V).name) !== StringPrototypeToLowerCase(dict.name))
+            throw lazyDOMException(
+              'key algorithm mismatch',
+              'InvalidAccessError');
+        },
+        required: true,
+      },
+    ],
+  ]);
+
+converters.ContextParams = createDictionaryConverter(
+  'ContextParams', [
+    dictAlgorithm,
+    [
+      {
+        key: 'context',
+        converter: converters.BufferSource,
+        validator(V, dict) {
+          if (process.features.openssl_is_boringssl) {
+            this.validator = undefined;
+          } else {
+            let { 0: major, 1: minor } = process.versions.openssl.split('.');
+            major = NumberParseInt(major, 10);
+            minor = NumberParseInt(minor, 10);
+            if (major > 3 || (major === 3 && minor >= 2)) {
+              this.validator = undefined;
+            } else {
+              this.validator = validateZeroLength('ContextParams.context');
+              this.validator(V, dict);
+            }
+          }
+        },
+      },
+    ],
+  ]);
+
+converters.Argon2Params = createDictionaryConverter(
+  'Argon2Params', [
+    dictAlgorithm,
+    [
+      {
+        key: 'nonce',
+        converter: converters.BufferSource,
+        validator: (V) => {
+          if (V.byteLength < 8) {
+            throw lazyDOMException('nonce must be at least 8 bytes', 'OperationError');
+          }
+        },
+        required: true,
+      },
+      {
+        key: 'parallelism',
+        converter: (V, opts) =>
+          converters['unsigned long'](V, enforceRangeOptions(opts)),
+        validator: (V, dict) => {
+          if (V === 0 || V > MathPow(2, 24) - 1) {
+            throw lazyDOMException(
+              'parallelism must be > 0 and <= 16777215',
+              'OperationError');
+          }
+        },
+        required: true,
+      },
+      {
+        key: 'memory',
+        converter: (V, opts) =>
+          converters['unsigned long'](V, enforceRangeOptions(opts)),
+        validator: (V, dict) => {
+          if (V < 8 * dict.parallelism) {
+            throw lazyDOMException(
+              'memory must be at least 8 times the degree of parallelism',
+              'OperationError');
+          }
+        },
+        required: true,
+      },
+      {
+        key: 'passes',
+        converter: (V, opts) =>
+          converters['unsigned long'](V, enforceRangeOptions(opts)),
+        validator: (V) => {
+          if (V === 0) {
+            throw lazyDOMException('passes must be > 0', 'OperationError');
+          }
+        },
+        required: true,
+      },
+      {
+        key: 'version',
+        converter: (V, opts) =>
+          converters.octet(V, enforceRangeOptions(opts)),
+        validator: (V, dict) => {
+          if (V !== 0x13) {
+            throw lazyDOMException(
+              `${V} is not a valid Argon2 version`,
+              'OperationError');
+          }
+        },
+      },
+      {
+        key: 'secretValue',
+        converter: converters.BufferSource,
+      },
+      {
+        key: 'associatedData',
+        converter: converters.BufferSource,
+      },
+    ],
+  ]);
+
+function validateMacKeyLength(parameterName, zeroError) {
+  return (V) => {
+    if (V === 0)
+      throw lazyDOMException(`${parameterName} cannot be 0`, zeroError);
+
+    // The Web Crypto spec allows for key lengths that are not multiples of 8. We don't.
+    if (V % 8)
+      throw lazyDOMException(`Unsupported ${parameterName}`, 'NotSupportedError');
+  };
+}
+
+for (const { 0: name, 1: zeroError } of [['KmacKeyGenParams', 'OperationError'], ['KmacImportParams', 'DataError']]) {
+  converters[name] = createDictionaryConverter(
+    name, [
+      dictAlgorithm,
+      [
+        {
+          key: 'length',
+          converter: (V, opts) =>
+            converters['unsigned long'](V, enforceRangeOptions(opts)),
+          validator: validateMacKeyLength(`${name}.length`, zeroError),
+        },
+      ],
+    ]);
+}
+
+converters.KmacParams = createDictionaryConverter(
+  'KmacParams', [
+    dictAlgorithm,
+    [
+      {
+        key: 'outputLength',
+        converter: (V, opts) =>
+          converters['unsigned long'](V, enforceRangeOptions(opts)),
+        validator: (V, opts) => {
+          // The Web Crypto spec allows for KMAC output length that are not multiples of 8. We don't.
+          if (V % 8)
+            throw lazyDOMException('Unsupported KmacParams outputLength', 'NotSupportedError');
+        },
+        required: true,
+      },
+      {
+        key: 'customization',
+        converter: converters.BufferSource,
+      },
+    ],
+  ]);
+
+converters.KangarooTwelveParams = createDictionaryConverter(
+  'KangarooTwelveParams', [
+    dictAlgorithm,
+    [
+      {
+        key: 'outputLength',
+        converter: (V, opts) =>
+          converters['unsigned long'](V, enforceRangeOptions(opts)),
+        validator: (V, opts) => {
+          if (V === 0 || V % 8)
+            throw lazyDOMException('Invalid KangarooTwelveParams outputLength', 'OperationError');
+        },
+        required: true,
+      },
+      {
+        key: 'customization',
+        converter: converters.BufferSource,
+      },
+    ],
+  ]);
+
+converters.TurboShakeParams = createDictionaryConverter(
+  'TurboShakeParams', [
+    dictAlgorithm,
+    [
+      {
+        key: 'outputLength',
+        converter: (V, opts) =>
+          converters['unsigned long'](V, enforceRangeOptions(opts)),
+        validator: (V, opts) => {
+          if (V === 0 || V % 8)
+            throw lazyDOMException('Invalid TurboShakeParams outputLength', 'OperationError');
+        },
+        required: true,
+      },
+      {
+        key: 'domainSeparation',
+        converter: (V, opts) =>
+          converters.octet(V, enforceRangeOptions(opts)),
+        validator: (V) => {
+          if (V < 0x01 || V > 0x7F) {
+            throw lazyDOMException(
+              'TurboShakeParams.domainSeparation must be in range 0x01-0x7f',
+              'OperationError');
+          }
+        },
+      },
+    ],
+  ]);
+
+module.exports = {
+  converters,
+  requiredArguments,
+};
diff --git a/test/js/node/test/common/nodeinternals/internal/fs/utils.js b/test/js/node/test/common/nodeinternals/internal/fs/utils.js
new file mode 100644
index 000000000000..ca0a888ada40
--- /dev/null
+++ b/test/js/node/test/common/nodeinternals/internal/fs/utils.js
@@ -0,0 +1,1085 @@
+'use strict';
+
+const {
+  ArrayIsArray,
+  BigInt,
+  Date,
+  DateNow,
+  DatePrototypeGetTime,
+  ErrorCaptureStackTrace,
+  FunctionPrototypeCall,
+  MathFloor,
+  MathMin,
+  MathRound,
+  Number,
+  NumberIsFinite,
+  ObjectDefineProperties,
+  ObjectIs,
+  ObjectSetPrototypeOf,
+  ReflectOwnKeys,
+  RegExpPrototypeSymbolReplace,
+  StringPrototypeEndsWith,
+  StringPrototypeIncludes,
+  Symbol,
+  TypedArrayPrototypeAt,
+  TypedArrayPrototypeIncludes,
+  globalThis,
+} = primordials;
+
+const { Buffer } = require('buffer');
+const {
+  UVException,
+  codes: {
+    ERR_FS_EISDIR,
+    ERR_INCOMPATIBLE_OPTION_PAIR,
+    ERR_INVALID_ARG_TYPE,
+    ERR_INVALID_ARG_VALUE,
+    ERR_NO_TEMPORAL,
+    ERR_OUT_OF_RANGE,
+  },
+  hideStackFrames,
+} = require('internal/errors');
+const {
+  isArrayBufferView,
+  isBigInt64Array,
+  isDate,
+  isUint8Array,
+} = require('internal/util/types');
+const {
+  deprecate,
+  isWindows,
+  kEmptyObject,
+  once,
+  setOwnProperty,
+} = require('internal/util');
+const { toPathIfFileURL } = require('internal/url');
+const {
+  validateAbortSignal,
+  validateBoolean,
+  validateFunction,
+  validateInt32,
+  validateInteger,
+  validateObject,
+  validateUint32,
+} = require('internal/validators');
+const pathModule = require('path');
+const kType = Symbol('type');
+const kStats = Symbol('stats');
+const kPartialAtimeNs = Symbol('partialAtimeNs');
+const kPartialMtimeNs = Symbol('partialMtimeNs');
+const kPartialCtimeNs = Symbol('partialCtimeNs');
+const kPartialBirthtimeNs = Symbol('kPartialBirthtimeNs');
+const assert = require('internal/assert');
+
+const {
+  fs: {
+    F_OK = 0,
+    W_OK = 0,
+    R_OK = 0,
+    X_OK = 0,
+    COPYFILE_EXCL,
+    COPYFILE_FICLONE,
+    COPYFILE_FICLONE_FORCE,
+    O_APPEND,
+    O_CREAT,
+    O_EXCL,
+    O_RDONLY,
+    O_RDWR,
+    O_SYNC,
+    O_TRUNC,
+    O_WRONLY,
+    S_IFBLK,
+    S_IFCHR,
+    S_IFDIR,
+    S_IFIFO,
+    S_IFLNK,
+    S_IFMT,
+    S_IFREG,
+    S_IFSOCK,
+    UV_FS_SYMLINK_DIR,
+    UV_FS_SYMLINK_JUNCTION,
+    UV_DIRENT_UNKNOWN,
+    UV_DIRENT_FILE,
+    UV_DIRENT_DIR,
+    UV_DIRENT_LINK,
+    UV_DIRENT_FIFO,
+    UV_DIRENT_SOCKET,
+    UV_DIRENT_CHAR,
+    UV_DIRENT_BLOCK,
+  },
+  os: {
+    errno: {
+      EISDIR,
+    },
+  },
+} = internalBinding('constants');
+
+// The access modes can be any of F_OK, R_OK, W_OK or X_OK. Some might not be
+// available on specific systems. They can be used in combination as well
+// (F_OK | R_OK | W_OK | X_OK).
+const kMinimumAccessMode = MathMin(F_OK, W_OK, R_OK, X_OK);
+const kMaximumAccessMode = F_OK | W_OK | R_OK | X_OK;
+
+const kDefaultCopyMode = 0;
+// The copy modes can be any of COPYFILE_EXCL, COPYFILE_FICLONE or
+// COPYFILE_FICLONE_FORCE. They can be used in combination as well
+// (COPYFILE_EXCL | COPYFILE_FICLONE | COPYFILE_FICLONE_FORCE).
+const kMinimumCopyMode = MathMin(
+  kDefaultCopyMode,
+  COPYFILE_EXCL,
+  COPYFILE_FICLONE,
+  COPYFILE_FICLONE_FORCE,
+);
+const kMaximumCopyMode = COPYFILE_EXCL |
+                         COPYFILE_FICLONE |
+                         COPYFILE_FICLONE_FORCE;
+
+// Most platforms don't allow reads or writes >= 2 GiB.
+// See https://github.com/libuv/libuv/pull/1501.
+const kIoMaxLength = 2 ** 31 - 1;
+
+// Use 64kb in case the file type is not a regular file and thus do not know the
+// actual file size. Increasing the value further results in more frequent over
+// allocation for small files and consumes CPU time and memory that should be
+// used else wise.
+// Use up to 512kb per read otherwise to partition reading big files to prevent
+// blocking other threads in case the available threads are all in use.
+const kReadFileUnknownBufferLength = 64 * 1024;
+const kReadFileBufferLength = 512 * 1024;
+
+const kWriteFileMaxChunkSize = 512 * 1024;
+
+const kMaxUserId = 2 ** 32 - 1;
+
+let fs;
+function lazyLoadFs() {
+  return fs ??= require('fs');
+}
+
+function assertEncoding(encoding) {
+  if (encoding && !Buffer.isEncoding(encoding)) {
+    const reason = 'is invalid encoding';
+    throw new ERR_INVALID_ARG_VALUE('encoding', encoding, reason);
+  }
+}
+
+class Dirent {
+  constructor(name, type, path) {
+    this.name = name;
+    this.parentPath = path;
+    this[kType] = type;
+  }
+
+  isDirectory() {
+    return this[kType] === UV_DIRENT_DIR;
+  }
+
+  isFile() {
+    return this[kType] === UV_DIRENT_FILE;
+  }
+
+  isBlockDevice() {
+    return this[kType] === UV_DIRENT_BLOCK;
+  }
+
+  isCharacterDevice() {
+    return this[kType] === UV_DIRENT_CHAR;
+  }
+
+  isSymbolicLink() {
+    return this[kType] === UV_DIRENT_LINK;
+  }
+
+  isFIFO() {
+    return this[kType] === UV_DIRENT_FIFO;
+  }
+
+  isSocket() {
+    return this[kType] === UV_DIRENT_SOCKET;
+  }
+}
+
+class DirentFromStats extends Dirent {
+  constructor(name, stats, path) {
+    super(name, null, path);
+    this[kStats] = stats;
+  }
+}
+
+for (const name of ReflectOwnKeys(Dirent.prototype)) {
+  if (name === 'constructor') {
+    continue;
+  }
+  DirentFromStats.prototype[name] = function() {
+    return this[kStats][name]();
+  };
+}
+
+function copyObject(source) {
+  const target = {};
+  for (const key in source)
+    target[key] = source[key];
+  return target;
+}
+
+const bufferSep = Buffer.from(pathModule.sep);
+
+function join(path, name) {
+  if ((typeof path === 'string' || isUint8Array(path)) &&
+      name === undefined) {
+    return path;
+  }
+
+  if (typeof path === 'string' && isUint8Array(name)) {
+    const pathBuffer = Buffer.from(pathModule.join(path, pathModule.sep));
+    return Buffer.concat([pathBuffer, name]);
+  }
+
+  if (typeof path === 'string' && typeof name === 'string') {
+    return pathModule.join(path, name);
+  }
+
+  if (isUint8Array(path) && isUint8Array(name)) {
+    return Buffer.concat([path, bufferSep, name]);
+  }
+
+  throw new ERR_INVALID_ARG_TYPE(
+    'path', ['string', 'Buffer'], path);
+}
+
+function getDirents(path, { 0: names, 1: types }, callback) {
+  let i;
+  if (typeof callback === 'function') {
+    const len = names.length;
+    let toFinish = 0;
+    callback = once(callback);
+    for (i = 0; i < len; i++) {
+      const type = types[i];
+      if (type === UV_DIRENT_UNKNOWN) {
+        const name = names[i];
+        const idx = i;
+        toFinish++;
+        let filepath;
+        try {
+          filepath = join(path, name);
+        } catch (err) {
+          callback(err);
+          return;
+        }
+        lazyLoadFs().lstat(filepath, (err, stats) => {
+          if (err) {
+            callback(err);
+            return;
+          }
+          names[idx] = new DirentFromStats(name, stats, path);
+          if (--toFinish === 0) {
+            callback(null, names);
+          }
+        });
+      } else {
+        names[i] = new Dirent(names[i], types[i], path);
+      }
+    }
+    if (toFinish === 0) {
+      callback(null, names);
+    }
+  } else {
+    const len = names.length;
+    for (i = 0; i < len; i++) {
+      names[i] = getDirent(path, names[i], types[i]);
+    }
+    return names;
+  }
+}
+
+function getDirent(path, name, type, callback) {
+  if (typeof callback === 'function') {
+    if (type === UV_DIRENT_UNKNOWN) {
+      let filepath;
+      try {
+        filepath = join(path, name);
+      } catch (err) {
+        callback(err);
+        return;
+      }
+      lazyLoadFs().lstat(filepath, (err, stats) => {
+        if (err) {
+          callback(err);
+          return;
+        }
+        callback(null, new DirentFromStats(name, stats, path));
+      });
+    } else {
+      callback(null, new Dirent(name, type, path));
+    }
+  } else if (type === UV_DIRENT_UNKNOWN) {
+    const filepath = join(path, name);
+    const stats = lazyLoadFs().lstatSync(filepath);
+    return new DirentFromStats(name, stats, path);
+  } else {
+    return new Dirent(name, type, path);
+  }
+}
+
+function getOptions(options, defaultOptions = kEmptyObject) {
+  if (options == null || typeof options === 'function') {
+    return defaultOptions;
+  }
+
+  if (typeof options === 'string') {
+    defaultOptions = { ...defaultOptions };
+    defaultOptions.encoding = options;
+    options = defaultOptions;
+  } else if (typeof options !== 'object') {
+    throw new ERR_INVALID_ARG_TYPE('options', ['string', 'Object'], options);
+  }
+
+  if (options.encoding !== 'buffer')
+    assertEncoding(options.encoding);
+
+  if (options.signal !== undefined) {
+    validateAbortSignal(options.signal, 'options.signal');
+  }
+
+  return options;
+}
+
+/**
+ * @param {InternalFSBinding.FSSyncContext} ctx
+ */
+function handleErrorFromBinding(ctx) {
+  if (ctx.errno !== undefined) {  // libuv error numbers
+    const err = new UVException(ctx);
+    ErrorCaptureStackTrace(err, handleErrorFromBinding);
+    throw err;
+  }
+  if (ctx.error !== undefined) {  // Errors created in C++ land.
+    ErrorCaptureStackTrace(ctx.error, handleErrorFromBinding);
+    throw ctx.error;
+  }
+}
+
+function preprocessSymlinkDestination(path, type, linkPath) {
+  if (!isWindows) {
+    // No preprocessing is needed on Unix.
+    return path;
+  }
+  path = '' + path;
+  if (type === 'junction') {
+    // Junctions paths need to be absolute and \\?\-prefixed.
+    // A relative target is relative to the link's parent directory.
+    path = pathModule.resolve(linkPath, '..', path);
+    return pathModule.toNamespacedPath(path);
+  }
+  if (pathModule.isAbsolute(path)) {
+    // If the path is absolute, use the \\?\-prefix to enable long filenames
+    return pathModule.toNamespacedPath(path);
+  }
+  // Windows symlinks don't tolerate forward slashes.
+  return RegExpPrototypeSymbolReplace(/\//g, path, '\\');
+}
+
+// Constructor for file stats.
+function StatsBase(dev, mode, nlink, uid, gid, rdev, blksize,
+                   ino, size, blocks) {
+  this.dev = dev;
+  this.mode = mode;
+  this.nlink = nlink;
+  this.uid = uid;
+  this.gid = gid;
+  this.rdev = rdev;
+  this.blksize = blksize;
+  this.ino = ino;
+  this.size = size;
+  this.blocks = blocks;
+}
+
+StatsBase.prototype.isDirectory = function() {
+  return this._checkModeProperty(S_IFDIR);
+};
+
+StatsBase.prototype.isFile = function() {
+  return this._checkModeProperty(S_IFREG);
+};
+
+StatsBase.prototype.isBlockDevice = function() {
+  return this._checkModeProperty(S_IFBLK);
+};
+
+StatsBase.prototype.isCharacterDevice = function() {
+  return this._checkModeProperty(S_IFCHR);
+};
+
+StatsBase.prototype.isSymbolicLink = function() {
+  return this._checkModeProperty(S_IFLNK);
+};
+
+StatsBase.prototype.isFIFO = function() {
+  return this._checkModeProperty(S_IFIFO);
+};
+
+StatsBase.prototype.isSocket = function() {
+  return this._checkModeProperty(S_IFSOCK);
+};
+
+const kNsPerMsBigInt = 1_000_000n;
+const kNsPerSecBigInt = 1_000_000_000n;
+const kMsPerSec = 1_000;
+const kNsPerMs = 1_000_000;
+function msFromTimeSpec(sec, nsec) {
+  return sec * kMsPerSec + nsec / kNsPerMs;
+}
+
+function nsFromTimeSpecBigInt(sec, nsec) {
+  return sec * kNsPerSecBigInt + nsec;
+}
+
+let TemporalInstant;
+
+function instantFromNs(nsec) {
+  TemporalInstant ??= globalThis.Temporal?.Instant;
+  if (TemporalInstant === undefined) {
+    throw new ERR_NO_TEMPORAL();
+  }
+  return new TemporalInstant(nsec);
+}
+
+function instantFromTimeSpecMs(msec, nsec) {
+  TemporalInstant ??= globalThis.Temporal?.Instant;
+  if (TemporalInstant === undefined) {
+    throw new ERR_NO_TEMPORAL();
+  }
+  return new TemporalInstant(BigInt(MathFloor(msec / kMsPerSec)) * kNsPerSecBigInt + BigInt(nsec));
+}
+
+// The Date constructor performs Math.floor() on the absolute value
+// of the timestamp: https://tc39.es/ecma262/#sec-timeclip
+// Since there may be a precision loss when the timestamp is
+// converted to a floating point number, we manually round
+// the timestamp here before passing it to Date().
+// Refs: https://github.com/nodejs/node/pull/12607
+// Refs: https://github.com/nodejs/node/pull/43714
+function dateFromMs(ms) {
+  // Coercing to number, ms can be bigint
+  return new Date(MathRound(Number(ms)));
+}
+
+const lazyDateFields = {
+  __proto__: null,
+  atime: {
+    __proto__: null,
+    enumerable: true,
+    configurable: true,
+    get() {
+      return setOwnProperty(this, 'atime', dateFromMs(this.atimeMs));
+    },
+    set(value) {
+      setOwnProperty(this, 'atime', value);
+    },
+  },
+  mtime: {
+    __proto__: null,
+    enumerable: true,
+    configurable: true,
+    get() {
+      return setOwnProperty(this, 'mtime', dateFromMs(this.mtimeMs));
+    },
+    set(value) {
+      setOwnProperty(this, 'mtime', value);
+    },
+  },
+  ctime: {
+    __proto__: null,
+    enumerable: true,
+    configurable: true,
+    get() {
+      return setOwnProperty(this, 'ctime', dateFromMs(this.ctimeMs));
+    },
+    set(value) {
+      setOwnProperty(this, 'ctime', value);
+    },
+  },
+  birthtime: {
+    __proto__: null,
+    enumerable: true,
+    configurable: true,
+    get() {
+      return setOwnProperty(this, 'birthtime', dateFromMs(this.birthtimeMs));
+    },
+    set(value) {
+      setOwnProperty(this, 'birthtime', value);
+    },
+  },
+};
+
+const lazyTemporalFields = {
+  __proto__: null,
+  atimeInstant: {
+    __proto__: null,
+    enumerable: true,
+    configurable: true,
+    get() {
+      return setOwnProperty(this, 'atimeInstant',
+                            instantFromTimeSpecMs(this.atimeMs, this[kPartialAtimeNs]));
+    },
+    set(value) {
+      setOwnProperty(this, 'atimeInstant', value);
+    },
+  },
+  mtimeInstant: {
+    __proto__: null,
+    enumerable: true,
+    configurable: true,
+    get() {
+      return setOwnProperty(this, 'mtimeInstant',
+                            instantFromTimeSpecMs(this.mtimeMs, this[kPartialMtimeNs]));
+    },
+    set(value) {
+      setOwnProperty(this, 'mtimeInstant', value);
+    },
+  },
+  ctimeInstant: {
+    __proto__: null,
+    enumerable: true,
+    configurable: true,
+    get() {
+      return setOwnProperty(this, 'ctimeInstant',
+                            instantFromTimeSpecMs(this.ctimeMs, this[kPartialCtimeNs]));
+    },
+    set(value) {
+      setOwnProperty(this, 'ctimeInstant', value);
+    },
+  },
+  birthtimeInstant: {
+    __proto__: null,
+    enumerable: true,
+    configurable: true,
+    get() {
+      return setOwnProperty(this, 'birthtimeInstant',
+                            instantFromTimeSpecMs(this.birthtimeMs, this[kPartialBirthtimeNs]));
+    },
+    set(value) {
+      setOwnProperty(this, 'birthtimeInstant', value);
+    },
+  },
+};
+
+const lazyTemporalBigIntFields = {
+  __proto__: null,
+  atimeInstant: {
+    __proto__: null,
+    enumerable: true,
+    configurable: true,
+    get() {
+      return setOwnProperty(this, 'atimeInstant', instantFromNs(this.atimeNs));
+    },
+    set(value) {
+      setOwnProperty(this, 'atimeInstant', value);
+    },
+  },
+  mtimeInstant: {
+    __proto__: null,
+    enumerable: true,
+    configurable: true,
+    get() {
+      return setOwnProperty(this, 'mtimeInstant', instantFromNs(this.mtimeNs));
+    },
+    set(value) {
+      setOwnProperty(this, 'mtimeInstant', value);
+    },
+  },
+  ctimeInstant: {
+    __proto__: null,
+    enumerable: true,
+    configurable: true,
+    get() {
+      return setOwnProperty(this, 'ctimeInstant', instantFromNs(this.ctimeNs));
+    },
+    set(value) {
+      setOwnProperty(this, 'ctimeInstant', value);
+    },
+  },
+  birthtimeInstant: {
+    __proto__: null,
+    enumerable: true,
+    configurable: true,
+    get() {
+      return setOwnProperty(this, 'birthtimeInstant', instantFromNs(this.birthtimeNs));
+    },
+    set(value) {
+      setOwnProperty(this, 'birthtimeInstant', value);
+    },
+  },
+};
+
+function BigIntStats(dev, mode, nlink, uid, gid, rdev, blksize,
+                     ino, size, blocks,
+                     atimeNs, mtimeNs, ctimeNs, birthtimeNs) {
+  FunctionPrototypeCall(StatsBase, this, dev, mode, nlink, uid, gid, rdev, blksize, ino, size, blocks);
+
+  this.atimeMs = atimeNs / kNsPerMsBigInt;
+  this.mtimeMs = mtimeNs / kNsPerMsBigInt;
+  this.ctimeMs = ctimeNs / kNsPerMsBigInt;
+  this.birthtimeMs = birthtimeNs / kNsPerMsBigInt;
+  this.atimeNs = atimeNs;
+  this.mtimeNs = mtimeNs;
+  this.ctimeNs = ctimeNs;
+  this.birthtimeNs = birthtimeNs;
+}
+
+ObjectSetPrototypeOf(BigIntStats.prototype, StatsBase.prototype);
+ObjectSetPrototypeOf(BigIntStats, StatsBase);
+ObjectDefineProperties(BigIntStats.prototype, lazyDateFields);
+ObjectDefineProperties(BigIntStats.prototype, lazyTemporalBigIntFields);
+
+BigIntStats.prototype._checkModeProperty = function(property) {
+  if (isWindows && (property === S_IFIFO || property === S_IFBLK ||
+    property === S_IFSOCK)) {
+    return false;  // Some types are not available on Windows
+  }
+  return (this.mode & BigInt(S_IFMT)) === BigInt(property);
+};
+
+function Stats(dev, mode, nlink, uid, gid, rdev, blksize,
+               ino, size, blocks,
+               atimeS, atimeNs, mtimeS, mtimeNs, ctimeS, ctimeNs, birthtimeS, birthtimeNs) {
+  FunctionPrototypeCall(StatsBase, this, dev, mode, nlink, uid, gid, rdev,
+                        blksize, ino, size, blocks);
+  this.atimeMs = msFromTimeSpec(atimeS, atimeNs);
+  this.mtimeMs = msFromTimeSpec(mtimeS, mtimeNs);
+  this.ctimeMs = msFromTimeSpec(ctimeS, ctimeNs);
+  this.birthtimeMs = msFromTimeSpec(birthtimeS, birthtimeNs);
+  this[kPartialAtimeNs] = atimeNs;
+  this[kPartialMtimeNs] = mtimeNs;
+  this[kPartialCtimeNs] = ctimeNs;
+  this[kPartialBirthtimeNs] = birthtimeNs;
+}
+
+ObjectSetPrototypeOf(Stats.prototype, StatsBase.prototype);
+ObjectSetPrototypeOf(Stats, StatsBase);
+ObjectDefineProperties(Stats.prototype, lazyDateFields);
+ObjectDefineProperties(Stats.prototype, lazyTemporalFields);
+
+Stats.prototype._checkModeProperty = function(property) {
+  if (isWindows && (property === S_IFIFO || property === S_IFBLK ||
+    property === S_IFSOCK)) {
+    return false;  // Some types are not available on Windows
+  }
+  return (this.mode & S_IFMT) === property;
+};
+
+/**
+ * @param {Float64Array | BigInt64Array} stats
+ * @param {number} offset
+ * @returns {BigIntStats | Stats}
+ */
+function getStatsFromBinding(stats, offset = 0) {
+  if (isBigInt64Array(stats)) {
+    return new BigIntStats(
+      stats[0 + offset], stats[1 + offset], stats[2 + offset],
+      stats[3 + offset], stats[4 + offset], stats[5 + offset],
+      stats[6 + offset], stats[7 + offset], stats[8 + offset],
+      stats[9 + offset],
+      nsFromTimeSpecBigInt(stats[10 + offset], stats[11 + offset]),
+      nsFromTimeSpecBigInt(stats[12 + offset], stats[13 + offset]),
+      nsFromTimeSpecBigInt(stats[14 + offset], stats[15 + offset]),
+      nsFromTimeSpecBigInt(stats[16 + offset], stats[17 + offset]),
+    );
+  }
+  return new Stats(
+    stats[0 + offset], stats[1 + offset], stats[2 + offset],
+    stats[3 + offset], stats[4 + offset], stats[5 + offset],
+    stats[6 + offset], stats[7 + offset], stats[8 + offset],
+    stats[9 + offset],
+    stats[10 + offset], stats[11 + offset], // atime
+    stats[12 + offset], stats[13 + offset], // mtime
+    stats[14 + offset], stats[15 + offset], // ctime
+    stats[16 + offset], stats[17 + offset], // birthtime
+  );
+}
+
+class StatFs {
+  constructor(type, bsize, frsize, blocks, bfree, bavail, files, ffree) {
+    this.type = type;
+    this.bsize = bsize;
+    this.frsize = frsize;
+    this.blocks = blocks;
+    this.bfree = bfree;
+    this.bavail = bavail;
+    this.files = files;
+    this.ffree = ffree;
+  }
+}
+
+function getStatFsFromBinding(stats) {
+  return new StatFs(
+    stats[0], stats[1], stats[2], stats[3], stats[4], stats[5], stats[6], stats[7],
+  );
+}
+
+function stringToFlags(flags, name = 'flags') {
+  if (typeof flags === 'number') {
+    validateInt32(flags, name);
+    return flags;
+  }
+
+  if (flags == null) {
+    return O_RDONLY;
+  }
+
+  switch (flags) {
+    case 'r' : return O_RDONLY;
+    case 'rs' : // Fall through.
+    case 'sr' : return O_RDONLY | O_SYNC;
+    case 'r+' : return O_RDWR;
+    case 'rs+' : // Fall through.
+    case 'sr+' : return O_RDWR | O_SYNC;
+
+    case 'w' : return O_TRUNC | O_CREAT | O_WRONLY;
+    case 'wx' : // Fall through.
+    case 'xw' : return O_TRUNC | O_CREAT | O_WRONLY | O_EXCL;
+
+    case 'w+' : return O_TRUNC | O_CREAT | O_RDWR;
+    case 'wx+': // Fall through.
+    case 'xw+': return O_TRUNC | O_CREAT | O_RDWR | O_EXCL;
+
+    case 'a' : return O_APPEND | O_CREAT | O_WRONLY;
+    case 'ax' : // Fall through.
+    case 'xa' : return O_APPEND | O_CREAT | O_WRONLY | O_EXCL;
+    case 'as' : // Fall through.
+    case 'sa' : return O_APPEND | O_CREAT | O_WRONLY | O_SYNC;
+
+    case 'a+' : return O_APPEND | O_CREAT | O_RDWR;
+    case 'ax+': // Fall through.
+    case 'xa+': return O_APPEND | O_CREAT | O_RDWR | O_EXCL;
+    case 'as+': // Fall through.
+    case 'sa+': return O_APPEND | O_CREAT | O_RDWR | O_SYNC;
+  }
+
+  throw new ERR_INVALID_ARG_VALUE('flags', flags);
+}
+
+const stringToSymlinkType = hideStackFrames((type) => {
+  switch (type) {
+    case undefined:
+    case null:
+    case 'file':
+      return 0;
+    case 'dir':
+      return UV_FS_SYMLINK_DIR;
+    case 'junction':
+      return UV_FS_SYMLINK_JUNCTION;
+  }
+});
+
+// converts Date or number to a fractional UNIX timestamp
+function toUnixTimestamp(time, name = 'time') {
+  // eslint-disable-next-line eqeqeq
+  if (typeof time === 'string' && +time == time) {
+    return +time;
+  }
+  if (NumberIsFinite(time)) {
+    if (time < 0) {
+      return DateNow() / 1000;
+    }
+    return time;
+  }
+  if (isDate(time)) {
+    // Convert to 123.456 UNIX timestamp
+    return DatePrototypeGetTime(time) / 1000;
+  }
+  throw new ERR_INVALID_ARG_TYPE(name, ['Date', 'Time in seconds'], time);
+}
+
+const validateOffsetLengthRead = hideStackFrames(
+  (offset, length, bufferLength) => {
+    if (offset < 0) {
+      throw new ERR_OUT_OF_RANGE.HideStackFramesError('offset', '>= 0', offset);
+    }
+    if (length < 0) {
+      throw new ERR_OUT_OF_RANGE.HideStackFramesError('length', '>= 0', length);
+    }
+    if (offset + length > bufferLength) {
+      throw new ERR_OUT_OF_RANGE.HideStackFramesError('length',
+                                                      `<= ${bufferLength - offset}`, length);
+    }
+  },
+);
+
+const validateOffsetLengthWrite = hideStackFrames(
+  (offset, length, byteLength) => {
+    if (offset > byteLength) {
+      throw new ERR_OUT_OF_RANGE.HideStackFramesError('offset', `<= ${byteLength}`, offset);
+    }
+
+    if (length > byteLength - offset) {
+      throw new ERR_OUT_OF_RANGE.HideStackFramesError('length', `<= ${byteLength - offset}`, length);
+    }
+
+    if (length < 0) {
+      throw new ERR_OUT_OF_RANGE.HideStackFramesError('length', '>= 0', length);
+    }
+
+    validateInt32.withoutStackTrace(length, 'length', 0);
+  },
+);
+
+const validatePath = hideStackFrames((path, propName = 'path') => {
+  if (typeof path !== 'string' && !isUint8Array(path)) {
+    throw new ERR_INVALID_ARG_TYPE.HideStackFramesError(propName, ['string', 'Buffer', 'URL'], path);
+  }
+
+  const pathIsString = typeof path === 'string';
+  const pathIsUint8Array = isUint8Array(path);
+
+  // We can only perform meaningful checks on strings and Uint8Arrays.
+  if ((!pathIsString && !pathIsUint8Array) ||
+      (pathIsString && !StringPrototypeIncludes(path, '\u0000')) ||
+      (pathIsUint8Array && !TypedArrayPrototypeIncludes(path, 0))) {
+    return;
+  }
+
+  throw new ERR_INVALID_ARG_VALUE.HideStackFramesError(
+    propName,
+    path,
+    'must be a string, Uint8Array, or URL without null bytes',
+  );
+});
+
+const getValidatedPath = hideStackFrames((fileURLOrPath, propName = 'path') => {
+  const path = toPathIfFileURL(fileURLOrPath);
+  validatePath(path, propName);
+  return path;
+});
+
+const getValidatedFd = hideStackFrames((fd, propName = 'fd') => {
+  if (ObjectIs(fd, -0)) {
+    return 0;
+  }
+
+  validateInt32(fd, propName, 0);
+
+  return fd;
+});
+
+const validateBufferArray = hideStackFrames((buffers, propName = 'buffers') => {
+  if (!ArrayIsArray(buffers))
+    throw new ERR_INVALID_ARG_TYPE.HideStackFramesError(propName, 'ArrayBufferView[]', buffers);
+
+  for (let i = 0; i < buffers.length; i++) {
+    if (!isArrayBufferView(buffers[i]))
+      throw new ERR_INVALID_ARG_TYPE.HideStackFramesError(propName, 'ArrayBufferView[]', buffers);
+  }
+
+  return buffers;
+});
+
+let nonPortableTemplateWarn = true;
+
+function warnOnNonPortableTemplate(template) {
+  // Template strings passed to the mkdtemp() family of functions should not
+  // end with 'X' because they are handled inconsistently across platforms.
+  if (nonPortableTemplateWarn &&
+    ((typeof template === 'string' && StringPrototypeEndsWith(template, 'X')) ||
+    (typeof template !== 'string' && TypedArrayPrototypeAt(template, -1) === 0x58))) {
+    process.emitWarning('mkdtemp() templates ending with X are not portable. ' +
+                        'For details see: https://nodejs.org/api/fs.html');
+    nonPortableTemplateWarn = false;
+  }
+}
+
+const defaultCpOptions = {
+  dereference: false,
+  errorOnExist: false,
+  filter: undefined,
+  force: true,
+  preserveTimestamps: false,
+  recursive: false,
+  verbatimSymlinks: false,
+};
+
+const defaultRmOptions = {
+  recursive: false,
+  force: false,
+  retryDelay: 100,
+  maxRetries: 0,
+};
+
+const validateCpOptions = hideStackFrames((options) => {
+  if (options === undefined)
+    return { ...defaultCpOptions };
+  validateObject(options, 'options');
+  options = { ...defaultCpOptions, ...options };
+  validateBoolean(options.dereference, 'options.dereference');
+  validateBoolean(options.errorOnExist, 'options.errorOnExist');
+  validateBoolean(options.force, 'options.force');
+  validateBoolean(options.preserveTimestamps, 'options.preserveTimestamps');
+  validateBoolean(options.recursive, 'options.recursive');
+  validateBoolean(options.verbatimSymlinks, 'options.verbatimSymlinks');
+  options.mode = getValidMode(options.mode, 'copyFile');
+  if (options.dereference === true && options.verbatimSymlinks === true) {
+    throw new ERR_INCOMPATIBLE_OPTION_PAIR.HideStackFramesError('dereference', 'verbatimSymlinks');
+  }
+  if (options.filter !== undefined) {
+    validateFunction(options.filter, 'options.filter');
+  }
+  return options;
+});
+
+const validateRmOptions = hideStackFrames((path, options, expectDir, cb) => {
+  options = validateRmdirOptions(options, defaultRmOptions);
+  validateBoolean.withoutStackTrace(options.force, 'options.force');
+  validateBoolean.withoutStackTrace(options.recursive, 'options.recursive');
+  validateInt32.withoutStackTrace(options.retryDelay, 'options.retryDelay', 0);
+  validateUint32.withoutStackTrace(options.maxRetries, 'options.maxRetries');
+
+  lazyLoadFs().lstat(path, (err, stats) => {
+    if (err) {
+      if (options.force && err.code === 'ENOENT') {
+        return cb(null, options);
+      }
+      return cb(err, options);
+    }
+
+    if (expectDir && !stats.isDirectory()) {
+      return cb(false);
+    }
+
+    if (stats.isDirectory() && !options.recursive) {
+      const err = new ERR_FS_EISDIR.HideStackFramesError({
+        code: 'EISDIR',
+        message: 'is a directory',
+        path,
+        syscall: 'rm',
+        errno: EISDIR,
+      });
+
+      return cb(err);
+    }
+    return cb(null, options);
+  });
+});
+
+const validateRmOptionsSync = hideStackFrames((path, options, expectDir) => {
+  options = validateRmdirOptions.withoutStackTrace(options, defaultRmOptions);
+  validateBoolean.withoutStackTrace(options.force, 'options.force');
+  validateBoolean.withoutStackTrace(options.recursive, 'options.recursive');
+  validateInt32.withoutStackTrace(options.retryDelay, 'options.retryDelay', 0);
+  validateUint32.withoutStackTrace(options.maxRetries, 'options.maxRetries');
+
+
+  if (!options.force || expectDir || !options.recursive) {
+    const isDirectory = lazyLoadFs()
+      .lstatSync(path, { throwIfNoEntry: !options.force })?.isDirectory();
+
+    if (expectDir && !isDirectory) {
+      return false;
+    }
+
+    if (isDirectory && !options.recursive) {
+      throw new ERR_FS_EISDIR.HideStackFramesError({
+        code: 'EISDIR',
+        message: 'is a directory',
+        path,
+        syscall: 'rm',
+        errno: EISDIR,
+      });
+    }
+  }
+
+  return options;
+});
+
+const validateRmdirOptions = hideStackFrames(
+  (options, defaults = { __proto__: null }) => {
+    if (options === undefined)
+      return defaults;
+    validateObject.withoutStackTrace(options, 'options');
+
+    options = { ...defaults, ...options };
+
+    return options;
+  });
+
+const getValidMode = hideStackFrames((mode, type) => {
+  let min = kMinimumAccessMode;
+  let max = kMaximumAccessMode;
+  let def = F_OK;
+  if (type === 'copyFile') {
+    min = kMinimumCopyMode;
+    max = kMaximumCopyMode;
+    def = mode || kDefaultCopyMode;
+  } else {
+    assert(type === 'access');
+  }
+  if (mode == null) {
+    return def;
+  }
+  validateInteger.withoutStackTrace(mode, 'mode', min, max);
+  return mode;
+});
+
+const validateStringAfterArrayBufferView = hideStackFrames((buffer, name) => {
+  if (typeof buffer !== 'string') {
+    throw new ERR_INVALID_ARG_TYPE.HideStackFramesError(
+      name,
+      ['string', 'Buffer', 'TypedArray', 'DataView'],
+      buffer,
+    );
+  }
+});
+
+const validatePosition = hideStackFrames((position, name, length) => {
+  if (typeof position === 'number') {
+    validateInteger.withoutStackTrace(position, name, -1);
+  } else if (typeof position === 'bigint') {
+    const maxPosition = 2n ** 63n - 1n - BigInt(length);
+    if (!(position >= -1n && position <= maxPosition)) {
+      throw new ERR_OUT_OF_RANGE.HideStackFramesError(name,
+                                                      `>= -1 && <= ${maxPosition}`,
+                                                      position);
+    }
+  } else {
+    throw new ERR_INVALID_ARG_TYPE.HideStackFramesError(name, ['integer', 'bigint'], position);
+  }
+});
+
+module.exports = {
+  constants: {
+    kIoMaxLength,
+    kMaxUserId,
+    kReadFileBufferLength,
+    kReadFileUnknownBufferLength,
+    kWriteFileMaxChunkSize,
+  },
+  assertEncoding,
+  BigIntStats,  // for testing
+  copyObject,
+  Dirent,
+  DirentFromStats,
+  getDirent,
+  getDirents,
+  getOptions,
+  getValidatedFd,
+  getValidatedPath,
+  handleErrorFromBinding,
+  preprocessSymlinkDestination,
+  realpathCacheKey: Symbol('realpathCacheKey'),
+  getStatFsFromBinding,
+  getStatsFromBinding,
+  stringToFlags,
+  stringToSymlinkType,
+  Stats: deprecate(Stats, 'fs.Stats constructor is deprecated.', 'DEP0180'),
+  toUnixTimestamp,
+  validateBufferArray,
+  validateCpOptions,
+  validateOffsetLengthRead,
+  validateOffsetLengthWrite,
+  validatePath,
+  validatePosition,
+  validateRmOptions,
+  validateRmOptionsSync,
+  validateRmdirOptions,
+  validateStringAfterArrayBufferView,
+  warnOnNonPortableTemplate,
+};
diff --git a/test/js/node/test/common/nodeinternals/internal/socket_list.js b/test/js/node/test/common/nodeinternals/internal/socket_list.js
new file mode 100644
index 000000000000..9949a6cde47a
--- /dev/null
+++ b/test/js/node/test/common/nodeinternals/internal/socket_list.js
@@ -0,0 +1,108 @@
+'use strict';
+
+const { ERR_CHILD_CLOSED_BEFORE_REPLY } = require('internal/errors').codes;
+
+const EventEmitter = require('events');
+
+// This object keeps track of the sockets that are sent
+class SocketListSend extends EventEmitter {
+  constructor(child, key) {
+    super();
+    this.key = key;
+    this.child = child;
+    child.once('exit', () => this.emit('exit', this));
+  }
+
+  _request(msg, cmd, swallowErrors, callback) {
+    const self = this;
+
+    if (!this.child.connected) return onclose();
+    this.child._send(msg, undefined, swallowErrors);
+
+    function onclose() {
+      self.child.removeListener('internalMessage', onreply);
+      callback(new ERR_CHILD_CLOSED_BEFORE_REPLY());
+    }
+
+    function onreply(msg) {
+      if (!(msg.cmd === cmd && msg.key === self.key)) return;
+      self.child.removeListener('disconnect', onclose);
+      self.child.removeListener('internalMessage', onreply);
+
+      callback(null, msg);
+    }
+
+    this.child.once('disconnect', onclose);
+    this.child.on('internalMessage', onreply);
+  }
+
+  close(callback) {
+    this._request({
+      cmd: 'NODE_SOCKET_NOTIFY_CLOSE',
+      key: this.key,
+    }, 'NODE_SOCKET_ALL_CLOSED', true, callback);
+  }
+
+  getConnections(callback) {
+    this._request({
+      cmd: 'NODE_SOCKET_GET_COUNT',
+      key: this.key,
+    }, 'NODE_SOCKET_COUNT', false, (err, msg) => {
+      if (err) return callback(err);
+      callback(null, msg.count);
+    });
+  }
+}
+
+
+// This object keeps track of the sockets that are received
+class SocketListReceive extends EventEmitter {
+  constructor(child, key) {
+    super();
+
+    this.connections = 0;
+    this.key = key;
+    this.child = child;
+
+    function onempty(self) {
+      if (!self.child.connected) return;
+
+      self.child._send({
+        cmd: 'NODE_SOCKET_ALL_CLOSED',
+        key: self.key,
+      }, undefined, true);
+    }
+
+    this.child.on('internalMessage', (msg) => {
+      if (msg.key !== this.key) return;
+
+      if (msg.cmd === 'NODE_SOCKET_NOTIFY_CLOSE') {
+        // Already empty
+        if (this.connections === 0) return onempty(this);
+
+        // Wait for sockets to get closed
+        this.once('empty', onempty);
+      } else if (msg.cmd === 'NODE_SOCKET_GET_COUNT') {
+        if (!this.child.connected) return;
+        this.child._send({
+          cmd: 'NODE_SOCKET_COUNT',
+          key: this.key,
+          count: this.connections,
+        });
+      }
+    });
+  }
+
+  add(obj) {
+    this.connections++;
+
+    // Notify the previous owner of the socket about its state change
+    obj.socket.once('close', () => {
+      this.connections--;
+
+      if (this.connections === 0) this.emit('empty', this);
+    });
+  }
+}
+
+module.exports = { SocketListSend, SocketListReceive };
diff --git a/test/js/node/test/common/nodeinternals/internal/webidl.js b/test/js/node/test/common/nodeinternals/internal/webidl.js
new file mode 100644
index 000000000000..13575d4f730d
--- /dev/null
+++ b/test/js/node/test/common/nodeinternals/internal/webidl.js
@@ -0,0 +1,1087 @@
+'use strict';
+
+const {
+  ArrayBufferIsView,
+  ArrayBufferPrototypeGetResizable,
+  ArrayIsArray,
+  ArrayPrototypePush,
+  ArrayPrototypeToSorted,
+  BigInt,
+  DataViewPrototypeGetBuffer,
+  FunctionPrototypeCall,
+  MathAbs,
+  MathMax,
+  MathMin,
+  MathPow,
+  MathSign,
+  MathTrunc,
+  Number,
+  NumberIsFinite,
+  NumberIsNaN,
+  NumberMAX_SAFE_INTEGER,
+  NumberMIN_SAFE_INTEGER,
+  ObjectPrototypeIsPrototypeOf,
+  SafeArrayIterator,
+  SafeSet,
+  String,
+  SymbolIterator,
+  TypeError,
+  TypedArrayPrototypeGetBuffer,
+  TypedArrayPrototypeGetSymbolToStringTag,
+} = primordials;
+
+const { kEmptyObject, setOwnProperty } = require('internal/util');
+const {
+  isSharedArrayBuffer,
+  isTypedArray,
+} = require('internal/util/types');
+
+const BIGINT_2_63 = 1n << 63n;
+const BIGINT_2_64 = 1n << 64n;
+
+const converters = { __proto__: null };
+
+/**
+ * @typedef {object} ConversionOptions
+ * @property {string} [prefix] Message prefix for operation failures.
+ * @property {string} [context] Message context for the converted value.
+ * @property {string} [code] Node.js error code to assign to TypeError.
+ * @property {boolean} [enforceRange] Web IDL [EnforceRange] attribute.
+ * @property {boolean} [clamp] Web IDL [Clamp] attribute.
+ * @property {boolean} [allowShared] Web IDL [AllowShared] attribute for
+ *   buffer view types.
+ * @property {boolean} [allowResizable] Web IDL [AllowResizable] attribute.
+ */
+
+/**
+ * @callback Converter
+ * @param {any} V JavaScript value to convert to an IDL value.
+ * @param {ConversionOptions} [options] Conversion options.
+ * @returns {any}
+ */
+
+/**
+ * @callback DictionaryMemberValidator
+ * @param {any} idlMemberValue Converted IDL member value.
+ * @param {object} jsDict Original JavaScript dictionary object.
+ * @returns {void}
+ */
+
+/**
+ * @typedef {object} DictionaryMember
+ * @property {string} key Dictionary member identifier.
+ * @property {Converter} converter Converter for the member type.
+ * @property {boolean} [required] Whether the member is required.
+ * @property {() => any} [defaultValue] Function returning the default value.
+ * @property {DictionaryMemberValidator} [validator] Optional Node.js
+ *   extension point invoked after conversion and before storing the member.
+ *   This is for early semantic validation of known unsupported IDL values,
+ *   especially in Web Crypto, where SubtleCrypto.supports() needs to answer
+ *   from normalized dictionaries without running the requested operation.
+ */
+
+/**
+ * Creates a TypeError with a Node.js error code.
+ * @param {string} message Error message.
+ * @param {string} code Node.js error code to assign.
+ * @returns {TypeError}
+ */
+function codedTypeError(message, code) {
+  // eslint-disable-next-line no-restricted-syntax
+  const err = new TypeError(message);
+  setOwnProperty(err, 'code', code);
+  return err;
+}
+
+/**
+ * Creates the exception thrown by Web IDL converters.
+ * @param {string} message Unprefixed conversion failure message.
+ * @param {ConversionOptions} [options] Conversion options.
+ * @returns {TypeError}
+ */
+function makeException(message, options = kEmptyObject) {
+  const prefix = options.prefix ? options.prefix + ': ' : '';
+  const context = options.context?.length === 0 ?
+    '' : (options.context ?? 'Value') + ' ';
+  return codedTypeError(
+    `${prefix}${context}${message}`,
+    options.code || 'ERR_INVALID_ARG_TYPE',
+  );
+}
+
+/**
+ * Builds derived conversion options for nested converter calls and adjusted
+ * error codes. These objects are allocated on dictionary/sequence conversion
+ * hot paths, so keep their shape stable and avoid object spread and
+ * null-prototype objects.
+ * @param {ConversionOptions} options Parent conversion options.
+ * @param {string} [context] Replacement context.
+ * @param {string} [code] Replacement error code.
+ * @returns {ConversionOptions}
+ */
+function makeOptions(options, context = options.context, code = options.code) {
+  return {
+    prefix: options.prefix,
+    context,
+    code,
+    enforceRange: options.enforceRange,
+    clamp: options.clamp,
+    allowShared: options.allowShared,
+    allowResizable: options.allowResizable,
+  };
+}
+
+/**
+ * Returns the ECMAScript specification type of a JavaScript value.
+ * @see https://tc39.es/ecma262/#sec-ecmascript-data-types-and-values
+ * @param {any} V JavaScript value.
+ * @returns {'Undefined'|'Null'|'Boolean'|'String'|'Symbol'|'Number'|'BigInt'|'Object'}
+ */
+function type(V) {
+  // ECMA-262 6.1: map JavaScript values to language type names.
+  switch (typeof V) {
+    case 'undefined':
+      return 'Undefined';
+    case 'boolean':
+      return 'Boolean';
+    case 'string':
+      return 'String';
+    case 'symbol':
+      return 'Symbol';
+    case 'number':
+      return 'Number';
+    case 'bigint':
+      return 'BigInt';
+    case 'object':
+    case 'function':
+    default:
+      // ECMA-262 6.1.2: null is its own language type.
+      // ECMA-262 6.1.7: functions are Object values.
+      if (V === null) {
+        return 'Null';
+      }
+      return 'Object';
+  }
+}
+
+/**
+ * Returns IntegerPart(n).
+ * @see https://webidl.spec.whatwg.org/#abstract-opdef-integerpart
+ * @param {number} n Numeric value.
+ * @returns {number}
+ */
+function integerPart(n) {
+  // Web IDL IntegerPart steps 1-3: floor(abs(n)), restore the sign,
+  // and choose +0 rather than -0.
+  const integer = MathTrunc(n);
+  return integer === 0 ? 0 : integer;
+}
+
+/**
+ * Rounds to the nearest integer, choosing the even integer on ties.
+ * @param {number} x Numeric value.
+ * @returns {number}
+ */
+function evenRound(x) {
+  // Web IDL ConvertToInt step 7.2: round to the nearest integer,
+  // choosing the even integer on ties and +0 rather than -0.
+  const i = integerPart(x);
+  const remainder = MathAbs(x % 1);
+  const sign = MathSign(x);
+  if (remainder === 0.5) {
+    return i % 2 === 0 ? i : i + sign;
+  }
+  const r = remainder < 0.5 ? i : i + sign;
+  if (r === 0) {
+    return 0;
+  }
+  return r;
+}
+
+/**
+ * Returns 2 to the power of the given exponent.
+ * @param {number} exponent Non-negative integer exponent.
+ * @returns {number}
+ */
+function pow2(exponent) {
+  if (exponent < 31) {
+    return 1 << exponent;
+  }
+  if (exponent === 31) {
+    return 0x8000_0000;
+  }
+  if (exponent === 32) {
+    return 0x1_0000_0000;
+  }
+  return MathPow(2, exponent);
+}
+
+/**
+ * Returns x modulo y for Web IDL ConvertToInt step 10.
+ *
+ * This is intentionally not a general modulo helper. ConvertToInt only calls
+ * it with a positive power-of-two modulus, and the implementation assumes
+ * that. It converts JavaScript remainder into mathematical modulo and
+ * normalizes -0 to +0.
+ * @param {number} x Dividend.
+ * @param {number} y Positive divisor.
+ * @returns {number}
+ */
+function modulo(x, y) {
+  // Web IDL ConvertToInt step 10 uses mathematical modulo.
+  const r = x % y;
+  if (r === 0) {
+    return 0;
+  }
+  return r > 0 ? r : r + y;
+}
+
+/**
+ * Returns x modulo y for Web IDL ConvertToInt step 10.
+ *
+ * This is intentionally not a general modulo helper. ConvertToInt only calls
+ * it with a positive power-of-two modulus, and the implementation assumes
+ * that. BigInt has no -0, but this mirrors modulo()'s mathematical modulo
+ * behavior for the 64-bit path.
+ * @param {bigint} x Dividend.
+ * @param {bigint} y Positive divisor.
+ * @returns {bigint}
+ */
+function bigIntModulo(x, y) {
+  // Web IDL ConvertToInt step 10 uses mathematical modulo.
+  const r = x % y;
+  return r >= 0n ? r : r + y;
+}
+
+/**
+ * Returns ToNumber(V).
+ * @see https://tc39.es/ecma262/#sec-tonumber
+ * @param {any} V JavaScript value.
+ * @param {ConversionOptions} [options] Conversion options.
+ * @returns {number}
+ */
+function toNumber(V, options = kEmptyObject) {
+  if (typeof V === 'bigint') {
+    // ECMA-262 ToNumber step 2: BigInt values throw.
+    throw makeException(
+      'is a BigInt and cannot be converted to a number.',
+      options);
+  }
+  if (typeof V === 'symbol') {
+    // ECMA-262 ToNumber step 2: Symbol values throw.
+    throw makeException(
+      'is a Symbol and cannot be converted to a number.',
+      options);
+  }
+
+  // Unary plus performs ToNumber, including ToPrimitive(V, number) for
+  // objects. Number(V) is not equivalent because it converts BigInt values,
+  // including BigInt values produced by ToPrimitive.
+  // Abrupt completions and native TypeErrors propagate unchanged. This is an
+  // intentional diagnostics tradeoff: decorating object conversion failures
+  // would require maintaining local ECMA-262 ToPrimitive and
+  // OrdinaryToPrimitive implementations.
+  return +V;
+}
+
+/**
+ * Returns ToString(V).
+ * @see https://tc39.es/ecma262/#sec-tostring
+ * @param {any} V JavaScript value.
+ * @param {ConversionOptions} [options] Conversion options.
+ * @returns {string}
+ */
+function toString(V, options = kEmptyObject) {
+  if (typeof V === 'symbol') {
+    // ECMA-262 ToString step 2: Symbol values throw.
+    throw makeException(
+      'is a Symbol and cannot be converted to a string.',
+      options);
+  }
+
+  // The String function performs ToString for all non-Symbol primitives and
+  // objects, including ToPrimitive(V, string). String concatenation is not
+  // equivalent because it uses ToPrimitive(V, default). Abrupt completions
+  // and native TypeErrors propagate unchanged. This is an intentional
+  // diagnostics tradeoff: decorating object conversion failures would require
+  // maintaining local ECMA-262 ToPrimitive and OrdinaryToPrimitive
+  // implementations.
+  return String(V);
+}
+
+/**
+ * Converts a JavaScript value to a Web IDL integer value.
+ * @see https://webidl.spec.whatwg.org/#abstract-opdef-converttoint
+ * @param {any} V JavaScript value.
+ * @param {number} bitLength Integer bit length.
+ * @param {'signed'|'unsigned'} [signedness] Integer signedness.
+ * @param {ConversionOptions} [options] Conversion options.
+ * @returns {number}
+ */
+function convertToInt(
+  V,
+  bitLength,
+  signedness = 'unsigned',
+  options = kEmptyObject,
+) {
+  const signed = signedness === 'signed';
+  let upperBound;
+  let lowerBound;
+
+  // Web IDL ConvertToInt steps 1-3: determine lower/upper bounds.
+  if (bitLength === 64) {
+    // Steps 1.1-1.3 set upperBound to 2^53 - 1 and lowerBound to 0
+    // for unsigned, or -2^53 + 1 for signed. This ensures 64-bit
+    // integer types associated with [EnforceRange] or [Clamp] are
+    // representable in JavaScript's Number type as unambiguous integers.
+    upperBound = NumberMAX_SAFE_INTEGER;
+    lowerBound = signed ? NumberMIN_SAFE_INTEGER : 0;
+  } else if (!signed) {
+    // Spell out the common Web IDL integer sizes so hot converters avoid
+    // recomputing powers of two on every call.
+    lowerBound = 0;
+    if (bitLength === 8) {
+      upperBound = 0xff;
+    } else if (bitLength === 16) {
+      upperBound = 0xffff;
+    } else if (bitLength === 32) {
+      upperBound = 0xffff_ffff;
+    } else {
+      upperBound = pow2(bitLength) - 1;
+    }
+  } else if (bitLength === 8) {
+    // Signed 8/16/32-bit conversions are mostly exercised through direct
+    // convertToInt() calls, but keep their common bounds cheap too.
+    lowerBound = -0x80;
+    upperBound = 0x7f;
+  } else if (bitLength === 16) {
+    lowerBound = -0x8000;
+    upperBound = 0x7fff;
+  } else if (bitLength === 32) {
+    lowerBound = -0x8000_0000;
+    upperBound = 0x7fff_ffff;
+  } else {
+    lowerBound = -pow2(bitLength - 1);
+    upperBound = pow2(bitLength - 1) - 1;
+  }
+
+  // Common case: primitive Number values that already fit the Web IDL
+  // range and have no fractional part are returned unchanged by every
+  // ConvertToInt path, except that -0 must become +0. This skips the
+  // generic ToNumber and option handling without skipping observable
+  // object coercion.
+  let x;
+  if (typeof V === 'number') {
+    // For primitive Numbers, in-range non-[Clamp] conversion is either
+    // identity or IntegerPart(V). This keeps the default and [EnforceRange]
+    // paths out of the generic ToNumber/options flow.
+    if (V >= lowerBound && V <= upperBound) {
+      const integer = MathTrunc(V);
+      if (integer === V) {
+        return V === 0 ? 0 : V;
+      }
+      if (options !== kEmptyObject && options.clamp) {
+        return evenRound(V);
+      }
+      return integer === 0 ? 0 : integer;
+    }
+    if (options !== kEmptyObject && options.enforceRange) {
+      // Keep [EnforceRange] ahead of [Clamp] without falling through to
+      // the shared check, which would observe options.enforceRange again.
+      if (!NumberIsFinite(V)) {
+        throw makeException(
+          'is not a finite number.',
+          options);
+      }
+
+      const integer = integerPart(V);
+      if (integer < lowerBound || integer > upperBound) {
+        throw makeException(
+          `is outside the expected range of ${lowerBound} to ${upperBound}.`,
+          makeOptions(options, options.context, 'ERR_OUT_OF_RANGE'));
+      }
+
+      return integer;
+    }
+    if (options !== kEmptyObject && options.clamp && !NumberIsNaN(V)) {
+      // Out-of-range [Clamp] returns one of the already-computed bounds.
+      if (V <= lowerBound) {
+        return lowerBound === 0 ? 0 : lowerBound;
+      }
+      if (V >= upperBound) {
+        return upperBound === 0 ? 0 : upperBound;
+      }
+    }
+    x = V;
+  } else {
+    // Step 4: convert V with ECMA-262 ToNumber.
+    x = toNumber(V, options);
+  }
+  // Step 5: normalize -0 to +0.
+  if (x === 0) {
+    x = 0;
+  }
+
+  // Step 6: [EnforceRange] rejects non-finite and out-of-range values.
+  if (options.enforceRange) {
+    // Step 6.1: reject NaN and infinities.
+    if (!NumberIsFinite(x)) {
+      throw makeException(
+        'is not a finite number.',
+        options);
+    }
+
+    // Step 6.2: truncate to IntegerPart(x).
+    x = integerPart(x);
+
+    // Steps 6.3-6.4: reject out-of-range values, otherwise return.
+    if (x < lowerBound || x > upperBound) {
+      throw makeException(
+        `is outside the expected range of ${lowerBound} to ${upperBound}.`,
+        makeOptions(options, options.context, 'ERR_OUT_OF_RANGE'));
+    }
+
+    return x;
+  }
+
+  // Step 7: [Clamp] clamps, rounds, and returns non-NaN values.
+  if (options.clamp && !NumberIsNaN(x)) {
+    // Step 7.1: clamp x into the supported bounds.
+    x = MathMin(MathMax(x, lowerBound), upperBound);
+    // Steps 7.2-7.3: round ties to even and return.
+    return evenRound(x);
+  }
+
+  // Step 8: NaN, +0, -0, and infinities become +0.
+  if (!NumberIsFinite(x) || x === 0) {
+    return 0;
+  }
+
+  // Step 9: truncate to IntegerPart(x).
+  x = integerPart(x);
+
+  // Steps 10-12 are an identity for values already in the step 1-3
+  // bounds. For 64-bit conversions this only skips the safe-integer
+  // subset; values outside it still need exact BigInt modulo and the
+  // final Number approximation.
+  if (x >= lowerBound && x <= upperBound) {
+    return x;
+  }
+
+  if (bitLength === 64) {
+    // Steps 10-12 still wrap over the full 2^64 IDL integer range.
+    // BigInt keeps x modulo 2^64 and the signed high-bit adjustment exact
+    // before this helper returns the JavaScript binding result.
+    let xBigInt = BigInt(x);
+    xBigInt = bigIntModulo(xBigInt, BIGINT_2_64);
+
+    // For long long and unsigned long long values outside the safe-integer
+    // range, Web IDL says the JS Number value represents the closest numeric
+    // value, choosing the value with an even significand if there are two
+    // equally close values. Number(BigInt) performs that final approximation.
+
+    // Step 11: wrap into the signed range when the high bit is set.
+    if (signed && xBigInt >= BIGINT_2_63) {
+      return Number(xBigInt - BIGINT_2_64);
+    }
+
+    // Step 12: return the unsigned value.
+    return Number(xBigInt);
+  }
+
+  // For 8/16/32-bit conversions, bitwise operators perform the same
+  // power-of-two wrapping as Web IDL step 10 for finite integer Numbers.
+  // The shifts narrow the unsigned value into the signed range when needed.
+  if (bitLength === 8) {
+    return signed ? (x << 24) >> 24 : x & 0xff;
+  }
+  if (bitLength === 16) {
+    return signed ? (x << 16) >> 16 : x & 0xffff;
+  }
+  if (bitLength === 32) {
+    return signed ? x | 0 : x >>> 0;
+  }
+
+  // Step 10: reduce modulo 2^bitLength.
+  const twoToTheBitLength = pow2(bitLength);
+  x = modulo(x, twoToTheBitLength);
+
+  // Step 11: wrap into the signed range when the high bit is set.
+  if (signed && x >= pow2(bitLength - 1)) {
+    return x - twoToTheBitLength;
+  }
+
+  // Step 12: return the unsigned value.
+  return x;
+}
+
+/**
+ * Creates a converter for a Web IDL integer type.
+ * @param {number} bitLength Integer bit length.
+ * @param {'signed'|'unsigned'} [signedness] Integer signedness.
+ * @returns {Converter}
+ */
+function createIntegerConverter(bitLength, signedness = 'unsigned') {
+  return (V, options = kEmptyObject) => {
+    // Integer conversion step 1 calls ConvertToInt; step 2 returns
+    // the IDL value with the same numeric value.
+    return convertToInt(V, bitLength, signedness, options);
+  };
+}
+
+/**
+ * Converts a JavaScript value to the IDL boolean type.
+ * @see https://webidl.spec.whatwg.org/#es-boolean
+ * @param {any} V JavaScript value.
+ * @returns {boolean}
+ */
+converters.boolean = (V) => {
+  // Web IDL boolean steps 1-2: ToBoolean(V), then return the same
+  // truth value as an IDL boolean.
+  return !!V;
+};
+
+/**
+ * Converts a JavaScript value to the IDL object type.
+ * @see https://webidl.spec.whatwg.org/#es-object
+ * @param {any} V JavaScript value.
+ * @param {ConversionOptions} [options] Conversion options.
+ * @returns {object|Function}
+ */
+converters.object = (V, options = kEmptyObject) => {
+  // Web IDL object step 1: throw unless V is an ECMA-262 Object.
+  if (type(V) !== 'Object') {
+    throw makeException(
+      'is not an object.',
+      options,
+    );
+  }
+  // Step 2: return a reference to the same object.
+  return V;
+};
+
+/**
+ * Converts a JavaScript value to the IDL octet type.
+ * @see https://webidl.spec.whatwg.org/#es-octet
+ * @type {Converter}
+ */
+converters.octet = createIntegerConverter(8);
+
+/**
+ * Converts a JavaScript value to the IDL unsigned short type.
+ * @see https://webidl.spec.whatwg.org/#es-unsigned-short
+ * @type {Converter}
+ */
+converters['unsigned short'] = createIntegerConverter(16);
+
+/**
+ * Converts a JavaScript value to the IDL unsigned long type.
+ * @see https://webidl.spec.whatwg.org/#es-unsigned-long
+ * @type {Converter}
+ */
+converters['unsigned long'] = createIntegerConverter(32);
+
+/**
+ * Converts a JavaScript value to the IDL long long type.
+ * @see https://webidl.spec.whatwg.org/#es-long-long
+ * @type {Converter}
+ */
+converters['long long'] = createIntegerConverter(64, 'signed');
+
+/**
+ * Converts a JavaScript value to the IDL DOMString type.
+ * @see https://webidl.spec.whatwg.org/#es-DOMString
+ * @param {any} V JavaScript value.
+ * @param {ConversionOptions} [options] Conversion options.
+ * @returns {string}
+ */
+converters.DOMString = function DOMString(V, options = kEmptyObject) {
+  // Step 1 only applies to [LegacyNullToEmptyString], which this core
+  // converter does not implement. Steps 2-3 apply ToString(V) and
+  // return a DOMString with the same code units.
+  return toString(V, options);
+};
+
+/**
+ * Throws when a Web IDL operation receives too few arguments.
+ * @param {number} length Actual argument count.
+ * @param {number} required Required argument count.
+ * @param {ConversionOptions} [options] Conversion options.
+ * @returns {void}
+ */
+function requiredArguments(length, required, options = kEmptyObject) {
+  if (length < required) {
+    throw makeException(
+      `${required} argument${
+        required === 1 ? '' : 's'
+      } required, but only ${length} present.`,
+      makeOptions(options, '', 'ERR_MISSING_ARGS'));
+  }
+}
+
+/**
+ * Creates a converter for a Web IDL enum type.
+ * @see https://webidl.spec.whatwg.org/#es-enumeration
+ * @param {string} name Enum identifier.
+ * @param {string[]} values Enum values.
+ * @returns {Converter}
+ */
+function createEnumConverter(name, values) {
+  const E = new SafeSet(new SafeArrayIterator(values));
+
+  return function(V, options = kEmptyObject) {
+    // Web IDL enumeration step 1: convert V with ToString.
+    const S = toString(V, options);
+
+    // Step 2: throw unless S is one of the enumeration values.
+    if (!E.has(S)) {
+      throw makeException(
+        `'${S}' is not a valid enum value of type ${name}.`,
+        makeOptions(options, options.context, 'ERR_INVALID_ARG_VALUE'));
+    }
+
+    // Step 3: return the matching enumeration value.
+    return S;
+  };
+}
+
+/**
+ * Returns the context used when converting a dictionary member.
+ * @param {string} key Dictionary member identifier.
+ * @param {ConversionOptions} options Conversion options.
+ * @returns {string}
+ */
+function dictionaryMemberContext(key, options) {
+  return options.context ? `${key} in ${options.context}` : key;
+}
+
+/**
+ * Returns the context used when converting a sequence element.
+ * @param {number} index Sequence element index.
+ * @param {ConversionOptions} options Conversion options.
+ * @returns {string}
+ */
+function sequenceElementContext(index, options) {
+  return `${options.context ?? 'Value'}[${index}]`;
+}
+
+/**
+ * Returns the message used for a missing required dictionary member.
+ * @param {string} dictionaryName Dictionary identifier.
+ * @param {string} key Dictionary member identifier.
+ * @returns {string}
+ */
+function missingDictionaryMemberMessage(dictionaryName, key) {
+  return `cannot be converted to '${dictionaryName}' because ` +
+    `'${key}' is required in '${dictionaryName}'.`;
+}
+
+/**
+ * Creates a converter for a Web IDL dictionary type.
+ * @see https://webidl.spec.whatwg.org/#js-dictionary
+ * @param {string} dictionaryName Dictionary identifier.
+ * @param {DictionaryMember[]|DictionaryMember[][]} members Dictionary members,
+ *   either for a single dictionary or grouped from least-derived to
+ *   most-derived dictionary.
+ * @returns {Converter}
+ */
+function createDictionaryConverter(
+  dictionaryName,
+  members,
+) {
+  const compareMembers = (a, b) => {
+    if (a.key === b.key) {
+      return 0;
+    }
+    return a.key < b.key ? -1 : 1;
+  };
+
+  const dictionaries = ArrayIsArray(members[0]) ? members : [members];
+  const sortedDictionaries = [];
+
+  // Web IDL dictionary conversion steps 3-4 process inherited dictionaries
+  // from least-derived to most-derived and sort only within each dictionary.
+  // Callers with inheritance pass one member array per dictionary level.
+  for (let i = 0; i < dictionaries.length; i++) {
+    ArrayPrototypePush(
+      sortedDictionaries,
+      ArrayPrototypeToSorted(dictionaries[i], compareMembers),
+    );
+  }
+
+  return function(jsDict, options = kEmptyObject) {
+    // Step 1: reject non-object, non-null, non-undefined values.
+    if (jsDict != null && type(jsDict) !== 'Object') {
+      throw makeException(
+        'cannot be converted to a dictionary',
+        options,
+      );
+    }
+
+    // Step 2: create the IDL dictionary value.
+    const idlDict = { __proto__: null };
+
+    // Steps 3-4: iterate each dictionary level, then its sorted members.
+    for (let i = 0; i < sortedDictionaries.length; i++) {
+      const sortedMembers = sortedDictionaries[i];
+      for (let j = 0; j < sortedMembers.length; j++) {
+        const member = sortedMembers[j];
+        // Step 4.1.1: get the dictionary member identifier.
+        const key = member.key;
+        // Steps 4.1.2-4.1.3: read the JavaScript member value.
+        const jsMemberValue = jsDict == null ? undefined : jsDict[key];
+
+        // Step 4.1.4: convert and store present member values.
+        if (jsMemberValue !== undefined) {
+          const converter = member.converter;
+          // Step 4.1.4.1: convert the JavaScript value to IDL.
+          const idlMemberValue = converter(
+            jsMemberValue,
+            makeOptions(options, dictionaryMemberContext(key, options)),
+          );
+          // Validators are a Node.js extension after conversion. They let
+          // consumers reject known unsupported values while dictionary
+          // conversion still has precise member context. Web Crypto uses this
+          // so SubtleCrypto.supports() can make accurate decisions from
+          // normalized dictionaries instead of probing by running operations.
+          member.validator?.(idlMemberValue, jsDict);
+          // Step 4.1.4.2: set idlDict[key] to the IDL value.
+          idlDict[key] = idlMemberValue;
+        } else if (typeof member.defaultValue === 'function') {
+          // Step 4.1.5: store the member default value.
+          idlDict[key] = member.defaultValue();
+        } else if (member.required) {
+          // Step 4.1.6: required missing members throw.
+          throw makeException(
+            missingDictionaryMemberMessage(dictionaryName, key),
+            makeOptions(options, options.context, 'ERR_MISSING_OPTION'));
+        }
+      }
+    }
+
+    // Step 5: return the IDL dictionary.
+    return idlDict;
+  };
+}
+
+/**
+ * Creates a converter for a Web IDL sequence type.
+ * @see https://webidl.spec.whatwg.org/#es-sequence
+ * @param {Converter} converter Element converter.
+ * @returns {Converter}
+ */
+function createSequenceConverter(converter) {
+  return function(V, options = kEmptyObject) {
+    // Web IDL sequence conversion step 1: require an ECMA-262 Object.
+    if (type(V) !== 'Object') {
+      throw makeException(
+        'cannot be converted to sequence.',
+        options);
+    }
+
+    // Step 2: GetMethod(V, %Symbol.iterator%).
+    const method = V[SymbolIterator];
+    // Step 3: throw if the iterator method is undefined, null, or not callable.
+    if (typeof method !== 'function') {
+      throw makeException(
+        'cannot be converted to sequence.',
+        options);
+    }
+
+    // Step 4 and create-sequence step 1: get the iterator record.
+    const iterator = FunctionPrototypeCall(method, V);
+    const nextMethod = iterator?.next;
+    if (typeof nextMethod !== 'function') {
+      throw makeException(
+        'cannot be converted to sequence.',
+        options);
+    }
+
+    // Create-sequence step 2: initialize i to 0.
+    const idlSequence = [];
+    while (true) {
+      // Step 3.1: IteratorStepValue(iteratorRecord).
+      const next = FunctionPrototypeCall(nextMethod, iterator);
+      if (type(next) !== 'Object') {
+        throw makeException(
+          'cannot be converted to sequence.',
+          options);
+      }
+      // Step 3.2: IteratorComplete applies ToBoolean(done).
+      if (next.done) {
+        break;
+      }
+      // Step 3.3: convert next to an IDL value of type T.
+      const idlValue = converter(
+        next.value,
+        makeOptions(options, sequenceElementContext(idlSequence.length, options)),
+      );
+      // Step 3.4: store the value and advance i.
+      ArrayPrototypePush(idlSequence, idlValue);
+    }
+    return idlSequence;
+  };
+}
+
+/**
+ * Creates a converter for a Web IDL interface type.
+ * @see https://webidl.spec.whatwg.org/#js-interface
+ * @param {string} name Interface identifier.
+ * @param {object} prototype Interface prototype object.
+ * @returns {Converter}
+ */
+function createInterfaceConverter(name, prototype) {
+  return (V, options = kEmptyObject) => {
+    // Web IDL interface conversion step 1: return V if it implements I.
+    if (ObjectPrototypeIsPrototypeOf(prototype, V)) {
+      return V;
+    }
+    // Step 2: otherwise throw.
+    throw makeException(
+      `is not of type ${name}.`,
+      options);
+  };
+}
+
+/**
+ * Returns the ArrayBuffer or SharedArrayBuffer viewed by a typed array or
+ * DataView.
+ * @param {ArrayBufferView} V TypedArray or DataView.
+ * @returns {ArrayBuffer|SharedArrayBuffer}
+ */
+function getViewedArrayBuffer(V) {
+  // Buffer view conversion steps read V.[[ViewedArrayBuffer]].
+  return isTypedArray(V) ?
+    TypedArrayPrototypeGetBuffer(V) : DataViewPrototypeGetBuffer(V);
+}
+
+/**
+ * Validates [AllowShared] and [AllowResizable] backing-store constraints.
+ * @param {ArrayBuffer|SharedArrayBuffer} buffer Backing buffer.
+ * @param {ConversionOptions} options Conversion options.
+ * @returns {void}
+ */
+function validateBufferSourceBacking(buffer, options) {
+  let resizable;
+  try {
+    // ArrayBuffer.prototype.resizable is an ArrayBuffer brand check and the
+    // [AllowResizable] value we need. For SharedArrayBuffer-backed views it
+    // throws, which lets this path avoid a separate IsSharedArrayBuffer check.
+    // BufferSource has separate inline logic because [AllowShared] cannot be
+    // used with that typedef.
+    resizable = ArrayBufferPrototypeGetResizable(buffer);
+  } catch {
+    // ArrayBufferView conversion step 2: reject SharedArrayBuffer
+    // backing stores unless [AllowShared] is present.
+    if (!options.allowShared) {
+      throw makeException(
+        'is a view on a SharedArrayBuffer, which is not allowed.',
+        options);
+    }
+    // Step 3: reject non-fixed SharedArrayBuffer backing stores unless
+    // [AllowResizable] is present.
+    validateAllowGrowableSharedArrayBuffer(buffer, options);
+    return;
+  }
+
+  // ArrayBuffer conversion step 3 and ArrayBufferView conversion step 3:
+  // reject non-fixed ArrayBuffer backing stores unless [AllowResizable]
+  // is present.
+  validateAllowResizableArrayBuffer(resizable, options);
+}
+
+/**
+ * Validates the [AllowResizable] constraint for growable SharedArrayBuffer.
+ * @param {SharedArrayBuffer} buffer SharedArrayBuffer backing buffer.
+ * @param {ConversionOptions} options Conversion options.
+ * @returns {void}
+ */
+function validateAllowGrowableSharedArrayBuffer(buffer, options) {
+  // SharedArrayBuffer and ArrayBufferView conversion step 3:
+  // IsFixedLengthArrayBuffer(buffer) must be true without [AllowResizable].
+  // Do not use a primordial getter here. When this module is included in the
+  // startup snapshot, an early-captured SharedArrayBuffer.prototype.growable
+  // getter does not detect growable buffers created after deserialization.
+  // Lazily capturing the getter would work, but it would observe the runtime
+  // prototype at first comparison, so it would not be an actual primordial.
+  if (!options.allowResizable && buffer.growable) {
+    throw makeException(
+      'is backed by a growable SharedArrayBuffer, which is not allowed.',
+      options);
+  }
+}
+
+/**
+ * Validates the [AllowResizable] constraint for resizable ArrayBuffer.
+ * @param {boolean} resizable ArrayBuffer [[ArrayBufferResizable]] value.
+ * @param {ConversionOptions} options Conversion options.
+ * @returns {void}
+ */
+function validateAllowResizableArrayBuffer(resizable, options) {
+  // ArrayBuffer and ArrayBufferView conversion step 3:
+  // IsFixedLengthArrayBuffer(buffer) must be true without [AllowResizable].
+  // Read [[ArrayBufferResizable]] first so fixed buffers skip the options
+  // property lookup on this hot path.
+  if (resizable && !options.allowResizable) {
+    throw makeException(
+      'is backed by a resizable ArrayBuffer, which is not allowed.',
+      options);
+  }
+}
+
+/**
+ * Converts a JavaScript value to the IDL Uint8Array type.
+ * @param {any} V JavaScript value.
+ * @param {ConversionOptions} [options] Conversion options.
+ * @returns {Uint8Array}
+ */
+converters.Uint8Array = (V, options = kEmptyObject) => {
+  // Typed array conversion steps 1-2: T is Uint8Array, and V must
+  // have [[TypedArrayName]] equal to "Uint8Array".
+  if (!ArrayBufferIsView(V) ||
+    TypedArrayPrototypeGetSymbolToStringTag(V) !== 'Uint8Array') {
+    throw makeException(
+      'is not an Uint8Array object.',
+      options);
+  }
+  // Steps 3-4: validate [AllowShared] and [AllowResizable].
+  validateBufferSourceBacking(TypedArrayPrototypeGetBuffer(V), options);
+
+  // Step 5: return a reference to the same object.
+  return V;
+};
+
+/**
+ * Converts a JavaScript value to the IDL BufferSource typedef.
+ * @see https://webidl.spec.whatwg.org/#BufferSource
+ * @param {any} V JavaScript value.
+ * @param {ConversionOptions} [options] Conversion options.
+ * @returns {ArrayBuffer|ArrayBufferView<ArrayBuffer>}
+ */
+converters.BufferSource = (V, options = kEmptyObject) => {
+  // BufferSource is a typedef for (ArrayBufferView or ArrayBuffer).
+  // [AllowShared] cannot be used with BufferSource because the ArrayBuffer
+  // union branch does not support it. Use AllowSharedBufferSource instead.
+  if (ArrayBufferIsView(V)) {
+    const buffer = getViewedArrayBuffer(V);
+    // ArrayBufferView conversion steps 2-4: validate the viewed buffer
+    // and return a reference to the same view.
+    // Keep this logic inline instead of calling validateBufferSourceBacking().
+    // BufferSource conversion is hot, and this avoids a helper call while still
+    // using a primordial getter for the backing-buffer internal-slot check.
+    // Unlike validateBufferSourceBacking(), this intentionally ignores
+    // options.allowShared because [AllowShared] cannot be used with
+    // BufferSource.
+    let resizable;
+    try {
+      // ArrayBuffer.prototype.resizable is both the ArrayBuffer brand check
+      // and the step 3 value. It throws for SharedArrayBuffer, which lets this
+      // path reject SAB-backed views without an extra byteLength getter call.
+      resizable = ArrayBufferPrototypeGetResizable(buffer);
+    } catch {
+      throw makeException(
+        'is a view on a SharedArrayBuffer, which is not allowed.',
+        options);
+    }
+    if (resizable && !options.allowResizable) {
+      throw makeException(
+        'is backed by a resizable ArrayBuffer, which is not allowed.',
+        options);
+    }
+    return V;
+  }
+
+  // ArrayBuffer conversion steps 1-2: require a non-shared ArrayBuffer.
+  // Use the primordial resizable getter as both the ArrayBuffer brand check
+  // and the step 3 value. This avoids isArrayBuffer(V) followed by another
+  // getter call, and rejects SharedArrayBuffer on this union branch.
+  let resizable;
+  try {
+    resizable = ArrayBufferPrototypeGetResizable(V);
+  } catch {
+    throw makeException(
+      'is not instance of ArrayBuffer, Buffer, TypedArray, or DataView.',
+      options);
+  }
+
+  // ArrayBuffer conversion step 3: validate [AllowResizable].
+  // ArrayBufferPrototypeGetResizable(V) already excluded SharedArrayBuffer,
+  // so no [AllowShared] validation is needed on this branch.
+  if (resizable && !options.allowResizable) {
+    throw makeException(
+      'is backed by a resizable ArrayBuffer, which is not allowed.',
+      options);
+  }
+
+  // Step 4: return a reference to the same ArrayBuffer.
+  return V;
+};
+
+/**
+ * Converts a JavaScript value to the IDL AllowSharedBufferSource typedef.
+ * @see https://webidl.spec.whatwg.org/#AllowSharedBufferSource
+ * @param {any} V JavaScript value.
+ * @param {ConversionOptions} [options] Conversion options.
+ * @returns {ArrayBuffer|SharedArrayBuffer|ArrayBufferView}
+ */
+converters.AllowSharedBufferSource = (V, options = kEmptyObject) => {
+  // AllowSharedBufferSource is a typedef for
+  // (ArrayBuffer or SharedArrayBuffer or [AllowShared] ArrayBufferView).
+  // The union branches are disjoint, so this keeps the hot view path first.
+  if (ArrayBufferIsView(V)) {
+    const buffer = getViewedArrayBuffer(V);
+    let resizable;
+    try {
+      resizable = ArrayBufferPrototypeGetResizable(buffer);
+    } catch {
+      validateAllowGrowableSharedArrayBuffer(buffer, options);
+      return V;
+    }
+    validateAllowResizableArrayBuffer(resizable, options);
+    return V;
+  }
+
+  let resizable;
+  try {
+    resizable = ArrayBufferPrototypeGetResizable(V);
+  } catch {
+    if (isSharedArrayBuffer(V)) {
+      validateAllowGrowableSharedArrayBuffer(V, options);
+      return V;
+    }
+    throw makeException(
+      'is not instance of ArrayBuffer, SharedArrayBuffer, Buffer, ' +
+      'TypedArray, or DataView.',
+      options);
+  }
+
+  validateAllowResizableArrayBuffer(resizable, options);
+  return V;
+};
+
+/**
+ * Converts a JavaScript value to the IDL sequence<DOMString> type.
+ * @see https://webidl.spec.whatwg.org/#es-sequence
+ * @type {Converter}
+ */
+converters['sequence<DOMString>'] =
+  createSequenceConverter(converters.DOMString);
+
+/**
+ * Converts a JavaScript value to the IDL sequence<object> type.
+ * @see https://webidl.spec.whatwg.org/#es-sequence
+ * @type {Converter}
+ */
+converters['sequence<object>'] =
+  createSequenceConverter(converters.object);
+
+module.exports = {
+  converters,
+  convertToInt,
+  createDictionaryConverter,
+  createEnumConverter,
+  createInterfaceConverter,
+  createSequenceConverter,
+  requiredArguments,
+  type,
+};
diff --git a/test/js/node/test/fixtures/compile-cache-wrapper-options.js b/test/js/node/test/fixtures/compile-cache-wrapper-options.js
new file mode 100644
index 000000000000..3ab73c9028a0
--- /dev/null
+++ b/test/js/node/test/fixtures/compile-cache-wrapper-options.js
@@ -0,0 +1,23 @@
+'use strict';
+
+const { enableCompileCache, getCompileCacheDir, constants } = require('module');
+
+console.log('dir before enableCompileCache:', getCompileCacheDir());
+const options = JSON.parse(process.env.NODE_TEST_COMPILE_CACHE_OPTIONS);
+console.log('options:', options);
+const result = enableCompileCache(options);
+switch (result.status) {
+  case constants.compileCacheStatus.FAILED:
+    console.log('Compile cache failed. ' + result.message);
+    break;
+  case constants.compileCacheStatus.ENABLED:
+    console.log('Compile cache enabled. ' + result.directory);
+    break;
+  case constants.compileCacheStatus.ALREADY_ENABLED:
+    console.log('Compile cache already enabled.');
+    break;
+  case constants.compileCacheStatus.DISABLED:
+    console.log('Compile cache already disabled.');
+    break;
+}
+console.log('dir after enableCompileCache:', getCompileCacheDir());
diff --git a/test/js/node/test/fixtures/encoding/README.md b/test/js/node/test/fixtures/encoding/README.md
new file mode 100644
index 000000000000..be6602bbf696
--- /dev/null
+++ b/test/js/node/test/fixtures/encoding/README.md
@@ -0,0 +1,4 @@
+1. <https://encoding.spec.whatwg.org/>
+2. <https://encoding.spec.whatwg.org/encodings.json>
+3. <https://encoding.spec.whatwg.org/#indexes>
+4. <https://encoding.spec.whatwg.org/#legacy-single-byte-encodings>
diff --git a/test/js/node/test/fixtures/encoding/encodings.json b/test/js/node/test/fixtures/encoding/encodings.json
new file mode 100644
index 000000000000..74019c09603e
--- /dev/null
+++ b/test/js/node/test/fixtures/encoding/encodings.json
@@ -0,0 +1,465 @@
+[
+  {
+    "encodings": [
+      {
+        "labels": [
+          "unicode-1-1-utf-8",
+          "unicode11utf8",
+          "unicode20utf8",
+          "utf-8",
+          "utf8",
+          "x-unicode20utf8"
+        ],
+        "name": "UTF-8"
+      }
+    ],
+    "heading": "The Encoding"
+  },
+  {
+    "encodings": [
+      {
+        "labels": [
+          "866",
+          "cp866",
+          "csibm866",
+          "ibm866"
+        ],
+        "name": "IBM866"
+      },
+      {
+        "labels": [
+          "csisolatin2",
+          "iso-8859-2",
+          "iso-ir-101",
+          "iso8859-2",
+          "iso88592",
+          "iso_8859-2",
+          "iso_8859-2:1987",
+          "l2",
+          "latin2"
+        ],
+        "name": "ISO-8859-2"
+      },
+      {
+        "labels": [
+          "csisolatin3",
+          "iso-8859-3",
+          "iso-ir-109",
+          "iso8859-3",
+          "iso88593",
+          "iso_8859-3",
+          "iso_8859-3:1988",
+          "l3",
+          "latin3"
+        ],
+        "name": "ISO-8859-3"
+      },
+      {
+        "labels": [
+          "csisolatin4",
+          "iso-8859-4",
+          "iso-ir-110",
+          "iso8859-4",
+          "iso88594",
+          "iso_8859-4",
+          "iso_8859-4:1988",
+          "l4",
+          "latin4"
+        ],
+        "name": "ISO-8859-4"
+      },
+      {
+        "labels": [
+          "csisolatincyrillic",
+          "cyrillic",
+          "iso-8859-5",
+          "iso-ir-144",
+          "iso8859-5",
+          "iso88595",
+          "iso_8859-5",
+          "iso_8859-5:1988"
+        ],
+        "name": "ISO-8859-5"
+      },
+      {
+        "labels": [
+          "arabic",
+          "asmo-708",
+          "csiso88596e",
+          "csiso88596i",
+          "csisolatinarabic",
+          "ecma-114",
+          "iso-8859-6",
+          "iso-8859-6-e",
+          "iso-8859-6-i",
+          "iso-ir-127",
+          "iso8859-6",
+          "iso88596",
+          "iso_8859-6",
+          "iso_8859-6:1987"
+        ],
+        "name": "ISO-8859-6"
+      },
+      {
+        "labels": [
+          "csisolatingreek",
+          "ecma-118",
+          "elot_928",
+          "greek",
+          "greek8",
+          "iso-8859-7",
+          "iso-ir-126",
+          "iso8859-7",
+          "iso88597",
+          "iso_8859-7",
+          "iso_8859-7:1987",
+          "sun_eu_greek"
+        ],
+        "name": "ISO-8859-7"
+      },
+      {
+        "labels": [
+          "csiso88598e",
+          "csisolatinhebrew",
+          "hebrew",
+          "iso-8859-8",
+          "iso-8859-8-e",
+          "iso-ir-138",
+          "iso8859-8",
+          "iso88598",
+          "iso_8859-8",
+          "iso_8859-8:1988",
+          "visual"
+        ],
+        "name": "ISO-8859-8"
+      },
+      {
+        "labels": [
+          "csiso88598i",
+          "iso-8859-8-i",
+          "logical"
+        ],
+        "name": "ISO-8859-8-I"
+      },
+      {
+        "labels": [
+          "csisolatin6",
+          "iso-8859-10",
+          "iso-ir-157",
+          "iso8859-10",
+          "iso885910",
+          "l6",
+          "latin6"
+        ],
+        "name": "ISO-8859-10"
+      },
+      {
+        "labels": [
+          "iso-8859-13",
+          "iso8859-13",
+          "iso885913"
+        ],
+        "name": "ISO-8859-13"
+      },
+      {
+        "labels": [
+          "iso-8859-14",
+          "iso8859-14",
+          "iso885914"
+        ],
+        "name": "ISO-8859-14"
+      },
+      {
+        "labels": [
+          "csisolatin9",
+          "iso-8859-15",
+          "iso8859-15",
+          "iso885915",
+          "iso_8859-15",
+          "l9"
+        ],
+        "name": "ISO-8859-15"
+      },
+      {
+        "labels": [
+          "iso-8859-16"
+        ],
+        "name": "ISO-8859-16"
+      },
+      {
+        "labels": [
+          "cskoi8r",
+          "koi",
+          "koi8",
+          "koi8-r",
+          "koi8_r"
+        ],
+        "name": "KOI8-R"
+      },
+      {
+        "labels": [
+          "koi8-ru",
+          "koi8-u"
+        ],
+        "name": "KOI8-U"
+      },
+      {
+        "labels": [
+          "csmacintosh",
+          "mac",
+          "macintosh",
+          "x-mac-roman"
+        ],
+        "name": "macintosh"
+      },
+      {
+        "labels": [
+          "dos-874",
+          "iso-8859-11",
+          "iso8859-11",
+          "iso885911",
+          "tis-620",
+          "windows-874"
+        ],
+        "name": "windows-874"
+      },
+      {
+        "labels": [
+          "cp1250",
+          "windows-1250",
+          "x-cp1250"
+        ],
+        "name": "windows-1250"
+      },
+      {
+        "labels": [
+          "cp1251",
+          "windows-1251",
+          "x-cp1251"
+        ],
+        "name": "windows-1251"
+      },
+      {
+        "labels": [
+          "ansi_x3.4-1968",
+          "ascii",
+          "cp1252",
+          "cp819",
+          "csisolatin1",
+          "ibm819",
+          "iso-8859-1",
+          "iso-ir-100",
+          "iso8859-1",
+          "iso88591",
+          "iso_8859-1",
+          "iso_8859-1:1987",
+          "l1",
+          "latin1",
+          "us-ascii",
+          "windows-1252",
+          "x-cp1252"
+        ],
+        "name": "windows-1252"
+      },
+      {
+        "labels": [
+          "cp1253",
+          "windows-1253",
+          "x-cp1253"
+        ],
+        "name": "windows-1253"
+      },
+      {
+        "labels": [
+          "cp1254",
+          "csisolatin5",
+          "iso-8859-9",
+          "iso-ir-148",
+          "iso8859-9",
+          "iso88599",
+          "iso_8859-9",
+          "iso_8859-9:1989",
+          "l5",
+          "latin5",
+          "windows-1254",
+          "x-cp1254"
+        ],
+        "name": "windows-1254"
+      },
+      {
+        "labels": [
+          "cp1255",
+          "windows-1255",
+          "x-cp1255"
+        ],
+        "name": "windows-1255"
+      },
+      {
+        "labels": [
+          "cp1256",
+          "windows-1256",
+          "x-cp1256"
+        ],
+        "name": "windows-1256"
+      },
+      {
+        "labels": [
+          "cp1257",
+          "windows-1257",
+          "x-cp1257"
+        ],
+        "name": "windows-1257"
+      },
+      {
+        "labels": [
+          "cp1258",
+          "windows-1258",
+          "x-cp1258"
+        ],
+        "name": "windows-1258"
+      },
+      {
+        "labels": [
+          "x-mac-cyrillic",
+          "x-mac-ukrainian"
+        ],
+        "name": "x-mac-cyrillic"
+      }
+    ],
+    "heading": "Legacy single-byte encodings"
+  },
+  {
+    "encodings": [
+      {
+        "labels": [
+          "chinese",
+          "csgb2312",
+          "csiso58gb231280",
+          "gb2312",
+          "gb_2312",
+          "gb_2312-80",
+          "gbk",
+          "iso-ir-58",
+          "x-gbk"
+        ],
+        "name": "GBK"
+      },
+      {
+        "labels": [
+          "gb18030"
+        ],
+        "name": "gb18030"
+      }
+    ],
+    "heading": "Legacy multi-byte Chinese (simplified) encodings"
+  },
+  {
+    "encodings": [
+      {
+        "labels": [
+          "big5",
+          "big5-hkscs",
+          "cn-big5",
+          "csbig5",
+          "x-x-big5"
+        ],
+        "name": "Big5"
+      }
+    ],
+    "heading": "Legacy multi-byte Chinese (traditional) encodings"
+  },
+  {
+    "encodings": [
+      {
+        "labels": [
+          "cseucpkdfmtjapanese",
+          "euc-jp",
+          "x-euc-jp"
+        ],
+        "name": "EUC-JP"
+      },
+      {
+        "labels": [
+          "csiso2022jp",
+          "iso-2022-jp"
+        ],
+        "name": "ISO-2022-JP"
+      },
+      {
+        "labels": [
+          "csshiftjis",
+          "ms932",
+          "ms_kanji",
+          "shift-jis",
+          "shift_jis",
+          "sjis",
+          "windows-31j",
+          "x-sjis"
+        ],
+        "name": "Shift_JIS"
+      }
+    ],
+    "heading": "Legacy multi-byte Japanese encodings"
+  },
+  {
+    "encodings": [
+      {
+        "labels": [
+          "cseuckr",
+          "csksc56011987",
+          "euc-kr",
+          "iso-ir-149",
+          "korean",
+          "ks_c_5601-1987",
+          "ks_c_5601-1989",
+          "ksc5601",
+          "ksc_5601",
+          "windows-949"
+        ],
+        "name": "EUC-KR"
+      }
+    ],
+    "heading": "Legacy multi-byte Korean encodings"
+  },
+  {
+    "encodings": [
+      {
+        "labels": [
+          "csiso2022kr",
+          "hz-gb-2312",
+          "iso-2022-cn",
+          "iso-2022-cn-ext",
+          "iso-2022-kr",
+          "replacement"
+        ],
+        "name": "replacement"
+      },
+      {
+        "labels": [
+          "unicodefffe",
+          "utf-16be"
+        ],
+        "name": "UTF-16BE"
+      },
+      {
+        "labels": [
+          "csunicode",
+          "iso-10646-ucs-2",
+          "ucs-2",
+          "unicode",
+          "unicodefeff",
+          "utf-16",
+          "utf-16le"
+        ],
+        "name": "UTF-16LE"
+      },
+      {
+        "labels": [
+          "x-user-defined"
+        ],
+        "name": "x-user-defined"
+      }
+    ],
+    "heading": "Legacy miscellaneous encodings"
+  }
+]
diff --git a/test/js/node/test/fixtures/encoding/single-byte/index-ibm866.txt b/test/js/node/test/fixtures/encoding/single-byte/index-ibm866.txt
new file mode 100644
index 000000000000..959f60718444
--- /dev/null
+++ b/test/js/node/test/fixtures/encoding/single-byte/index-ibm866.txt
@@ -0,0 +1,134 @@
+# For details on index index-ibm866.txt see the Encoding Standard
+# https://encoding.spec.whatwg.org/
+#
+# Identifier: db6fe14a559d1601a7667338d83704773d5708dbc641e1ad3c5e21405770f05e
+# Date: 2024-09-18
+
+  0	0x0410	А (CYRILLIC CAPITAL LETTER A)
+  1	0x0411	Б (CYRILLIC CAPITAL LETTER BE)
+  2	0x0412	В (CYRILLIC CAPITAL LETTER VE)
+  3	0x0413	Г (CYRILLIC CAPITAL LETTER GHE)
+  4	0x0414	Д (CYRILLIC CAPITAL LETTER DE)
+  5	0x0415	Е (CYRILLIC CAPITAL LETTER IE)
+  6	0x0416	Ж (CYRILLIC CAPITAL LETTER ZHE)
+  7	0x0417	З (CYRILLIC CAPITAL LETTER ZE)
+  8	0x0418	И (CYRILLIC CAPITAL LETTER I)
+  9	0x0419	Й (CYRILLIC CAPITAL LETTER SHORT I)
+ 10	0x041A	К (CYRILLIC CAPITAL LETTER KA)
+ 11	0x041B	Л (CYRILLIC CAPITAL LETTER EL)
+ 12	0x041C	М (CYRILLIC CAPITAL LETTER EM)
+ 13	0x041D	Н (CYRILLIC CAPITAL LETTER EN)
+ 14	0x041E	О (CYRILLIC CAPITAL LETTER O)
+ 15	0x041F	П (CYRILLIC CAPITAL LETTER PE)
+ 16	0x0420	Р (CYRILLIC CAPITAL LETTER ER)
+ 17	0x0421	С (CYRILLIC CAPITAL LETTER ES)
+ 18	0x0422	Т (CYRILLIC CAPITAL LETTER TE)
+ 19	0x0423	У (CYRILLIC CAPITAL LETTER U)
+ 20	0x0424	Ф (CYRILLIC CAPITAL LETTER EF)
+ 21	0x0425	Х (CYRILLIC CAPITAL LETTER HA)
+ 22	0x0426	Ц (CYRILLIC CAPITAL LETTER TSE)
+ 23	0x0427	Ч (CYRILLIC CAPITAL LETTER CHE)
+ 24	0x0428	Ш (CYRILLIC CAPITAL LETTER SHA)
+ 25	0x0429	Щ (CYRILLIC CAPITAL LETTER SHCHA)
+ 26	0x042A	Ъ (CYRILLIC CAPITAL LETTER HARD SIGN)
+ 27	0x042B	Ы (CYRILLIC CAPITAL LETTER YERU)
+ 28	0x042C	Ь (CYRILLIC CAPITAL LETTER SOFT SIGN)
+ 29	0x042D	Э (CYRILLIC CAPITAL LETTER E)
+ 30	0x042E	Ю (CYRILLIC CAPITAL LETTER YU)
+ 31	0x042F	Я (CYRILLIC CAPITAL LETTER YA)
+ 32	0x0430	а (CYRILLIC SMALL LETTER A)
+ 33	0x0431	б (CYRILLIC SMALL LETTER BE)
+ 34	0x0432	в (CYRILLIC SMALL LETTER VE)
+ 35	0x0433	г (CYRILLIC SMALL LETTER GHE)
+ 36	0x0434	д (CYRILLIC SMALL LETTER DE)
+ 37	0x0435	е (CYRILLIC SMALL LETTER IE)
+ 38	0x0436	ж (CYRILLIC SMALL LETTER ZHE)
+ 39	0x0437	з (CYRILLIC SMALL LETTER ZE)
+ 40	0x0438	и (CYRILLIC SMALL LETTER I)
+ 41	0x0439	й (CYRILLIC SMALL LETTER SHORT I)
+ 42	0x043A	к (CYRILLIC SMALL LETTER KA)
+ 43	0x043B	л (CYRILLIC SMALL LETTER EL)
+ 44	0x043C	м (CYRILLIC SMALL LETTER EM)
+ 45	0x043D	н (CYRILLIC SMALL LETTER EN)
+ 46	0x043E	о (CYRILLIC SMALL LETTER O)
+ 47	0x043F	п (CYRILLIC SMALL LETTER PE)
+ 48	0x2591	░ (LIGHT SHADE)
+ 49	0x2592	▒ (MEDIUM SHADE)
+ 50	0x2593	▓ (DARK SHADE)
+ 51	0x2502	│ (BOX DRAWINGS LIGHT VERTICAL)
+ 52	0x2524	┤ (BOX DRAWINGS LIGHT VERTICAL AND LEFT)
+ 53	0x2561	╡ (BOX DRAWINGS VERTICAL SINGLE AND LEFT DOUBLE)
+ 54	0x2562	╢ (BOX DRAWINGS VERTICAL DOUBLE AND LEFT SINGLE)
+ 55	0x2556	╖ (BOX DRAWINGS DOWN DOUBLE AND LEFT SINGLE)
+ 56	0x2555	╕ (BOX DRAWINGS DOWN SINGLE AND LEFT DOUBLE)
+ 57	0x2563	╣ (BOX DRAWINGS DOUBLE VERTICAL AND LEFT)
+ 58	0x2551	║ (BOX DRAWINGS DOUBLE VERTICAL)
+ 59	0x2557	╗ (BOX DRAWINGS DOUBLE DOWN AND LEFT)
+ 60	0x255D	╝ (BOX DRAWINGS DOUBLE UP AND LEFT)
+ 61	0x255C	╜ (BOX DRAWINGS UP DOUBLE AND LEFT SINGLE)
+ 62	0x255B	╛ (BOX DRAWINGS UP SINGLE AND LEFT DOUBLE)
+ 63	0x2510	┐ (BOX DRAWINGS LIGHT DOWN AND LEFT)
+ 64	0x2514	└ (BOX DRAWINGS LIGHT UP AND RIGHT)
+ 65	0x2534	┴ (BOX DRAWINGS LIGHT UP AND HORIZONTAL)
+ 66	0x252C	┬ (BOX DRAWINGS LIGHT DOWN AND HORIZONTAL)
+ 67	0x251C	├ (BOX DRAWINGS LIGHT VERTICAL AND RIGHT)
+ 68	0x2500	─ (BOX DRAWINGS LIGHT HORIZONTAL)
+ 69	0x253C	┼ (BOX DRAWINGS LIGHT VERTICAL AND HORIZONTAL)
+ 70	0x255E	╞ (BOX DRAWINGS VERTICAL SINGLE AND RIGHT DOUBLE)
+ 71	0x255F	╟ (BOX DRAWINGS VERTICAL DOUBLE AND RIGHT SINGLE)
+ 72	0x255A	╚ (BOX DRAWINGS DOUBLE UP AND RIGHT)
+ 73	0x2554	╔ (BOX DRAWINGS DOUBLE DOWN AND RIGHT)
+ 74	0x2569	╩ (BOX DRAWINGS DOUBLE UP AND HORIZONTAL)
+ 75	0x2566	╦ (BOX DRAWINGS DOUBLE DOWN AND HORIZONTAL)
+ 76	0x2560	╠ (BOX DRAWINGS DOUBLE VERTICAL AND RIGHT)
+ 77	0x2550	═ (BOX DRAWINGS DOUBLE HORIZONTAL)
+ 78	0x256C	╬ (BOX DRAWINGS DOUBLE VERTICAL AND HORIZONTAL)
+ 79	0x2567	╧ (BOX DRAWINGS UP SINGLE AND HORIZONTAL DOUBLE)
+ 80	0x2568	╨ (BOX DRAWINGS UP DOUBLE AND HORIZONTAL SINGLE)
+ 81	0x2564	╤ (BOX DRAWINGS DOWN SINGLE AND HORIZONTAL DOUBLE)
+ 82	0x2565	╥ (BOX DRAWINGS DOWN DOUBLE AND HORIZONTAL SINGLE)
+ 83	0x2559	╙ (BOX DRAWINGS UP DOUBLE AND RIGHT SINGLE)
+ 84	0x2558	╘ (BOX DRAWINGS UP SINGLE AND RIGHT DOUBLE)
+ 85	0x2552	╒ (BOX DRAWINGS DOWN SINGLE AND RIGHT DOUBLE)
+ 86	0x2553	╓ (BOX DRAWINGS DOWN DOUBLE AND RIGHT SINGLE)
+ 87	0x256B	╫ (BOX DRAWINGS VERTICAL DOUBLE AND HORIZONTAL SINGLE)
+ 88	0x256A	╪ (BOX DRAWINGS VERTICAL SINGLE AND HORIZONTAL DOUBLE)
+ 89	0x2518	┘ (BOX DRAWINGS LIGHT UP AND LEFT)
+ 90	0x250C	┌ (BOX DRAWINGS LIGHT DOWN AND RIGHT)
+ 91	0x2588	█ (FULL BLOCK)
+ 92	0x2584	▄ (LOWER HALF BLOCK)
+ 93	0x258C	▌ (LEFT HALF BLOCK)
+ 94	0x2590	▐ (RIGHT HALF BLOCK)
+ 95	0x2580	▀ (UPPER HALF BLOCK)
+ 96	0x0440	р (CYRILLIC SMALL LETTER ER)
+ 97	0x0441	с (CYRILLIC SMALL LETTER ES)
+ 98	0x0442	т (CYRILLIC SMALL LETTER TE)
+ 99	0x0443	у (CYRILLIC SMALL LETTER U)
+100	0x0444	ф (CYRILLIC SMALL LETTER EF)
+101	0x0445	х (CYRILLIC SMALL LETTER HA)
+102	0x0446	ц (CYRILLIC SMALL LETTER TSE)
+103	0x0447	ч (CYRILLIC SMALL LETTER CHE)
+104	0x0448	ш (CYRILLIC SMALL LETTER SHA)
+105	0x0449	щ (CYRILLIC SMALL LETTER SHCHA)
+106	0x044A	ъ (CYRILLIC SMALL LETTER HARD SIGN)
+107	0x044B	ы (CYRILLIC SMALL LETTER YERU)
+108	0x044C	ь (CYRILLIC SMALL LETTER SOFT SIGN)
+109	0x044D	э (CYRILLIC SMALL LETTER E)
+110	0x044E	ю (CYRILLIC SMALL LETTER YU)
+111	0x044F	я (CYRILLIC SMALL LETTER YA)
+112	0x0401	Ё (CYRILLIC CAPITAL LETTER IO)
+113	0x0451	ё (CYRILLIC SMALL LETTER IO)
+114	0x0404	Є (CYRILLIC CAPITAL LETTER UKRAINIAN IE)
+115	0x0454	є (CYRILLIC SMALL LETTER UKRAINIAN IE)
+116	0x0407	Ї (CYRILLIC CAPITAL LETTER YI)
+117	0x0457	ї (CYRILLIC SMALL LETTER YI)
+118	0x040E	Ў (CYRILLIC CAPITAL LETTER SHORT U)
+119	0x045E	ў (CYRILLIC SMALL LETTER SHORT U)
+120	0x00B0	° (DEGREE SIGN)
+121	0x2219	∙ (BULLET OPERATOR)
+122	0x00B7	· (MIDDLE DOT)
+123	0x221A	√ (SQUARE ROOT)
+124	0x2116	№ (NUMERO SIGN)
+125	0x00A4	¤ (CURRENCY SIGN)
+126	0x25A0	■ (BLACK SQUARE)
+127	0x00A0	  (NO-BREAK SPACE)
diff --git a/test/js/node/test/fixtures/encoding/single-byte/index-iso-8859-10.txt b/test/js/node/test/fixtures/encoding/single-byte/index-iso-8859-10.txt
new file mode 100644
index 000000000000..0097b42145ee
--- /dev/null
+++ b/test/js/node/test/fixtures/encoding/single-byte/index-iso-8859-10.txt
@@ -0,0 +1,134 @@
+# For details on index index-iso-8859-10.txt see the Encoding Standard
+# https://encoding.spec.whatwg.org/
+#
+# Identifier: 02c2b5590d8ccda9931008c471f6ee2c590b2c8fe5e6ccb3b08638115d778507
+# Date: 2024-09-18
+
+  0	0x0080	€ (<control>)
+  1	0x0081	 (<control>)
+  2	0x0082	‚ (<control>)
+  3	0x0083	ƒ (<control>)
+  4	0x0084	„ (<control>)
+  5	0x0085	… (<control>)
+  6	0x0086	† (<control>)
+  7	0x0087	‡ (<control>)
+  8	0x0088	ˆ (<control>)
+  9	0x0089	‰ (<control>)
+ 10	0x008A	Š (<control>)
+ 11	0x008B	‹ (<control>)
+ 12	0x008C	Π(<control>)
+ 13	0x008D	 (<control>)
+ 14	0x008E	Ž (<control>)
+ 15	0x008F	 (<control>)
+ 16	0x0090	 (<control>)
+ 17	0x0091	‘ (<control>)
+ 18	0x0092	’ (<control>)
+ 19	0x0093	“ (<control>)
+ 20	0x0094	” (<control>)
+ 21	0x0095	• (<control>)
+ 22	0x0096	– (<control>)
+ 23	0x0097	— (<control>)
+ 24	0x0098	˜ (<control>)
+ 25	0x0099	™ (<control>)
+ 26	0x009A	š (<control>)
+ 27	0x009B	› (<control>)
+ 28	0x009C	œ (<control>)
+ 29	0x009D	 (<control>)
+ 30	0x009E	ž (<control>)
+ 31	0x009F	Ÿ (<control>)
+ 32	0x00A0	  (NO-BREAK SPACE)
+ 33	0x0104	Ą (LATIN CAPITAL LETTER A WITH OGONEK)
+ 34	0x0112	Ē (LATIN CAPITAL LETTER E WITH MACRON)
+ 35	0x0122	Ģ (LATIN CAPITAL LETTER G WITH CEDILLA)
+ 36	0x012A	Ī (LATIN CAPITAL LETTER I WITH MACRON)
+ 37	0x0128	Ĩ (LATIN CAPITAL LETTER I WITH TILDE)
+ 38	0x0136	Ķ (LATIN CAPITAL LETTER K WITH CEDILLA)
+ 39	0x00A7	§ (SECTION SIGN)
+ 40	0x013B	Ļ (LATIN CAPITAL LETTER L WITH CEDILLA)
+ 41	0x0110	Đ (LATIN CAPITAL LETTER D WITH STROKE)
+ 42	0x0160	Š (LATIN CAPITAL LETTER S WITH CARON)
+ 43	0x0166	Ŧ (LATIN CAPITAL LETTER T WITH STROKE)
+ 44	0x017D	Ž (LATIN CAPITAL LETTER Z WITH CARON)
+ 45	0x00AD	­ (SOFT HYPHEN)
+ 46	0x016A	Ū (LATIN CAPITAL LETTER U WITH MACRON)
+ 47	0x014A	Ŋ (LATIN CAPITAL LETTER ENG)
+ 48	0x00B0	° (DEGREE SIGN)
+ 49	0x0105	ą (LATIN SMALL LETTER A WITH OGONEK)
+ 50	0x0113	ē (LATIN SMALL LETTER E WITH MACRON)
+ 51	0x0123	ģ (LATIN SMALL LETTER G WITH CEDILLA)
+ 52	0x012B	ī (LATIN SMALL LETTER I WITH MACRON)
+ 53	0x0129	ĩ (LATIN SMALL LETTER I WITH TILDE)
+ 54	0x0137	ķ (LATIN SMALL LETTER K WITH CEDILLA)
+ 55	0x00B7	· (MIDDLE DOT)
+ 56	0x013C	ļ (LATIN SMALL LETTER L WITH CEDILLA)
+ 57	0x0111	đ (LATIN SMALL LETTER D WITH STROKE)
+ 58	0x0161	š (LATIN SMALL LETTER S WITH CARON)
+ 59	0x0167	ŧ (LATIN SMALL LETTER T WITH STROKE)
+ 60	0x017E	ž (LATIN SMALL LETTER Z WITH CARON)
+ 61	0x2015	― (HORIZONTAL BAR)
+ 62	0x016B	ū (LATIN SMALL LETTER U WITH MACRON)
+ 63	0x014B	ŋ (LATIN SMALL LETTER ENG)
+ 64	0x0100	Ā (LATIN CAPITAL LETTER A WITH MACRON)
+ 65	0x00C1	Á (LATIN CAPITAL LETTER A WITH ACUTE)
+ 66	0x00C2	Â (LATIN CAPITAL LETTER A WITH CIRCUMFLEX)
+ 67	0x00C3	Ã (LATIN CAPITAL LETTER A WITH TILDE)
+ 68	0x00C4	Ä (LATIN CAPITAL LETTER A WITH DIAERESIS)
+ 69	0x00C5	Å (LATIN CAPITAL LETTER A WITH RING ABOVE)
+ 70	0x00C6	Æ (LATIN CAPITAL LETTER AE)
+ 71	0x012E	Į (LATIN CAPITAL LETTER I WITH OGONEK)
+ 72	0x010C	Č (LATIN CAPITAL LETTER C WITH CARON)
+ 73	0x00C9	É (LATIN CAPITAL LETTER E WITH ACUTE)
+ 74	0x0118	Ę (LATIN CAPITAL LETTER E WITH OGONEK)
+ 75	0x00CB	Ë (LATIN CAPITAL LETTER E WITH DIAERESIS)
+ 76	0x0116	Ė (LATIN CAPITAL LETTER E WITH DOT ABOVE)
+ 77	0x00CD	Í (LATIN CAPITAL LETTER I WITH ACUTE)
+ 78	0x00CE	Î (LATIN CAPITAL LETTER I WITH CIRCUMFLEX)
+ 79	0x00CF	Ï (LATIN CAPITAL LETTER I WITH DIAERESIS)
+ 80	0x00D0	Ð (LATIN CAPITAL LETTER ETH)
+ 81	0x0145	Ņ (LATIN CAPITAL LETTER N WITH CEDILLA)
+ 82	0x014C	Ō (LATIN CAPITAL LETTER O WITH MACRON)
+ 83	0x00D3	Ó (LATIN CAPITAL LETTER O WITH ACUTE)
+ 84	0x00D4	Ô (LATIN CAPITAL LETTER O WITH CIRCUMFLEX)
+ 85	0x00D5	Õ (LATIN CAPITAL LETTER O WITH TILDE)
+ 86	0x00D6	Ö (LATIN CAPITAL LETTER O WITH DIAERESIS)
+ 87	0x0168	Ũ (LATIN CAPITAL LETTER U WITH TILDE)
+ 88	0x00D8	Ø (LATIN CAPITAL LETTER O WITH STROKE)
+ 89	0x0172	Ų (LATIN CAPITAL LETTER U WITH OGONEK)
+ 90	0x00DA	Ú (LATIN CAPITAL LETTER U WITH ACUTE)
+ 91	0x00DB	Û (LATIN CAPITAL LETTER U WITH CIRCUMFLEX)
+ 92	0x00DC	Ü (LATIN CAPITAL LETTER U WITH DIAERESIS)
+ 93	0x00DD	Ý (LATIN CAPITAL LETTER Y WITH ACUTE)
+ 94	0x00DE	Þ (LATIN CAPITAL LETTER THORN)
+ 95	0x00DF	ß (LATIN SMALL LETTER SHARP S)
+ 96	0x0101	ā (LATIN SMALL LETTER A WITH MACRON)
+ 97	0x00E1	á (LATIN SMALL LETTER A WITH ACUTE)
+ 98	0x00E2	â (LATIN SMALL LETTER A WITH CIRCUMFLEX)
+ 99	0x00E3	ã (LATIN SMALL LETTER A WITH TILDE)
+100	0x00E4	ä (LATIN SMALL LETTER A WITH DIAERESIS)
+101	0x00E5	å (LATIN SMALL LETTER A WITH RING ABOVE)
+102	0x00E6	æ (LATIN SMALL LETTER AE)
+103	0x012F	į (LATIN SMALL LETTER I WITH OGONEK)
+104	0x010D	č (LATIN SMALL LETTER C WITH CARON)
+105	0x00E9	é (LATIN SMALL LETTER E WITH ACUTE)
+106	0x0119	ę (LATIN SMALL LETTER E WITH OGONEK)
+107	0x00EB	ë (LATIN SMALL LETTER E WITH DIAERESIS)
+108	0x0117	ė (LATIN SMALL LETTER E WITH DOT ABOVE)
+109	0x00ED	í (LATIN SMALL LETTER I WITH ACUTE)
+110	0x00EE	î (LATIN SMALL LETTER I WITH CIRCUMFLEX)
+111	0x00EF	ï (LATIN SMALL LETTER I WITH DIAERESIS)
+112	0x00F0	ð (LATIN SMALL LETTER ETH)
+113	0x0146	ņ (LATIN SMALL LETTER N WITH CEDILLA)
+114	0x014D	ō (LATIN SMALL LETTER O WITH MACRON)
+115	0x00F3	ó (LATIN SMALL LETTER O WITH ACUTE)
+116	0x00F4	ô (LATIN SMALL LETTER O WITH CIRCUMFLEX)
+117	0x00F5	õ (LATIN SMALL LETTER O WITH TILDE)
+118	0x00F6	ö (LATIN SMALL LETTER O WITH DIAERESIS)
+119	0x0169	ũ (LATIN SMALL LETTER U WITH TILDE)
+120	0x00F8	ø (LATIN SMALL LETTER O WITH STROKE)
+121	0x0173	ų (LATIN SMALL LETTER U WITH OGONEK)
+122	0x00FA	ú (LATIN SMALL LETTER U WITH ACUTE)
+123	0x00FB	û (LATIN SMALL LETTER U WITH CIRCUMFLEX)
+124	0x00FC	ü (LATIN SMALL LETTER U WITH DIAERESIS)
+125	0x00FD	ý (LATIN SMALL LETTER Y WITH ACUTE)
+126	0x00FE	þ (LATIN SMALL LETTER THORN)
+127	0x0138	ĸ (LATIN SMALL LETTER KRA)
diff --git a/test/js/node/test/fixtures/encoding/single-byte/index-iso-8859-13.txt b/test/js/node/test/fixtures/encoding/single-byte/index-iso-8859-13.txt
new file mode 100644
index 000000000000..0e52de359b82
--- /dev/null
+++ b/test/js/node/test/fixtures/encoding/single-byte/index-iso-8859-13.txt
@@ -0,0 +1,134 @@
+# For details on index index-iso-8859-13.txt see the Encoding Standard
+# https://encoding.spec.whatwg.org/
+#
+# Identifier: 40736338e964ab520407cebcb01329f8d450abf6ce12bf88b74b655b60e43300
+# Date: 2024-09-18
+
+  0	0x0080	€ (<control>)
+  1	0x0081	 (<control>)
+  2	0x0082	‚ (<control>)
+  3	0x0083	ƒ (<control>)
+  4	0x0084	„ (<control>)
+  5	0x0085	… (<control>)
+  6	0x0086	† (<control>)
+  7	0x0087	‡ (<control>)
+  8	0x0088	ˆ (<control>)
+  9	0x0089	‰ (<control>)
+ 10	0x008A	Š (<control>)
+ 11	0x008B	‹ (<control>)
+ 12	0x008C	Π(<control>)
+ 13	0x008D	 (<control>)
+ 14	0x008E	Ž (<control>)
+ 15	0x008F	 (<control>)
+ 16	0x0090	 (<control>)
+ 17	0x0091	‘ (<control>)
+ 18	0x0092	’ (<control>)
+ 19	0x0093	“ (<control>)
+ 20	0x0094	” (<control>)
+ 21	0x0095	• (<control>)
+ 22	0x0096	– (<control>)
+ 23	0x0097	— (<control>)
+ 24	0x0098	˜ (<control>)
+ 25	0x0099	™ (<control>)
+ 26	0x009A	š (<control>)
+ 27	0x009B	› (<control>)
+ 28	0x009C	œ (<control>)
+ 29	0x009D	 (<control>)
+ 30	0x009E	ž (<control>)
+ 31	0x009F	Ÿ (<control>)
+ 32	0x00A0	  (NO-BREAK SPACE)
+ 33	0x201D	” (RIGHT DOUBLE QUOTATION MARK)
+ 34	0x00A2	¢ (CENT SIGN)
+ 35	0x00A3	£ (POUND SIGN)
+ 36	0x00A4	¤ (CURRENCY SIGN)
+ 37	0x201E	„ (DOUBLE LOW-9 QUOTATION MARK)
+ 38	0x00A6	¦ (BROKEN BAR)
+ 39	0x00A7	§ (SECTION SIGN)
+ 40	0x00D8	Ø (LATIN CAPITAL LETTER O WITH STROKE)
+ 41	0x00A9	© (COPYRIGHT SIGN)
+ 42	0x0156	Ŗ (LATIN CAPITAL LETTER R WITH CEDILLA)
+ 43	0x00AB	« (LEFT-POINTING DOUBLE ANGLE QUOTATION MARK)
+ 44	0x00AC	¬ (NOT SIGN)
+ 45	0x00AD	­ (SOFT HYPHEN)
+ 46	0x00AE	® (REGISTERED SIGN)
+ 47	0x00C6	Æ (LATIN CAPITAL LETTER AE)
+ 48	0x00B0	° (DEGREE SIGN)
+ 49	0x00B1	± (PLUS-MINUS SIGN)
+ 50	0x00B2	² (SUPERSCRIPT TWO)
+ 51	0x00B3	³ (SUPERSCRIPT THREE)
+ 52	0x201C	“ (LEFT DOUBLE QUOTATION MARK)
+ 53	0x00B5	µ (MICRO SIGN)
+ 54	0x00B6	¶ (PILCROW SIGN)
+ 55	0x00B7	· (MIDDLE DOT)
+ 56	0x00F8	ø (LATIN SMALL LETTER O WITH STROKE)
+ 57	0x00B9	¹ (SUPERSCRIPT ONE)
+ 58	0x0157	ŗ (LATIN SMALL LETTER R WITH CEDILLA)
+ 59	0x00BB	» (RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK)
+ 60	0x00BC	¼ (VULGAR FRACTION ONE QUARTER)
+ 61	0x00BD	½ (VULGAR FRACTION ONE HALF)
+ 62	0x00BE	¾ (VULGAR FRACTION THREE QUARTERS)
+ 63	0x00E6	æ (LATIN SMALL LETTER AE)
+ 64	0x0104	Ą (LATIN CAPITAL LETTER A WITH OGONEK)
+ 65	0x012E	Į (LATIN CAPITAL LETTER I WITH OGONEK)
+ 66	0x0100	Ā (LATIN CAPITAL LETTER A WITH MACRON)
+ 67	0x0106	Ć (LATIN CAPITAL LETTER C WITH ACUTE)
+ 68	0x00C4	Ä (LATIN CAPITAL LETTER A WITH DIAERESIS)
+ 69	0x00C5	Å (LATIN CAPITAL LETTER A WITH RING ABOVE)
+ 70	0x0118	Ę (LATIN CAPITAL LETTER E WITH OGONEK)
+ 71	0x0112	Ē (LATIN CAPITAL LETTER E WITH MACRON)
+ 72	0x010C	Č (LATIN CAPITAL LETTER C WITH CARON)
+ 73	0x00C9	É (LATIN CAPITAL LETTER E WITH ACUTE)
+ 74	0x0179	Ź (LATIN CAPITAL LETTER Z WITH ACUTE)
+ 75	0x0116	Ė (LATIN CAPITAL LETTER E WITH DOT ABOVE)
+ 76	0x0122	Ģ (LATIN CAPITAL LETTER G WITH CEDILLA)
+ 77	0x0136	Ķ (LATIN CAPITAL LETTER K WITH CEDILLA)
+ 78	0x012A	Ī (LATIN CAPITAL LETTER I WITH MACRON)
+ 79	0x013B	Ļ (LATIN CAPITAL LETTER L WITH CEDILLA)
+ 80	0x0160	Š (LATIN CAPITAL LETTER S WITH CARON)
+ 81	0x0143	Ń (LATIN CAPITAL LETTER N WITH ACUTE)
+ 82	0x0145	Ņ (LATIN CAPITAL LETTER N WITH CEDILLA)
+ 83	0x00D3	Ó (LATIN CAPITAL LETTER O WITH ACUTE)
+ 84	0x014C	Ō (LATIN CAPITAL LETTER O WITH MACRON)
+ 85	0x00D5	Õ (LATIN CAPITAL LETTER O WITH TILDE)
+ 86	0x00D6	Ö (LATIN CAPITAL LETTER O WITH DIAERESIS)
+ 87	0x00D7	× (MULTIPLICATION SIGN)
+ 88	0x0172	Ų (LATIN CAPITAL LETTER U WITH OGONEK)
+ 89	0x0141	Ł (LATIN CAPITAL LETTER L WITH STROKE)
+ 90	0x015A	Ś (LATIN CAPITAL LETTER S WITH ACUTE)
+ 91	0x016A	Ū (LATIN CAPITAL LETTER U WITH MACRON)
+ 92	0x00DC	Ü (LATIN CAPITAL LETTER U WITH DIAERESIS)
+ 93	0x017B	Ż (LATIN CAPITAL LETTER Z WITH DOT ABOVE)
+ 94	0x017D	Ž (LATIN CAPITAL LETTER Z WITH CARON)
+ 95	0x00DF	ß (LATIN SMALL LETTER SHARP S)
+ 96	0x0105	ą (LATIN SMALL LETTER A WITH OGONEK)
+ 97	0x012F	į (LATIN SMALL LETTER I WITH OGONEK)
+ 98	0x0101	ā (LATIN SMALL LETTER A WITH MACRON)
+ 99	0x0107	ć (LATIN SMALL LETTER C WITH ACUTE)
+100	0x00E4	ä (LATIN SMALL LETTER A WITH DIAERESIS)
+101	0x00E5	å (LATIN SMALL LETTER A WITH RING ABOVE)
+102	0x0119	ę (LATIN SMALL LETTER E WITH OGONEK)
+103	0x0113	ē (LATIN SMALL LETTER E WITH MACRON)
+104	0x010D	č (LATIN SMALL LETTER C WITH CARON)
+105	0x00E9	é (LATIN SMALL LETTER E WITH ACUTE)
+106	0x017A	ź (LATIN SMALL LETTER Z WITH ACUTE)
+107	0x0117	ė (LATIN SMALL LETTER E WITH DOT ABOVE)
+108	0x0123	ģ (LATIN SMALL LETTER G WITH CEDILLA)
+109	0x0137	ķ (LATIN SMALL LETTER K WITH CEDILLA)
+110	0x012B	ī (LATIN SMALL LETTER I WITH MACRON)
+111	0x013C	ļ (LATIN SMALL LETTER L WITH CEDILLA)
+112	0x0161	š (LATIN SMALL LETTER S WITH CARON)
+113	0x0144	ń (LATIN SMALL LETTER N WITH ACUTE)
+114	0x0146	ņ (LATIN SMALL LETTER N WITH CEDILLA)
+115	0x00F3	ó (LATIN SMALL LETTER O WITH ACUTE)
+116	0x014D	ō (LATIN SMALL LETTER O WITH MACRON)
+117	0x00F5	õ (LATIN SMALL LETTER O WITH TILDE)
+118	0x00F6	ö (LATIN SMALL LETTER O WITH DIAERESIS)
+119	0x00F7	÷ (DIVISION SIGN)
+120	0x0173	ų (LATIN SMALL LETTER U WITH OGONEK)
+121	0x0142	ł (LATIN SMALL LETTER L WITH STROKE)
+122	0x015B	ś (LATIN SMALL LETTER S WITH ACUTE)
+123	0x016B	ū (LATIN SMALL LETTER U WITH MACRON)
+124	0x00FC	ü (LATIN SMALL LETTER U WITH DIAERESIS)
+125	0x017C	ż (LATIN SMALL LETTER Z WITH DOT ABOVE)
+126	0x017E	ž (LATIN SMALL LETTER Z WITH CARON)
+127	0x2019	’ (RIGHT SINGLE QUOTATION MARK)
diff --git a/test/js/node/test/fixtures/encoding/single-byte/index-iso-8859-14.txt b/test/js/node/test/fixtures/encoding/single-byte/index-iso-8859-14.txt
new file mode 100644
index 000000000000..d020592171b3
--- /dev/null
+++ b/test/js/node/test/fixtures/encoding/single-byte/index-iso-8859-14.txt
@@ -0,0 +1,134 @@
+# For details on index index-iso-8859-14.txt see the Encoding Standard
+# https://encoding.spec.whatwg.org/
+#
+# Identifier: 2c8651cfc08b1f35b17919ee5379f2fa006af3ec809f11b3b7f470785580542b
+# Date: 2024-09-18
+
+  0	0x0080	€ (<control>)
+  1	0x0081	 (<control>)
+  2	0x0082	‚ (<control>)
+  3	0x0083	ƒ (<control>)
+  4	0x0084	„ (<control>)
+  5	0x0085	… (<control>)
+  6	0x0086	† (<control>)
+  7	0x0087	‡ (<control>)
+  8	0x0088	ˆ (<control>)
+  9	0x0089	‰ (<control>)
+ 10	0x008A	Š (<control>)
+ 11	0x008B	‹ (<control>)
+ 12	0x008C	Π(<control>)
+ 13	0x008D	 (<control>)
+ 14	0x008E	Ž (<control>)
+ 15	0x008F	 (<control>)
+ 16	0x0090	 (<control>)
+ 17	0x0091	‘ (<control>)
+ 18	0x0092	’ (<control>)
+ 19	0x0093	“ (<control>)
+ 20	0x0094	” (<control>)
+ 21	0x0095	• (<control>)
+ 22	0x0096	– (<control>)
+ 23	0x0097	— (<control>)
+ 24	0x0098	˜ (<control>)
+ 25	0x0099	™ (<control>)
+ 26	0x009A	š (<control>)
+ 27	0x009B	› (<control>)
+ 28	0x009C	œ (<control>)
+ 29	0x009D	 (<control>)
+ 30	0x009E	ž (<control>)
+ 31	0x009F	Ÿ (<control>)
+ 32	0x00A0	  (NO-BREAK SPACE)
+ 33	0x1E02	Ḃ (LATIN CAPITAL LETTER B WITH DOT ABOVE)
+ 34	0x1E03	ḃ (LATIN SMALL LETTER B WITH DOT ABOVE)
+ 35	0x00A3	£ (POUND SIGN)
+ 36	0x010A	Ċ (LATIN CAPITAL LETTER C WITH DOT ABOVE)
+ 37	0x010B	ċ (LATIN SMALL LETTER C WITH DOT ABOVE)
+ 38	0x1E0A	Ḋ (LATIN CAPITAL LETTER D WITH DOT ABOVE)
+ 39	0x00A7	§ (SECTION SIGN)
+ 40	0x1E80	Ẁ (LATIN CAPITAL LETTER W WITH GRAVE)
+ 41	0x00A9	© (COPYRIGHT SIGN)
+ 42	0x1E82	Ẃ (LATIN CAPITAL LETTER W WITH ACUTE)
+ 43	0x1E0B	ḋ (LATIN SMALL LETTER D WITH DOT ABOVE)
+ 44	0x1EF2	Ỳ (LATIN CAPITAL LETTER Y WITH GRAVE)
+ 45	0x00AD	­ (SOFT HYPHEN)
+ 46	0x00AE	® (REGISTERED SIGN)
+ 47	0x0178	Ÿ (LATIN CAPITAL LETTER Y WITH DIAERESIS)
+ 48	0x1E1E	Ḟ (LATIN CAPITAL LETTER F WITH DOT ABOVE)
+ 49	0x1E1F	ḟ (LATIN SMALL LETTER F WITH DOT ABOVE)
+ 50	0x0120	Ġ (LATIN CAPITAL LETTER G WITH DOT ABOVE)
+ 51	0x0121	ġ (LATIN SMALL LETTER G WITH DOT ABOVE)
+ 52	0x1E40	Ṁ (LATIN CAPITAL LETTER M WITH DOT ABOVE)
+ 53	0x1E41	ṁ (LATIN SMALL LETTER M WITH DOT ABOVE)
+ 54	0x00B6	¶ (PILCROW SIGN)
+ 55	0x1E56	Ṗ (LATIN CAPITAL LETTER P WITH DOT ABOVE)
+ 56	0x1E81	ẁ (LATIN SMALL LETTER W WITH GRAVE)
+ 57	0x1E57	ṗ (LATIN SMALL LETTER P WITH DOT ABOVE)
+ 58	0x1E83	ẃ (LATIN SMALL LETTER W WITH ACUTE)
+ 59	0x1E60	Ṡ (LATIN CAPITAL LETTER S WITH DOT ABOVE)
+ 60	0x1EF3	ỳ (LATIN SMALL LETTER Y WITH GRAVE)
+ 61	0x1E84	Ẅ (LATIN CAPITAL LETTER W WITH DIAERESIS)
+ 62	0x1E85	ẅ (LATIN SMALL LETTER W WITH DIAERESIS)
+ 63	0x1E61	ṡ (LATIN SMALL LETTER S WITH DOT ABOVE)
+ 64	0x00C0	À (LATIN CAPITAL LETTER A WITH GRAVE)
+ 65	0x00C1	Á (LATIN CAPITAL LETTER A WITH ACUTE)
+ 66	0x00C2	Â (LATIN CAPITAL LETTER A WITH CIRCUMFLEX)
+ 67	0x00C3	Ã (LATIN CAPITAL LETTER A WITH TILDE)
+ 68	0x00C4	Ä (LATIN CAPITAL LETTER A WITH DIAERESIS)
+ 69	0x00C5	Å (LATIN CAPITAL LETTER A WITH RING ABOVE)
+ 70	0x00C6	Æ (LATIN CAPITAL LETTER AE)
+ 71	0x00C7	Ç (LATIN CAPITAL LETTER C WITH CEDILLA)
+ 72	0x00C8	È (LATIN CAPITAL LETTER E WITH GRAVE)
+ 73	0x00C9	É (LATIN CAPITAL LETTER E WITH ACUTE)
+ 74	0x00CA	Ê (LATIN CAPITAL LETTER E WITH CIRCUMFLEX)
+ 75	0x00CB	Ë (LATIN CAPITAL LETTER E WITH DIAERESIS)
+ 76	0x00CC	Ì (LATIN CAPITAL LETTER I WITH GRAVE)
+ 77	0x00CD	Í (LATIN CAPITAL LETTER I WITH ACUTE)
+ 78	0x00CE	Î (LATIN CAPITAL LETTER I WITH CIRCUMFLEX)
+ 79	0x00CF	Ï (LATIN CAPITAL LETTER I WITH DIAERESIS)
+ 80	0x0174	Ŵ (LATIN CAPITAL LETTER W WITH CIRCUMFLEX)
+ 81	0x00D1	Ñ (LATIN CAPITAL LETTER N WITH TILDE)
+ 82	0x00D2	Ò (LATIN CAPITAL LETTER O WITH GRAVE)
+ 83	0x00D3	Ó (LATIN CAPITAL LETTER O WITH ACUTE)
+ 84	0x00D4	Ô (LATIN CAPITAL LETTER O WITH CIRCUMFLEX)
+ 85	0x00D5	Õ (LATIN CAPITAL LETTER O WITH TILDE)
+ 86	0x00D6	Ö (LATIN CAPITAL LETTER O WITH DIAERESIS)
+ 87	0x1E6A	Ṫ (LATIN CAPITAL LETTER T WITH DOT ABOVE)
+ 88	0x00D8	Ø (LATIN CAPITAL LETTER O WITH STROKE)
+ 89	0x00D9	Ù (LATIN CAPITAL LETTER U WITH GRAVE)
+ 90	0x00DA	Ú (LATIN CAPITAL LETTER U WITH ACUTE)
+ 91	0x00DB	Û (LATIN CAPITAL LETTER U WITH CIRCUMFLEX)
+ 92	0x00DC	Ü (LATIN CAPITAL LETTER U WITH DIAERESIS)
+ 93	0x00DD	Ý (LATIN CAPITAL LETTER Y WITH ACUTE)
+ 94	0x0176	Ŷ (LATIN CAPITAL LETTER Y WITH CIRCUMFLEX)
+ 95	0x00DF	ß (LATIN SMALL LETTER SHARP S)
+ 96	0x00E0	à (LATIN SMALL LETTER A WITH GRAVE)
+ 97	0x00E1	á (LATIN SMALL LETTER A WITH ACUTE)
+ 98	0x00E2	â (LATIN SMALL LETTER A WITH CIRCUMFLEX)
+ 99	0x00E3	ã (LATIN SMALL LETTER A WITH TILDE)
+100	0x00E4	ä (LATIN SMALL LETTER A WITH DIAERESIS)
+101	0x00E5	å (LATIN SMALL LETTER A WITH RING ABOVE)
+102	0x00E6	æ (LATIN SMALL LETTER AE)
+103	0x00E7	ç (LATIN SMALL LETTER C WITH CEDILLA)
+104	0x00E8	è (LATIN SMALL LETTER E WITH GRAVE)
+105	0x00E9	é (LATIN SMALL LETTER E WITH ACUTE)
+106	0x00EA	ê (LATIN SMALL LETTER E WITH CIRCUMFLEX)
+107	0x00EB	ë (LATIN SMALL LETTER E WITH DIAERESIS)
+108	0x00EC	ì (LATIN SMALL LETTER I WITH GRAVE)
+109	0x00ED	í (LATIN SMALL LETTER I WITH ACUTE)
+110	0x00EE	î (LATIN SMALL LETTER I WITH CIRCUMFLEX)
+111	0x00EF	ï (LATIN SMALL LETTER I WITH DIAERESIS)
+112	0x0175	ŵ (LATIN SMALL LETTER W WITH CIRCUMFLEX)
+113	0x00F1	ñ (LATIN SMALL LETTER N WITH TILDE)
+114	0x00F2	ò (LATIN SMALL LETTER O WITH GRAVE)
+115	0x00F3	ó (LATIN SMALL LETTER O WITH ACUTE)
+116	0x00F4	ô (LATIN SMALL LETTER O WITH CIRCUMFLEX)
+117	0x00F5	õ (LATIN SMALL LETTER O WITH TILDE)
+118	0x00F6	ö (LATIN SMALL LETTER O WITH DIAERESIS)
+119	0x1E6B	ṫ (LATIN SMALL LETTER T WITH DOT ABOVE)
+120	0x00F8	ø (LATIN SMALL LETTER O WITH STROKE)
+121	0x00F9	ù (LATIN SMALL LETTER U WITH GRAVE)
+122	0x00FA	ú (LATIN SMALL LETTER U WITH ACUTE)
+123	0x00FB	û (LATIN SMALL LETTER U WITH CIRCUMFLEX)
+124	0x00FC	ü (LATIN SMALL LETTER U WITH DIAERESIS)
+125	0x00FD	ý (LATIN SMALL LETTER Y WITH ACUTE)
+126	0x0177	ŷ (LATIN SMALL LETTER Y WITH CIRCUMFLEX)
+127	0x00FF	ÿ (LATIN SMALL LETTER Y WITH DIAERESIS)
diff --git a/test/js/node/test/fixtures/encoding/single-byte/index-iso-8859-15.txt b/test/js/node/test/fixtures/encoding/single-byte/index-iso-8859-15.txt
new file mode 100644
index 000000000000..e673fa816b51
--- /dev/null
+++ b/test/js/node/test/fixtures/encoding/single-byte/index-iso-8859-15.txt
@@ -0,0 +1,134 @@
+# For details on index index-iso-8859-15.txt see the Encoding Standard
+# https://encoding.spec.whatwg.org/
+#
+# Identifier: a560aba47bccd7510a6ac77f671fe75dca3800f05cf6d676910c311a8f8ff079
+# Date: 2024-09-18
+
+  0	0x0080	€ (<control>)
+  1	0x0081	 (<control>)
+  2	0x0082	‚ (<control>)
+  3	0x0083	ƒ (<control>)
+  4	0x0084	„ (<control>)
+  5	0x0085	… (<control>)
+  6	0x0086	† (<control>)
+  7	0x0087	‡ (<control>)
+  8	0x0088	ˆ (<control>)
+  9	0x0089	‰ (<control>)
+ 10	0x008A	Š (<control>)
+ 11	0x008B	‹ (<control>)
+ 12	0x008C	Π(<control>)
+ 13	0x008D	 (<control>)
+ 14	0x008E	Ž (<control>)
+ 15	0x008F	 (<control>)
+ 16	0x0090	 (<control>)
+ 17	0x0091	‘ (<control>)
+ 18	0x0092	’ (<control>)
+ 19	0x0093	“ (<control>)
+ 20	0x0094	” (<control>)
+ 21	0x0095	• (<control>)
+ 22	0x0096	– (<control>)
+ 23	0x0097	— (<control>)
+ 24	0x0098	˜ (<control>)
+ 25	0x0099	™ (<control>)
+ 26	0x009A	š (<control>)
+ 27	0x009B	› (<control>)
+ 28	0x009C	œ (<control>)
+ 29	0x009D	 (<control>)
+ 30	0x009E	ž (<control>)
+ 31	0x009F	Ÿ (<control>)
+ 32	0x00A0	  (NO-BREAK SPACE)
+ 33	0x00A1	¡ (INVERTED EXCLAMATION MARK)
+ 34	0x00A2	¢ (CENT SIGN)
+ 35	0x00A3	£ (POUND SIGN)
+ 36	0x20AC	€ (EURO SIGN)
+ 37	0x00A5	¥ (YEN SIGN)
+ 38	0x0160	Š (LATIN CAPITAL LETTER S WITH CARON)
+ 39	0x00A7	§ (SECTION SIGN)
+ 40	0x0161	š (LATIN SMALL LETTER S WITH CARON)
+ 41	0x00A9	© (COPYRIGHT SIGN)
+ 42	0x00AA	ª (FEMININE ORDINAL INDICATOR)
+ 43	0x00AB	« (LEFT-POINTING DOUBLE ANGLE QUOTATION MARK)
+ 44	0x00AC	¬ (NOT SIGN)
+ 45	0x00AD	­ (SOFT HYPHEN)
+ 46	0x00AE	® (REGISTERED SIGN)
+ 47	0x00AF	¯ (MACRON)
+ 48	0x00B0	° (DEGREE SIGN)
+ 49	0x00B1	± (PLUS-MINUS SIGN)
+ 50	0x00B2	² (SUPERSCRIPT TWO)
+ 51	0x00B3	³ (SUPERSCRIPT THREE)
+ 52	0x017D	Ž (LATIN CAPITAL LETTER Z WITH CARON)
+ 53	0x00B5	µ (MICRO SIGN)
+ 54	0x00B6	¶ (PILCROW SIGN)
+ 55	0x00B7	· (MIDDLE DOT)
+ 56	0x017E	ž (LATIN SMALL LETTER Z WITH CARON)
+ 57	0x00B9	¹ (SUPERSCRIPT ONE)
+ 58	0x00BA	º (MASCULINE ORDINAL INDICATOR)
+ 59	0x00BB	» (RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK)
+ 60	0x0152	Π(LATIN CAPITAL LIGATURE OE)
+ 61	0x0153	œ (LATIN SMALL LIGATURE OE)
+ 62	0x0178	Ÿ (LATIN CAPITAL LETTER Y WITH DIAERESIS)
+ 63	0x00BF	¿ (INVERTED QUESTION MARK)
+ 64	0x00C0	À (LATIN CAPITAL LETTER A WITH GRAVE)
+ 65	0x00C1	Á (LATIN CAPITAL LETTER A WITH ACUTE)
+ 66	0x00C2	Â (LATIN CAPITAL LETTER A WITH CIRCUMFLEX)
+ 67	0x00C3	Ã (LATIN CAPITAL LETTER A WITH TILDE)
+ 68	0x00C4	Ä (LATIN CAPITAL LETTER A WITH DIAERESIS)
+ 69	0x00C5	Å (LATIN CAPITAL LETTER A WITH RING ABOVE)
+ 70	0x00C6	Æ (LATIN CAPITAL LETTER AE)
+ 71	0x00C7	Ç (LATIN CAPITAL LETTER C WITH CEDILLA)
+ 72	0x00C8	È (LATIN CAPITAL LETTER E WITH GRAVE)
+ 73	0x00C9	É (LATIN CAPITAL LETTER E WITH ACUTE)
+ 74	0x00CA	Ê (LATIN CAPITAL LETTER E WITH CIRCUMFLEX)
+ 75	0x00CB	Ë (LATIN CAPITAL LETTER E WITH DIAERESIS)
+ 76	0x00CC	Ì (LATIN CAPITAL LETTER I WITH GRAVE)
+ 77	0x00CD	Í (LATIN CAPITAL LETTER I WITH ACUTE)
+ 78	0x00CE	Î (LATIN CAPITAL LETTER I WITH CIRCUMFLEX)
+ 79	0x00CF	Ï (LATIN CAPITAL LETTER I WITH DIAERESIS)
+ 80	0x00D0	Ð (LATIN CAPITAL LETTER ETH)
+ 81	0x00D1	Ñ (LATIN CAPITAL LETTER N WITH TILDE)
+ 82	0x00D2	Ò (LATIN CAPITAL LETTER O WITH GRAVE)
+ 83	0x00D3	Ó (LATIN CAPITAL LETTER O WITH ACUTE)
+ 84	0x00D4	Ô (LATIN CAPITAL LETTER O WITH CIRCUMFLEX)
+ 85	0x00D5	Õ (LATIN CAPITAL LETTER O WITH TILDE)
+ 86	0x00D6	Ö (LATIN CAPITAL LETTER O WITH DIAERESIS)
+ 87	0x00D7	× (MULTIPLICATION SIGN)
+ 88	0x00D8	Ø (LATIN CAPITAL LETTER O WITH STROKE)
+ 89	0x00D9	Ù (LATIN CAPITAL LETTER U WITH GRAVE)
+ 90	0x00DA	Ú (LATIN CAPITAL LETTER U WITH ACUTE)
+ 91	0x00DB	Û (LATIN CAPITAL LETTER U WITH CIRCUMFLEX)
+ 92	0x00DC	Ü (LATIN CAPITAL LETTER U WITH DIAERESIS)
+ 93	0x00DD	Ý (LATIN CAPITAL LETTER Y WITH ACUTE)
+ 94	0x00DE	Þ (LATIN CAPITAL LETTER THORN)
+ 95	0x00DF	ß (LATIN SMALL LETTER SHARP S)
+ 96	0x00E0	à (LATIN SMALL LETTER A WITH GRAVE)
+ 97	0x00E1	á (LATIN SMALL LETTER A WITH ACUTE)
+ 98	0x00E2	â (LATIN SMALL LETTER A WITH CIRCUMFLEX)
+ 99	0x00E3	ã (LATIN SMALL LETTER A WITH TILDE)
+100	0x00E4	ä (LATIN SMALL LETTER A WITH DIAERESIS)
+101	0x00E5	å (LATIN SMALL LETTER A WITH RING ABOVE)
+102	0x00E6	æ (LATIN SMALL LETTER AE)
+103	0x00E7	ç (LATIN SMALL LETTER C WITH CEDILLA)
+104	0x00E8	è (LATIN SMALL LETTER E WITH GRAVE)
+105	0x00E9	é (LATIN SMALL LETTER E WITH ACUTE)
+106	0x00EA	ê (LATIN SMALL LETTER E WITH CIRCUMFLEX)
+107	0x00EB	ë (LATIN SMALL LETTER E WITH DIAERESIS)
+108	0x00EC	ì (LATIN SMALL LETTER I WITH GRAVE)
+109	0x00ED	í (LATIN SMALL LETTER I WITH ACUTE)
+110	0x00EE	î (LATIN SMALL LETTER I WITH CIRCUMFLEX)
+111	0x00EF	ï (LATIN SMALL LETTER I WITH DIAERESIS)
+112	0x00F0	ð (LATIN SMALL LETTER ETH)
+113	0x00F1	ñ (LATIN SMALL LETTER N WITH TILDE)
+114	0x00F2	ò (LATIN SMALL LETTER O WITH GRAVE)
+115	0x00F3	ó (LATIN SMALL LETTER O WITH ACUTE)
+116	0x00F4	ô (LATIN SMALL LETTER O WITH CIRCUMFLEX)
+117	0x00F5	õ (LATIN SMALL LETTER O WITH TILDE)
+118	0x00F6	ö (LATIN SMALL LETTER O WITH DIAERESIS)
+119	0x00F7	÷ (DIVISION SIGN)
+120	0x00F8	ø (LATIN SMALL LETTER O WITH STROKE)
+121	0x00F9	ù (LATIN SMALL LETTER U WITH GRAVE)
+122	0x00FA	ú (LATIN SMALL LETTER U WITH ACUTE)
+123	0x00FB	û (LATIN SMALL LETTER U WITH CIRCUMFLEX)
+124	0x00FC	ü (LATIN SMALL LETTER U WITH DIAERESIS)
+125	0x00FD	ý (LATIN SMALL LETTER Y WITH ACUTE)
+126	0x00FE	þ (LATIN SMALL LETTER THORN)
+127	0x00FF	ÿ (LATIN SMALL LETTER Y WITH DIAERESIS)
diff --git a/test/js/node/test/fixtures/encoding/single-byte/index-iso-8859-16.txt b/test/js/node/test/fixtures/encoding/single-byte/index-iso-8859-16.txt
new file mode 100644
index 000000000000..985176ff5367
--- /dev/null
+++ b/test/js/node/test/fixtures/encoding/single-byte/index-iso-8859-16.txt
@@ -0,0 +1,134 @@
+# For details on index index-iso-8859-16.txt see the Encoding Standard
+# https://encoding.spec.whatwg.org/
+#
+# Identifier: 55676320d2d1b6e6909f5b3d741a7cf0cefc84e920aa4474afc091459111c2e3
+# Date: 2024-09-18
+
+  0	0x0080	€ (<control>)
+  1	0x0081	 (<control>)
+  2	0x0082	‚ (<control>)
+  3	0x0083	ƒ (<control>)
+  4	0x0084	„ (<control>)
+  5	0x0085	… (<control>)
+  6	0x0086	† (<control>)
+  7	0x0087	‡ (<control>)
+  8	0x0088	ˆ (<control>)
+  9	0x0089	‰ (<control>)
+ 10	0x008A	Š (<control>)
+ 11	0x008B	‹ (<control>)
+ 12	0x008C	Π(<control>)
+ 13	0x008D	 (<control>)
+ 14	0x008E	Ž (<control>)
+ 15	0x008F	 (<control>)
+ 16	0x0090	 (<control>)
+ 17	0x0091	‘ (<control>)
+ 18	0x0092	’ (<control>)
+ 19	0x0093	“ (<control>)
+ 20	0x0094	” (<control>)
+ 21	0x0095	• (<control>)
+ 22	0x0096	– (<control>)
+ 23	0x0097	— (<control>)
+ 24	0x0098	˜ (<control>)
+ 25	0x0099	™ (<control>)
+ 26	0x009A	š (<control>)
+ 27	0x009B	› (<control>)
+ 28	0x009C	œ (<control>)
+ 29	0x009D	 (<control>)
+ 30	0x009E	ž (<control>)
+ 31	0x009F	Ÿ (<control>)
+ 32	0x00A0	  (NO-BREAK SPACE)
+ 33	0x0104	Ą (LATIN CAPITAL LETTER A WITH OGONEK)
+ 34	0x0105	ą (LATIN SMALL LETTER A WITH OGONEK)
+ 35	0x0141	Ł (LATIN CAPITAL LETTER L WITH STROKE)
+ 36	0x20AC	€ (EURO SIGN)
+ 37	0x201E	„ (DOUBLE LOW-9 QUOTATION MARK)
+ 38	0x0160	Š (LATIN CAPITAL LETTER S WITH CARON)
+ 39	0x00A7	§ (SECTION SIGN)
+ 40	0x0161	š (LATIN SMALL LETTER S WITH CARON)
+ 41	0x00A9	© (COPYRIGHT SIGN)
+ 42	0x0218	Ș (LATIN CAPITAL LETTER S WITH COMMA BELOW)
+ 43	0x00AB	« (LEFT-POINTING DOUBLE ANGLE QUOTATION MARK)
+ 44	0x0179	Ź (LATIN CAPITAL LETTER Z WITH ACUTE)
+ 45	0x00AD	­ (SOFT HYPHEN)
+ 46	0x017A	ź (LATIN SMALL LETTER Z WITH ACUTE)
+ 47	0x017B	Ż (LATIN CAPITAL LETTER Z WITH DOT ABOVE)
+ 48	0x00B0	° (DEGREE SIGN)
+ 49	0x00B1	± (PLUS-MINUS SIGN)
+ 50	0x010C	Č (LATIN CAPITAL LETTER C WITH CARON)
+ 51	0x0142	ł (LATIN SMALL LETTER L WITH STROKE)
+ 52	0x017D	Ž (LATIN CAPITAL LETTER Z WITH CARON)
+ 53	0x201D	” (RIGHT DOUBLE QUOTATION MARK)
+ 54	0x00B6	¶ (PILCROW SIGN)
+ 55	0x00B7	· (MIDDLE DOT)
+ 56	0x017E	ž (LATIN SMALL LETTER Z WITH CARON)
+ 57	0x010D	č (LATIN SMALL LETTER C WITH CARON)
+ 58	0x0219	ș (LATIN SMALL LETTER S WITH COMMA BELOW)
+ 59	0x00BB	» (RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK)
+ 60	0x0152	Π(LATIN CAPITAL LIGATURE OE)
+ 61	0x0153	œ (LATIN SMALL LIGATURE OE)
+ 62	0x0178	Ÿ (LATIN CAPITAL LETTER Y WITH DIAERESIS)
+ 63	0x017C	ż (LATIN SMALL LETTER Z WITH DOT ABOVE)
+ 64	0x00C0	À (LATIN CAPITAL LETTER A WITH GRAVE)
+ 65	0x00C1	Á (LATIN CAPITAL LETTER A WITH ACUTE)
+ 66	0x00C2	Â (LATIN CAPITAL LETTER A WITH CIRCUMFLEX)
+ 67	0x0102	Ă (LATIN CAPITAL LETTER A WITH BREVE)
+ 68	0x00C4	Ä (LATIN CAPITAL LETTER A WITH DIAERESIS)
+ 69	0x0106	Ć (LATIN CAPITAL LETTER C WITH ACUTE)
+ 70	0x00C6	Æ (LATIN CAPITAL LETTER AE)
+ 71	0x00C7	Ç (LATIN CAPITAL LETTER C WITH CEDILLA)
+ 72	0x00C8	È (LATIN CAPITAL LETTER E WITH GRAVE)
+ 73	0x00C9	É (LATIN CAPITAL LETTER E WITH ACUTE)
+ 74	0x00CA	Ê (LATIN CAPITAL LETTER E WITH CIRCUMFLEX)
+ 75	0x00CB	Ë (LATIN CAPITAL LETTER E WITH DIAERESIS)
+ 76	0x00CC	Ì (LATIN CAPITAL LETTER I WITH GRAVE)
+ 77	0x00CD	Í (LATIN CAPITAL LETTER I WITH ACUTE)
+ 78	0x00CE	Î (LATIN CAPITAL LETTER I WITH CIRCUMFLEX)
+ 79	0x00CF	Ï (LATIN CAPITAL LETTER I WITH DIAERESIS)
+ 80	0x0110	Đ (LATIN CAPITAL LETTER D WITH STROKE)
+ 81	0x0143	Ń (LATIN CAPITAL LETTER N WITH ACUTE)
+ 82	0x00D2	Ò (LATIN CAPITAL LETTER O WITH GRAVE)
+ 83	0x00D3	Ó (LATIN CAPITAL LETTER O WITH ACUTE)
+ 84	0x00D4	Ô (LATIN CAPITAL LETTER O WITH CIRCUMFLEX)
+ 85	0x0150	Ő (LATIN CAPITAL LETTER O WITH DOUBLE ACUTE)
+ 86	0x00D6	Ö (LATIN CAPITAL LETTER O WITH DIAERESIS)
+ 87	0x015A	Ś (LATIN CAPITAL LETTER S WITH ACUTE)
+ 88	0x0170	Ű (LATIN CAPITAL LETTER U WITH DOUBLE ACUTE)
+ 89	0x00D9	Ù (LATIN CAPITAL LETTER U WITH GRAVE)
+ 90	0x00DA	Ú (LATIN CAPITAL LETTER U WITH ACUTE)
+ 91	0x00DB	Û (LATIN CAPITAL LETTER U WITH CIRCUMFLEX)
+ 92	0x00DC	Ü (LATIN CAPITAL LETTER U WITH DIAERESIS)
+ 93	0x0118	Ę (LATIN CAPITAL LETTER E WITH OGONEK)
+ 94	0x021A	Ț (LATIN CAPITAL LETTER T WITH COMMA BELOW)
+ 95	0x00DF	ß (LATIN SMALL LETTER SHARP S)
+ 96	0x00E0	à (LATIN SMALL LETTER A WITH GRAVE)
+ 97	0x00E1	á (LATIN SMALL LETTER A WITH ACUTE)
+ 98	0x00E2	â (LATIN SMALL LETTER A WITH CIRCUMFLEX)
+ 99	0x0103	ă (LATIN SMALL LETTER A WITH BREVE)
+100	0x00E4	ä (LATIN SMALL LETTER A WITH DIAERESIS)
+101	0x0107	ć (LATIN SMALL LETTER C WITH ACUTE)
+102	0x00E6	æ (LATIN SMALL LETTER AE)
+103	0x00E7	ç (LATIN SMALL LETTER C WITH CEDILLA)
+104	0x00E8	è (LATIN SMALL LETTER E WITH GRAVE)
+105	0x00E9	é (LATIN SMALL LETTER E WITH ACUTE)
+106	0x00EA	ê (LATIN SMALL LETTER E WITH CIRCUMFLEX)
+107	0x00EB	ë (LATIN SMALL LETTER E WITH DIAERESIS)
+108	0x00EC	ì (LATIN SMALL LETTER I WITH GRAVE)
+109	0x00ED	í (LATIN SMALL LETTER I WITH ACUTE)
+110	0x00EE	î (LATIN SMALL LETTER I WITH CIRCUMFLEX)
+111	0x00EF	ï (LATIN SMALL LETTER I WITH DIAERESIS)
+112	0x0111	đ (LATIN SMALL LETTER D WITH STROKE)
+113	0x0144	ń (LATIN SMALL LETTER N WITH ACUTE)
+114	0x00F2	ò (LATIN SMALL LETTER O WITH GRAVE)
+115	0x00F3	ó (LATIN SMALL LETTER O WITH ACUTE)
+116	0x00F4	ô (LATIN SMALL LETTER O WITH CIRCUMFLEX)
+117	0x0151	ő (LATIN SMALL LETTER O WITH DOUBLE ACUTE)
+118	0x00F6	ö (LATIN SMALL LETTER O WITH DIAERESIS)
+119	0x015B	ś (LATIN SMALL LETTER S WITH ACUTE)
+120	0x0171	ű (LATIN SMALL LETTER U WITH DOUBLE ACUTE)
+121	0x00F9	ù (LATIN SMALL LETTER U WITH GRAVE)
+122	0x00FA	ú (LATIN SMALL LETTER U WITH ACUTE)
+123	0x00FB	û (LATIN SMALL LETTER U WITH CIRCUMFLEX)
+124	0x00FC	ü (LATIN SMALL LETTER U WITH DIAERESIS)
+125	0x0119	ę (LATIN SMALL LETTER E WITH OGONEK)
+126	0x021B	ț (LATIN SMALL LETTER T WITH COMMA BELOW)
+127	0x00FF	ÿ (LATIN SMALL LETTER Y WITH DIAERESIS)
diff --git a/test/js/node/test/fixtures/encoding/single-byte/index-iso-8859-2.txt b/test/js/node/test/fixtures/encoding/single-byte/index-iso-8859-2.txt
new file mode 100644
index 000000000000..3849517a980d
--- /dev/null
+++ b/test/js/node/test/fixtures/encoding/single-byte/index-iso-8859-2.txt
@@ -0,0 +1,134 @@
+# For details on index index-iso-8859-2.txt see the Encoding Standard
+# https://encoding.spec.whatwg.org/
+#
+# Identifier: 9569c67f22d0b57790e1c407c6eecf227e4562322dc296de43cdab7a0152ec73
+# Date: 2024-09-18
+
+  0	0x0080	€ (<control>)
+  1	0x0081	 (<control>)
+  2	0x0082	‚ (<control>)
+  3	0x0083	ƒ (<control>)
+  4	0x0084	„ (<control>)
+  5	0x0085	… (<control>)
+  6	0x0086	† (<control>)
+  7	0x0087	‡ (<control>)
+  8	0x0088	ˆ (<control>)
+  9	0x0089	‰ (<control>)
+ 10	0x008A	Š (<control>)
+ 11	0x008B	‹ (<control>)
+ 12	0x008C	Π(<control>)
+ 13	0x008D	 (<control>)
+ 14	0x008E	Ž (<control>)
+ 15	0x008F	 (<control>)
+ 16	0x0090	 (<control>)
+ 17	0x0091	‘ (<control>)
+ 18	0x0092	’ (<control>)
+ 19	0x0093	“ (<control>)
+ 20	0x0094	” (<control>)
+ 21	0x0095	• (<control>)
+ 22	0x0096	– (<control>)
+ 23	0x0097	— (<control>)
+ 24	0x0098	˜ (<control>)
+ 25	0x0099	™ (<control>)
+ 26	0x009A	š (<control>)
+ 27	0x009B	› (<control>)
+ 28	0x009C	œ (<control>)
+ 29	0x009D	 (<control>)
+ 30	0x009E	ž (<control>)
+ 31	0x009F	Ÿ (<control>)
+ 32	0x00A0	  (NO-BREAK SPACE)
+ 33	0x0104	Ą (LATIN CAPITAL LETTER A WITH OGONEK)
+ 34	0x02D8	˘ (BREVE)
+ 35	0x0141	Ł (LATIN CAPITAL LETTER L WITH STROKE)
+ 36	0x00A4	¤ (CURRENCY SIGN)
+ 37	0x013D	Ľ (LATIN CAPITAL LETTER L WITH CARON)
+ 38	0x015A	Ś (LATIN CAPITAL LETTER S WITH ACUTE)
+ 39	0x00A7	§ (SECTION SIGN)
+ 40	0x00A8	¨ (DIAERESIS)
+ 41	0x0160	Š (LATIN CAPITAL LETTER S WITH CARON)
+ 42	0x015E	Ş (LATIN CAPITAL LETTER S WITH CEDILLA)
+ 43	0x0164	Ť (LATIN CAPITAL LETTER T WITH CARON)
+ 44	0x0179	Ź (LATIN CAPITAL LETTER Z WITH ACUTE)
+ 45	0x00AD	­ (SOFT HYPHEN)
+ 46	0x017D	Ž (LATIN CAPITAL LETTER Z WITH CARON)
+ 47	0x017B	Ż (LATIN CAPITAL LETTER Z WITH DOT ABOVE)
+ 48	0x00B0	° (DEGREE SIGN)
+ 49	0x0105	ą (LATIN SMALL LETTER A WITH OGONEK)
+ 50	0x02DB	˛ (OGONEK)
+ 51	0x0142	ł (LATIN SMALL LETTER L WITH STROKE)
+ 52	0x00B4	´ (ACUTE ACCENT)
+ 53	0x013E	ľ (LATIN SMALL LETTER L WITH CARON)
+ 54	0x015B	ś (LATIN SMALL LETTER S WITH ACUTE)
+ 55	0x02C7	ˇ (CARON)
+ 56	0x00B8	¸ (CEDILLA)
+ 57	0x0161	š (LATIN SMALL LETTER S WITH CARON)
+ 58	0x015F	ş (LATIN SMALL LETTER S WITH CEDILLA)
+ 59	0x0165	ť (LATIN SMALL LETTER T WITH CARON)
+ 60	0x017A	ź (LATIN SMALL LETTER Z WITH ACUTE)
+ 61	0x02DD	˝ (DOUBLE ACUTE ACCENT)
+ 62	0x017E	ž (LATIN SMALL LETTER Z WITH CARON)
+ 63	0x017C	ż (LATIN SMALL LETTER Z WITH DOT ABOVE)
+ 64	0x0154	Ŕ (LATIN CAPITAL LETTER R WITH ACUTE)
+ 65	0x00C1	Á (LATIN CAPITAL LETTER A WITH ACUTE)
+ 66	0x00C2	Â (LATIN CAPITAL LETTER A WITH CIRCUMFLEX)
+ 67	0x0102	Ă (LATIN CAPITAL LETTER A WITH BREVE)
+ 68	0x00C4	Ä (LATIN CAPITAL LETTER A WITH DIAERESIS)
+ 69	0x0139	Ĺ (LATIN CAPITAL LETTER L WITH ACUTE)
+ 70	0x0106	Ć (LATIN CAPITAL LETTER C WITH ACUTE)
+ 71	0x00C7	Ç (LATIN CAPITAL LETTER C WITH CEDILLA)
+ 72	0x010C	Č (LATIN CAPITAL LETTER C WITH CARON)
+ 73	0x00C9	É (LATIN CAPITAL LETTER E WITH ACUTE)
+ 74	0x0118	Ę (LATIN CAPITAL LETTER E WITH OGONEK)
+ 75	0x00CB	Ë (LATIN CAPITAL LETTER E WITH DIAERESIS)
+ 76	0x011A	Ě (LATIN CAPITAL LETTER E WITH CARON)
+ 77	0x00CD	Í (LATIN CAPITAL LETTER I WITH ACUTE)
+ 78	0x00CE	Î (LATIN CAPITAL LETTER I WITH CIRCUMFLEX)
+ 79	0x010E	Ď (LATIN CAPITAL LETTER D WITH CARON)
+ 80	0x0110	Đ (LATIN CAPITAL LETTER D WITH STROKE)
+ 81	0x0143	Ń (LATIN CAPITAL LETTER N WITH ACUTE)
+ 82	0x0147	Ň (LATIN CAPITAL LETTER N WITH CARON)
+ 83	0x00D3	Ó (LATIN CAPITAL LETTER O WITH ACUTE)
+ 84	0x00D4	Ô (LATIN CAPITAL LETTER O WITH CIRCUMFLEX)
+ 85	0x0150	Ő (LATIN CAPITAL LETTER O WITH DOUBLE ACUTE)
+ 86	0x00D6	Ö (LATIN CAPITAL LETTER O WITH DIAERESIS)
+ 87	0x00D7	× (MULTIPLICATION SIGN)
+ 88	0x0158	Ř (LATIN CAPITAL LETTER R WITH CARON)
+ 89	0x016E	Ů (LATIN CAPITAL LETTER U WITH RING ABOVE)
+ 90	0x00DA	Ú (LATIN CAPITAL LETTER U WITH ACUTE)
+ 91	0x0170	Ű (LATIN CAPITAL LETTER U WITH DOUBLE ACUTE)
+ 92	0x00DC	Ü (LATIN CAPITAL LETTER U WITH DIAERESIS)
+ 93	0x00DD	Ý (LATIN CAPITAL LETTER Y WITH ACUTE)
+ 94	0x0162	Ţ (LATIN CAPITAL LETTER T WITH CEDILLA)
+ 95	0x00DF	ß (LATIN SMALL LETTER SHARP S)
+ 96	0x0155	ŕ (LATIN SMALL LETTER R WITH ACUTE)
+ 97	0x00E1	á (LATIN SMALL LETTER A WITH ACUTE)
+ 98	0x00E2	â (LATIN SMALL LETTER A WITH CIRCUMFLEX)
+ 99	0x0103	ă (LATIN SMALL LETTER A WITH BREVE)
+100	0x00E4	ä (LATIN SMALL LETTER A WITH DIAERESIS)
+101	0x013A	ĺ (LATIN SMALL LETTER L WITH ACUTE)
+102	0x0107	ć (LATIN SMALL LETTER C WITH ACUTE)
+103	0x00E7	ç (LATIN SMALL LETTER C WITH CEDILLA)
+104	0x010D	č (LATIN SMALL LETTER C WITH CARON)
+105	0x00E9	é (LATIN SMALL LETTER E WITH ACUTE)
+106	0x0119	ę (LATIN SMALL LETTER E WITH OGONEK)
+107	0x00EB	ë (LATIN SMALL LETTER E WITH DIAERESIS)
+108	0x011B	ě (LATIN SMALL LETTER E WITH CARON)
+109	0x00ED	í (LATIN SMALL LETTER I WITH ACUTE)
+110	0x00EE	î (LATIN SMALL LETTER I WITH CIRCUMFLEX)
+111	0x010F	ď (LATIN SMALL LETTER D WITH CARON)
+112	0x0111	đ (LATIN SMALL LETTER D WITH STROKE)
+113	0x0144	ń (LATIN SMALL LETTER N WITH ACUTE)
+114	0x0148	ň (LATIN SMALL LETTER N WITH CARON)
+115	0x00F3	ó (LATIN SMALL LETTER O WITH ACUTE)
+116	0x00F4	ô (LATIN SMALL LETTER O WITH CIRCUMFLEX)
+117	0x0151	ő (LATIN SMALL LETTER O WITH DOUBLE ACUTE)
+118	0x00F6	ö (LATIN SMALL LETTER O WITH DIAERESIS)
+119	0x00F7	÷ (DIVISION SIGN)
+120	0x0159	ř (LATIN SMALL LETTER R WITH CARON)
+121	0x016F	ů (LATIN SMALL LETTER U WITH RING ABOVE)
+122	0x00FA	ú (LATIN SMALL LETTER U WITH ACUTE)
+123	0x0171	ű (LATIN SMALL LETTER U WITH DOUBLE ACUTE)
+124	0x00FC	ü (LATIN SMALL LETTER U WITH DIAERESIS)
+125	0x00FD	ý (LATIN SMALL LETTER Y WITH ACUTE)
+126	0x0163	ţ (LATIN SMALL LETTER T WITH CEDILLA)
+127	0x02D9	˙ (DOT ABOVE)
diff --git a/test/js/node/test/fixtures/encoding/single-byte/index-iso-8859-3.txt b/test/js/node/test/fixtures/encoding/single-byte/index-iso-8859-3.txt
new file mode 100644
index 000000000000..e22c3b109996
--- /dev/null
+++ b/test/js/node/test/fixtures/encoding/single-byte/index-iso-8859-3.txt
@@ -0,0 +1,127 @@
+# For details on index index-iso-8859-3.txt see the Encoding Standard
+# https://encoding.spec.whatwg.org/
+#
+# Identifier: af8f1e12df79b768322b5e83613698cdc619438270a2fc359554331c805054a3
+# Date: 2024-09-18
+
+  0	0x0080	€ (<control>)
+  1	0x0081	 (<control>)
+  2	0x0082	‚ (<control>)
+  3	0x0083	ƒ (<control>)
+  4	0x0084	„ (<control>)
+  5	0x0085	… (<control>)
+  6	0x0086	† (<control>)
+  7	0x0087	‡ (<control>)
+  8	0x0088	ˆ (<control>)
+  9	0x0089	‰ (<control>)
+ 10	0x008A	Š (<control>)
+ 11	0x008B	‹ (<control>)
+ 12	0x008C	Π(<control>)
+ 13	0x008D	 (<control>)
+ 14	0x008E	Ž (<control>)
+ 15	0x008F	 (<control>)
+ 16	0x0090	 (<control>)
+ 17	0x0091	‘ (<control>)
+ 18	0x0092	’ (<control>)
+ 19	0x0093	“ (<control>)
+ 20	0x0094	” (<control>)
+ 21	0x0095	• (<control>)
+ 22	0x0096	– (<control>)
+ 23	0x0097	— (<control>)
+ 24	0x0098	˜ (<control>)
+ 25	0x0099	™ (<control>)
+ 26	0x009A	š (<control>)
+ 27	0x009B	› (<control>)
+ 28	0x009C	œ (<control>)
+ 29	0x009D	 (<control>)
+ 30	0x009E	ž (<control>)
+ 31	0x009F	Ÿ (<control>)
+ 32	0x00A0	  (NO-BREAK SPACE)
+ 33	0x0126	Ħ (LATIN CAPITAL LETTER H WITH STROKE)
+ 34	0x02D8	˘ (BREVE)
+ 35	0x00A3	£ (POUND SIGN)
+ 36	0x00A4	¤ (CURRENCY SIGN)
+ 38	0x0124	Ĥ (LATIN CAPITAL LETTER H WITH CIRCUMFLEX)
+ 39	0x00A7	§ (SECTION SIGN)
+ 40	0x00A8	¨ (DIAERESIS)
+ 41	0x0130	İ (LATIN CAPITAL LETTER I WITH DOT ABOVE)
+ 42	0x015E	Ş (LATIN CAPITAL LETTER S WITH CEDILLA)
+ 43	0x011E	Ğ (LATIN CAPITAL LETTER G WITH BREVE)
+ 44	0x0134	Ĵ (LATIN CAPITAL LETTER J WITH CIRCUMFLEX)
+ 45	0x00AD	­ (SOFT HYPHEN)
+ 47	0x017B	Ż (LATIN CAPITAL LETTER Z WITH DOT ABOVE)
+ 48	0x00B0	° (DEGREE SIGN)
+ 49	0x0127	ħ (LATIN SMALL LETTER H WITH STROKE)
+ 50	0x00B2	² (SUPERSCRIPT TWO)
+ 51	0x00B3	³ (SUPERSCRIPT THREE)
+ 52	0x00B4	´ (ACUTE ACCENT)
+ 53	0x00B5	µ (MICRO SIGN)
+ 54	0x0125	ĥ (LATIN SMALL LETTER H WITH CIRCUMFLEX)
+ 55	0x00B7	· (MIDDLE DOT)
+ 56	0x00B8	¸ (CEDILLA)
+ 57	0x0131	ı (LATIN SMALL LETTER DOTLESS I)
+ 58	0x015F	ş (LATIN SMALL LETTER S WITH CEDILLA)
+ 59	0x011F	ğ (LATIN SMALL LETTER G WITH BREVE)
+ 60	0x0135	ĵ (LATIN SMALL LETTER J WITH CIRCUMFLEX)
+ 61	0x00BD	½ (VULGAR FRACTION ONE HALF)
+ 63	0x017C	ż (LATIN SMALL LETTER Z WITH DOT ABOVE)
+ 64	0x00C0	À (LATIN CAPITAL LETTER A WITH GRAVE)
+ 65	0x00C1	Á (LATIN CAPITAL LETTER A WITH ACUTE)
+ 66	0x00C2	Â (LATIN CAPITAL LETTER A WITH CIRCUMFLEX)
+ 68	0x00C4	Ä (LATIN CAPITAL LETTER A WITH DIAERESIS)
+ 69	0x010A	Ċ (LATIN CAPITAL LETTER C WITH DOT ABOVE)
+ 70	0x0108	Ĉ (LATIN CAPITAL LETTER C WITH CIRCUMFLEX)
+ 71	0x00C7	Ç (LATIN CAPITAL LETTER C WITH CEDILLA)
+ 72	0x00C8	È (LATIN CAPITAL LETTER E WITH GRAVE)
+ 73	0x00C9	É (LATIN CAPITAL LETTER E WITH ACUTE)
+ 74	0x00CA	Ê (LATIN CAPITAL LETTER E WITH CIRCUMFLEX)
+ 75	0x00CB	Ë (LATIN CAPITAL LETTER E WITH DIAERESIS)
+ 76	0x00CC	Ì (LATIN CAPITAL LETTER I WITH GRAVE)
+ 77	0x00CD	Í (LATIN CAPITAL LETTER I WITH ACUTE)
+ 78	0x00CE	Î (LATIN CAPITAL LETTER I WITH CIRCUMFLEX)
+ 79	0x00CF	Ï (LATIN CAPITAL LETTER I WITH DIAERESIS)
+ 81	0x00D1	Ñ (LATIN CAPITAL LETTER N WITH TILDE)
+ 82	0x00D2	Ò (LATIN CAPITAL LETTER O WITH GRAVE)
+ 83	0x00D3	Ó (LATIN CAPITAL LETTER O WITH ACUTE)
+ 84	0x00D4	Ô (LATIN CAPITAL LETTER O WITH CIRCUMFLEX)
+ 85	0x0120	Ġ (LATIN CAPITAL LETTER G WITH DOT ABOVE)
+ 86	0x00D6	Ö (LATIN CAPITAL LETTER O WITH DIAERESIS)
+ 87	0x00D7	× (MULTIPLICATION SIGN)
+ 88	0x011C	Ĝ (LATIN CAPITAL LETTER G WITH CIRCUMFLEX)
+ 89	0x00D9	Ù (LATIN CAPITAL LETTER U WITH GRAVE)
+ 90	0x00DA	Ú (LATIN CAPITAL LETTER U WITH ACUTE)
+ 91	0x00DB	Û (LATIN CAPITAL LETTER U WITH CIRCUMFLEX)
+ 92	0x00DC	Ü (LATIN CAPITAL LETTER U WITH DIAERESIS)
+ 93	0x016C	Ŭ (LATIN CAPITAL LETTER U WITH BREVE)
+ 94	0x015C	Ŝ (LATIN CAPITAL LETTER S WITH CIRCUMFLEX)
+ 95	0x00DF	ß (LATIN SMALL LETTER SHARP S)
+ 96	0x00E0	à (LATIN SMALL LETTER A WITH GRAVE)
+ 97	0x00E1	á (LATIN SMALL LETTER A WITH ACUTE)
+ 98	0x00E2	â (LATIN SMALL LETTER A WITH CIRCUMFLEX)
+100	0x00E4	ä (LATIN SMALL LETTER A WITH DIAERESIS)
+101	0x010B	ċ (LATIN SMALL LETTER C WITH DOT ABOVE)
+102	0x0109	ĉ (LATIN SMALL LETTER C WITH CIRCUMFLEX)
+103	0x00E7	ç (LATIN SMALL LETTER C WITH CEDILLA)
+104	0x00E8	è (LATIN SMALL LETTER E WITH GRAVE)
+105	0x00E9	é (LATIN SMALL LETTER E WITH ACUTE)
+106	0x00EA	ê (LATIN SMALL LETTER E WITH CIRCUMFLEX)
+107	0x00EB	ë (LATIN SMALL LETTER E WITH DIAERESIS)
+108	0x00EC	ì (LATIN SMALL LETTER I WITH GRAVE)
+109	0x00ED	í (LATIN SMALL LETTER I WITH ACUTE)
+110	0x00EE	î (LATIN SMALL LETTER I WITH CIRCUMFLEX)
+111	0x00EF	ï (LATIN SMALL LETTER I WITH DIAERESIS)
+113	0x00F1	ñ (LATIN SMALL LETTER N WITH TILDE)
+114	0x00F2	ò (LATIN SMALL LETTER O WITH GRAVE)
+115	0x00F3	ó (LATIN SMALL LETTER O WITH ACUTE)
+116	0x00F4	ô (LATIN SMALL LETTER O WITH CIRCUMFLEX)
+117	0x0121	ġ (LATIN SMALL LETTER G WITH DOT ABOVE)
+118	0x00F6	ö (LATIN SMALL LETTER O WITH DIAERESIS)
+119	0x00F7	÷ (DIVISION SIGN)
+120	0x011D	ĝ (LATIN SMALL LETTER G WITH CIRCUMFLEX)
+121	0x00F9	ù (LATIN SMALL LETTER U WITH GRAVE)
+122	0x00FA	ú (LATIN SMALL LETTER U WITH ACUTE)
+123	0x00FB	û (LATIN SMALL LETTER U WITH CIRCUMFLEX)
+124	0x00FC	ü (LATIN SMALL LETTER U WITH DIAERESIS)
+125	0x016D	ŭ (LATIN SMALL LETTER U WITH BREVE)
+126	0x015D	ŝ (LATIN SMALL LETTER S WITH CIRCUMFLEX)
+127	0x02D9	˙ (DOT ABOVE)
diff --git a/test/js/node/test/fixtures/encoding/single-byte/index-iso-8859-4.txt b/test/js/node/test/fixtures/encoding/single-byte/index-iso-8859-4.txt
new file mode 100644
index 000000000000..bd7f1270117c
--- /dev/null
+++ b/test/js/node/test/fixtures/encoding/single-byte/index-iso-8859-4.txt
@@ -0,0 +1,134 @@
+# For details on index index-iso-8859-4.txt see the Encoding Standard
+# https://encoding.spec.whatwg.org/
+#
+# Identifier: 72f29c92344d351fe9e74a946e7e0468d76d542c6894ff82982cb652ebe0feb7
+# Date: 2024-09-18
+
+  0	0x0080	€ (<control>)
+  1	0x0081	 (<control>)
+  2	0x0082	‚ (<control>)
+  3	0x0083	ƒ (<control>)
+  4	0x0084	„ (<control>)
+  5	0x0085	… (<control>)
+  6	0x0086	† (<control>)
+  7	0x0087	‡ (<control>)
+  8	0x0088	ˆ (<control>)
+  9	0x0089	‰ (<control>)
+ 10	0x008A	Š (<control>)
+ 11	0x008B	‹ (<control>)
+ 12	0x008C	Π(<control>)
+ 13	0x008D	 (<control>)
+ 14	0x008E	Ž (<control>)
+ 15	0x008F	 (<control>)
+ 16	0x0090	 (<control>)
+ 17	0x0091	‘ (<control>)
+ 18	0x0092	’ (<control>)
+ 19	0x0093	“ (<control>)
+ 20	0x0094	” (<control>)
+ 21	0x0095	• (<control>)
+ 22	0x0096	– (<control>)
+ 23	0x0097	— (<control>)
+ 24	0x0098	˜ (<control>)
+ 25	0x0099	™ (<control>)
+ 26	0x009A	š (<control>)
+ 27	0x009B	› (<control>)
+ 28	0x009C	œ (<control>)
+ 29	0x009D	 (<control>)
+ 30	0x009E	ž (<control>)
+ 31	0x009F	Ÿ (<control>)
+ 32	0x00A0	  (NO-BREAK SPACE)
+ 33	0x0104	Ą (LATIN CAPITAL LETTER A WITH OGONEK)
+ 34	0x0138	ĸ (LATIN SMALL LETTER KRA)
+ 35	0x0156	Ŗ (LATIN CAPITAL LETTER R WITH CEDILLA)
+ 36	0x00A4	¤ (CURRENCY SIGN)
+ 37	0x0128	Ĩ (LATIN CAPITAL LETTER I WITH TILDE)
+ 38	0x013B	Ļ (LATIN CAPITAL LETTER L WITH CEDILLA)
+ 39	0x00A7	§ (SECTION SIGN)
+ 40	0x00A8	¨ (DIAERESIS)
+ 41	0x0160	Š (LATIN CAPITAL LETTER S WITH CARON)
+ 42	0x0112	Ē (LATIN CAPITAL LETTER E WITH MACRON)
+ 43	0x0122	Ģ (LATIN CAPITAL LETTER G WITH CEDILLA)
+ 44	0x0166	Ŧ (LATIN CAPITAL LETTER T WITH STROKE)
+ 45	0x00AD	­ (SOFT HYPHEN)
+ 46	0x017D	Ž (LATIN CAPITAL LETTER Z WITH CARON)
+ 47	0x00AF	¯ (MACRON)
+ 48	0x00B0	° (DEGREE SIGN)
+ 49	0x0105	ą (LATIN SMALL LETTER A WITH OGONEK)
+ 50	0x02DB	˛ (OGONEK)
+ 51	0x0157	ŗ (LATIN SMALL LETTER R WITH CEDILLA)
+ 52	0x00B4	´ (ACUTE ACCENT)
+ 53	0x0129	ĩ (LATIN SMALL LETTER I WITH TILDE)
+ 54	0x013C	ļ (LATIN SMALL LETTER L WITH CEDILLA)
+ 55	0x02C7	ˇ (CARON)
+ 56	0x00B8	¸ (CEDILLA)
+ 57	0x0161	š (LATIN SMALL LETTER S WITH CARON)
+ 58	0x0113	ē (LATIN SMALL LETTER E WITH MACRON)
+ 59	0x0123	ģ (LATIN SMALL LETTER G WITH CEDILLA)
+ 60	0x0167	ŧ (LATIN SMALL LETTER T WITH STROKE)
+ 61	0x014A	Ŋ (LATIN CAPITAL LETTER ENG)
+ 62	0x017E	ž (LATIN SMALL LETTER Z WITH CARON)
+ 63	0x014B	ŋ (LATIN SMALL LETTER ENG)
+ 64	0x0100	Ā (LATIN CAPITAL LETTER A WITH MACRON)
+ 65	0x00C1	Á (LATIN CAPITAL LETTER A WITH ACUTE)
+ 66	0x00C2	Â (LATIN CAPITAL LETTER A WITH CIRCUMFLEX)
+ 67	0x00C3	Ã (LATIN CAPITAL LETTER A WITH TILDE)
+ 68	0x00C4	Ä (LATIN CAPITAL LETTER A WITH DIAERESIS)
+ 69	0x00C5	Å (LATIN CAPITAL LETTER A WITH RING ABOVE)
+ 70	0x00C6	Æ (LATIN CAPITAL LETTER AE)
+ 71	0x012E	Į (LATIN CAPITAL LETTER I WITH OGONEK)
+ 72	0x010C	Č (LATIN CAPITAL LETTER C WITH CARON)
+ 73	0x00C9	É (LATIN CAPITAL LETTER E WITH ACUTE)
+ 74	0x0118	Ę (LATIN CAPITAL LETTER E WITH OGONEK)
+ 75	0x00CB	Ë (LATIN CAPITAL LETTER E WITH DIAERESIS)
+ 76	0x0116	Ė (LATIN CAPITAL LETTER E WITH DOT ABOVE)
+ 77	0x00CD	Í (LATIN CAPITAL LETTER I WITH ACUTE)
+ 78	0x00CE	Î (LATIN CAPITAL LETTER I WITH CIRCUMFLEX)
+ 79	0x012A	Ī (LATIN CAPITAL LETTER I WITH MACRON)
+ 80	0x0110	Đ (LATIN CAPITAL LETTER D WITH STROKE)
+ 81	0x0145	Ņ (LATIN CAPITAL LETTER N WITH CEDILLA)
+ 82	0x014C	Ō (LATIN CAPITAL LETTER O WITH MACRON)
+ 83	0x0136	Ķ (LATIN CAPITAL LETTER K WITH CEDILLA)
+ 84	0x00D4	Ô (LATIN CAPITAL LETTER O WITH CIRCUMFLEX)
+ 85	0x00D5	Õ (LATIN CAPITAL LETTER O WITH TILDE)
+ 86	0x00D6	Ö (LATIN CAPITAL LETTER O WITH DIAERESIS)
+ 87	0x00D7	× (MULTIPLICATION SIGN)
+ 88	0x00D8	Ø (LATIN CAPITAL LETTER O WITH STROKE)
+ 89	0x0172	Ų (LATIN CAPITAL LETTER U WITH OGONEK)
+ 90	0x00DA	Ú (LATIN CAPITAL LETTER U WITH ACUTE)
+ 91	0x00DB	Û (LATIN CAPITAL LETTER U WITH CIRCUMFLEX)
+ 92	0x00DC	Ü (LATIN CAPITAL LETTER U WITH DIAERESIS)
+ 93	0x0168	Ũ (LATIN CAPITAL LETTER U WITH TILDE)
+ 94	0x016A	Ū (LATIN CAPITAL LETTER U WITH MACRON)
+ 95	0x00DF	ß (LATIN SMALL LETTER SHARP S)
+ 96	0x0101	ā (LATIN SMALL LETTER A WITH MACRON)
+ 97	0x00E1	á (LATIN SMALL LETTER A WITH ACUTE)
+ 98	0x00E2	â (LATIN SMALL LETTER A WITH CIRCUMFLEX)
+ 99	0x00E3	ã (LATIN SMALL LETTER A WITH TILDE)
+100	0x00E4	ä (LATIN SMALL LETTER A WITH DIAERESIS)
+101	0x00E5	å (LATIN SMALL LETTER A WITH RING ABOVE)
+102	0x00E6	æ (LATIN SMALL LETTER AE)
+103	0x012F	į (LATIN SMALL LETTER I WITH OGONEK)
+104	0x010D	č (LATIN SMALL LETTER C WITH CARON)
+105	0x00E9	é (LATIN SMALL LETTER E WITH ACUTE)
+106	0x0119	ę (LATIN SMALL LETTER E WITH OGONEK)
+107	0x00EB	ë (LATIN SMALL LETTER E WITH DIAERESIS)
+108	0x0117	ė (LATIN SMALL LETTER E WITH DOT ABOVE)
+109	0x00ED	í (LATIN SMALL LETTER I WITH ACUTE)
+110	0x00EE	î (LATIN SMALL LETTER I WITH CIRCUMFLEX)
+111	0x012B	ī (LATIN SMALL LETTER I WITH MACRON)
+112	0x0111	đ (LATIN SMALL LETTER D WITH STROKE)
+113	0x0146	ņ (LATIN SMALL LETTER N WITH CEDILLA)
+114	0x014D	ō (LATIN SMALL LETTER O WITH MACRON)
+115	0x0137	ķ (LATIN SMALL LETTER K WITH CEDILLA)
+116	0x00F4	ô (LATIN SMALL LETTER O WITH CIRCUMFLEX)
+117	0x00F5	õ (LATIN SMALL LETTER O WITH TILDE)
+118	0x00F6	ö (LATIN SMALL LETTER O WITH DIAERESIS)
+119	0x00F7	÷ (DIVISION SIGN)
+120	0x00F8	ø (LATIN SMALL LETTER O WITH STROKE)
+121	0x0173	ų (LATIN SMALL LETTER U WITH OGONEK)
+122	0x00FA	ú (LATIN SMALL LETTER U WITH ACUTE)
+123	0x00FB	û (LATIN SMALL LETTER U WITH CIRCUMFLEX)
+124	0x00FC	ü (LATIN SMALL LETTER U WITH DIAERESIS)
+125	0x0169	ũ (LATIN SMALL LETTER U WITH TILDE)
+126	0x016B	ū (LATIN SMALL LETTER U WITH MACRON)
+127	0x02D9	˙ (DOT ABOVE)
diff --git a/test/js/node/test/fixtures/encoding/single-byte/index-iso-8859-5.txt b/test/js/node/test/fixtures/encoding/single-byte/index-iso-8859-5.txt
new file mode 100644
index 000000000000..fd0967008811
--- /dev/null
+++ b/test/js/node/test/fixtures/encoding/single-byte/index-iso-8859-5.txt
@@ -0,0 +1,134 @@
+# For details on index index-iso-8859-5.txt see the Encoding Standard
+# https://encoding.spec.whatwg.org/
+#
+# Identifier: fa9b1f3f5242df43e2e7bca80e9b6997c67944f20a4af91ee06bacc4e132d9c9
+# Date: 2024-09-18
+
+  0	0x0080	€ (<control>)
+  1	0x0081	 (<control>)
+  2	0x0082	‚ (<control>)
+  3	0x0083	ƒ (<control>)
+  4	0x0084	„ (<control>)
+  5	0x0085	… (<control>)
+  6	0x0086	† (<control>)
+  7	0x0087	‡ (<control>)
+  8	0x0088	ˆ (<control>)
+  9	0x0089	‰ (<control>)
+ 10	0x008A	Š (<control>)
+ 11	0x008B	‹ (<control>)
+ 12	0x008C	Π(<control>)
+ 13	0x008D	 (<control>)
+ 14	0x008E	Ž (<control>)
+ 15	0x008F	 (<control>)
+ 16	0x0090	 (<control>)
+ 17	0x0091	‘ (<control>)
+ 18	0x0092	’ (<control>)
+ 19	0x0093	“ (<control>)
+ 20	0x0094	” (<control>)
+ 21	0x0095	• (<control>)
+ 22	0x0096	– (<control>)
+ 23	0x0097	— (<control>)
+ 24	0x0098	˜ (<control>)
+ 25	0x0099	™ (<control>)
+ 26	0x009A	š (<control>)
+ 27	0x009B	› (<control>)
+ 28	0x009C	œ (<control>)
+ 29	0x009D	 (<control>)
+ 30	0x009E	ž (<control>)
+ 31	0x009F	Ÿ (<control>)
+ 32	0x00A0	  (NO-BREAK SPACE)
+ 33	0x0401	Ё (CYRILLIC CAPITAL LETTER IO)
+ 34	0x0402	Ђ (CYRILLIC CAPITAL LETTER DJE)
+ 35	0x0403	Ѓ (CYRILLIC CAPITAL LETTER GJE)
+ 36	0x0404	Є (CYRILLIC CAPITAL LETTER UKRAINIAN IE)
+ 37	0x0405	Ѕ (CYRILLIC CAPITAL LETTER DZE)
+ 38	0x0406	І (CYRILLIC CAPITAL LETTER BYELORUSSIAN-UKRAINIAN I)
+ 39	0x0407	Ї (CYRILLIC CAPITAL LETTER YI)
+ 40	0x0408	Ј (CYRILLIC CAPITAL LETTER JE)
+ 41	0x0409	Љ (CYRILLIC CAPITAL LETTER LJE)
+ 42	0x040A	Њ (CYRILLIC CAPITAL LETTER NJE)
+ 43	0x040B	Ћ (CYRILLIC CAPITAL LETTER TSHE)
+ 44	0x040C	Ќ (CYRILLIC CAPITAL LETTER KJE)
+ 45	0x00AD	­ (SOFT HYPHEN)
+ 46	0x040E	Ў (CYRILLIC CAPITAL LETTER SHORT U)
+ 47	0x040F	Џ (CYRILLIC CAPITAL LETTER DZHE)
+ 48	0x0410	А (CYRILLIC CAPITAL LETTER A)
+ 49	0x0411	Б (CYRILLIC CAPITAL LETTER BE)
+ 50	0x0412	В (CYRILLIC CAPITAL LETTER VE)
+ 51	0x0413	Г (CYRILLIC CAPITAL LETTER GHE)
+ 52	0x0414	Д (CYRILLIC CAPITAL LETTER DE)
+ 53	0x0415	Е (CYRILLIC CAPITAL LETTER IE)
+ 54	0x0416	Ж (CYRILLIC CAPITAL LETTER ZHE)
+ 55	0x0417	З (CYRILLIC CAPITAL LETTER ZE)
+ 56	0x0418	И (CYRILLIC CAPITAL LETTER I)
+ 57	0x0419	Й (CYRILLIC CAPITAL LETTER SHORT I)
+ 58	0x041A	К (CYRILLIC CAPITAL LETTER KA)
+ 59	0x041B	Л (CYRILLIC CAPITAL LETTER EL)
+ 60	0x041C	М (CYRILLIC CAPITAL LETTER EM)
+ 61	0x041D	Н (CYRILLIC CAPITAL LETTER EN)
+ 62	0x041E	О (CYRILLIC CAPITAL LETTER O)
+ 63	0x041F	П (CYRILLIC CAPITAL LETTER PE)
+ 64	0x0420	Р (CYRILLIC CAPITAL LETTER ER)
+ 65	0x0421	С (CYRILLIC CAPITAL LETTER ES)
+ 66	0x0422	Т (CYRILLIC CAPITAL LETTER TE)
+ 67	0x0423	У (CYRILLIC CAPITAL LETTER U)
+ 68	0x0424	Ф (CYRILLIC CAPITAL LETTER EF)
+ 69	0x0425	Х (CYRILLIC CAPITAL LETTER HA)
+ 70	0x0426	Ц (CYRILLIC CAPITAL LETTER TSE)
+ 71	0x0427	Ч (CYRILLIC CAPITAL LETTER CHE)
+ 72	0x0428	Ш (CYRILLIC CAPITAL LETTER SHA)
+ 73	0x0429	Щ (CYRILLIC CAPITAL LETTER SHCHA)
+ 74	0x042A	Ъ (CYRILLIC CAPITAL LETTER HARD SIGN)
+ 75	0x042B	Ы (CYRILLIC CAPITAL LETTER YERU)
+ 76	0x042C	Ь (CYRILLIC CAPITAL LETTER SOFT SIGN)
+ 77	0x042D	Э (CYRILLIC CAPITAL LETTER E)
+ 78	0x042E	Ю (CYRILLIC CAPITAL LETTER YU)
+ 79	0x042F	Я (CYRILLIC CAPITAL LETTER YA)
+ 80	0x0430	а (CYRILLIC SMALL LETTER A)
+ 81	0x0431	б (CYRILLIC SMALL LETTER BE)
+ 82	0x0432	в (CYRILLIC SMALL LETTER VE)
+ 83	0x0433	г (CYRILLIC SMALL LETTER GHE)
+ 84	0x0434	д (CYRILLIC SMALL LETTER DE)
+ 85	0x0435	е (CYRILLIC SMALL LETTER IE)
+ 86	0x0436	ж (CYRILLIC SMALL LETTER ZHE)
+ 87	0x0437	з (CYRILLIC SMALL LETTER ZE)
+ 88	0x0438	и (CYRILLIC SMALL LETTER I)
+ 89	0x0439	й (CYRILLIC SMALL LETTER SHORT I)
+ 90	0x043A	к (CYRILLIC SMALL LETTER KA)
+ 91	0x043B	л (CYRILLIC SMALL LETTER EL)
+ 92	0x043C	м (CYRILLIC SMALL LETTER EM)
+ 93	0x043D	н (CYRILLIC SMALL LETTER EN)
+ 94	0x043E	о (CYRILLIC SMALL LETTER O)
+ 95	0x043F	п (CYRILLIC SMALL LETTER PE)
+ 96	0x0440	р (CYRILLIC SMALL LETTER ER)
+ 97	0x0441	с (CYRILLIC SMALL LETTER ES)
+ 98	0x0442	т (CYRILLIC SMALL LETTER TE)
+ 99	0x0443	у (CYRILLIC SMALL LETTER U)
+100	0x0444	ф (CYRILLIC SMALL LETTER EF)
+101	0x0445	х (CYRILLIC SMALL LETTER HA)
+102	0x0446	ц (CYRILLIC SMALL LETTER TSE)
+103	0x0447	ч (CYRILLIC SMALL LETTER CHE)
+104	0x0448	ш (CYRILLIC SMALL LETTER SHA)
+105	0x0449	щ (CYRILLIC SMALL LETTER SHCHA)
+106	0x044A	ъ (CYRILLIC SMALL LETTER HARD SIGN)
+107	0x044B	ы (CYRILLIC SMALL LETTER YERU)
+108	0x044C	ь (CYRILLIC SMALL LETTER SOFT SIGN)
+109	0x044D	э (CYRILLIC SMALL LETTER E)
+110	0x044E	ю (CYRILLIC SMALL LETTER YU)
+111	0x044F	я (CYRILLIC SMALL LETTER YA)
+112	0x2116	№ (NUMERO SIGN)
+113	0x0451	ё (CYRILLIC SMALL LETTER IO)
+114	0x0452	ђ (CYRILLIC SMALL LETTER DJE)
+115	0x0453	ѓ (CYRILLIC SMALL LETTER GJE)
+116	0x0454	є (CYRILLIC SMALL LETTER UKRAINIAN IE)
+117	0x0455	ѕ (CYRILLIC SMALL LETTER DZE)
+118	0x0456	і (CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I)
+119	0x0457	ї (CYRILLIC SMALL LETTER YI)
+120	0x0458	ј (CYRILLIC SMALL LETTER JE)
+121	0x0459	љ (CYRILLIC SMALL LETTER LJE)
+122	0x045A	њ (CYRILLIC SMALL LETTER NJE)
+123	0x045B	ћ (CYRILLIC SMALL LETTER TSHE)
+124	0x045C	ќ (CYRILLIC SMALL LETTER KJE)
+125	0x00A7	§ (SECTION SIGN)
+126	0x045E	ў (CYRILLIC SMALL LETTER SHORT U)
+127	0x045F	џ (CYRILLIC SMALL LETTER DZHE)
diff --git a/test/js/node/test/fixtures/encoding/single-byte/index-iso-8859-6.txt b/test/js/node/test/fixtures/encoding/single-byte/index-iso-8859-6.txt
new file mode 100644
index 000000000000..8a6869100f0d
--- /dev/null
+++ b/test/js/node/test/fixtures/encoding/single-byte/index-iso-8859-6.txt
@@ -0,0 +1,89 @@
+# For details on index index-iso-8859-6.txt see the Encoding Standard
+# https://encoding.spec.whatwg.org/
+#
+# Identifier: 85bb7b5c2dc75975afebe5743935ba4ed5a09c1e9e34e9bfb2ff80293f5d8bbc
+# Date: 2024-09-18
+
+  0	0x0080	€ (<control>)
+  1	0x0081	 (<control>)
+  2	0x0082	‚ (<control>)
+  3	0x0083	ƒ (<control>)
+  4	0x0084	„ (<control>)
+  5	0x0085	… (<control>)
+  6	0x0086	† (<control>)
+  7	0x0087	‡ (<control>)
+  8	0x0088	ˆ (<control>)
+  9	0x0089	‰ (<control>)
+ 10	0x008A	Š (<control>)
+ 11	0x008B	‹ (<control>)
+ 12	0x008C	Π(<control>)
+ 13	0x008D	 (<control>)
+ 14	0x008E	Ž (<control>)
+ 15	0x008F	 (<control>)
+ 16	0x0090	 (<control>)
+ 17	0x0091	‘ (<control>)
+ 18	0x0092	’ (<control>)
+ 19	0x0093	“ (<control>)
+ 20	0x0094	” (<control>)
+ 21	0x0095	• (<control>)
+ 22	0x0096	– (<control>)
+ 23	0x0097	— (<control>)
+ 24	0x0098	˜ (<control>)
+ 25	0x0099	™ (<control>)
+ 26	0x009A	š (<control>)
+ 27	0x009B	› (<control>)
+ 28	0x009C	œ (<control>)
+ 29	0x009D	 (<control>)
+ 30	0x009E	ž (<control>)
+ 31	0x009F	Ÿ (<control>)
+ 32	0x00A0	  (NO-BREAK SPACE)
+ 36	0x00A4	¤ (CURRENCY SIGN)
+ 44	0x060C	، (ARABIC COMMA)
+ 45	0x00AD	­ (SOFT HYPHEN)
+ 59	0x061B	؛ (ARABIC SEMICOLON)
+ 63	0x061F	؟ (ARABIC QUESTION MARK)
+ 65	0x0621	ء (ARABIC LETTER HAMZA)
+ 66	0x0622	آ (ARABIC LETTER ALEF WITH MADDA ABOVE)
+ 67	0x0623	أ (ARABIC LETTER ALEF WITH HAMZA ABOVE)
+ 68	0x0624	ؤ (ARABIC LETTER WAW WITH HAMZA ABOVE)
+ 69	0x0625	إ (ARABIC LETTER ALEF WITH HAMZA BELOW)
+ 70	0x0626	ئ (ARABIC LETTER YEH WITH HAMZA ABOVE)
+ 71	0x0627	ا (ARABIC LETTER ALEF)
+ 72	0x0628	ب (ARABIC LETTER BEH)
+ 73	0x0629	ة (ARABIC LETTER TEH MARBUTA)
+ 74	0x062A	ت (ARABIC LETTER TEH)
+ 75	0x062B	ث (ARABIC LETTER THEH)
+ 76	0x062C	ج (ARABIC LETTER JEEM)
+ 77	0x062D	ح (ARABIC LETTER HAH)
+ 78	0x062E	خ (ARABIC LETTER KHAH)
+ 79	0x062F	د (ARABIC LETTER DAL)
+ 80	0x0630	ذ (ARABIC LETTER THAL)
+ 81	0x0631	ر (ARABIC LETTER REH)
+ 82	0x0632	ز (ARABIC LETTER ZAIN)
+ 83	0x0633	س (ARABIC LETTER SEEN)
+ 84	0x0634	ش (ARABIC LETTER SHEEN)
+ 85	0x0635	ص (ARABIC LETTER SAD)
+ 86	0x0636	ض (ARABIC LETTER DAD)
+ 87	0x0637	ط (ARABIC LETTER TAH)
+ 88	0x0638	ظ (ARABIC LETTER ZAH)
+ 89	0x0639	ع (ARABIC LETTER AIN)
+ 90	0x063A	غ (ARABIC LETTER GHAIN)
+ 96	0x0640	ـ (ARABIC TATWEEL)
+ 97	0x0641	ف (ARABIC LETTER FEH)
+ 98	0x0642	ق (ARABIC LETTER QAF)
+ 99	0x0643	ك (ARABIC LETTER KAF)
+100	0x0644	ل (ARABIC LETTER LAM)
+101	0x0645	م (ARABIC LETTER MEEM)
+102	0x0646	ن (ARABIC LETTER NOON)
+103	0x0647	ه (ARABIC LETTER HEH)
+104	0x0648	و (ARABIC LETTER WAW)
+105	0x0649	ى (ARABIC LETTER ALEF MAKSURA)
+106	0x064A	ي (ARABIC LETTER YEH)
+107	0x064B	ً (ARABIC FATHATAN)
+108	0x064C	ٌ (ARABIC DAMMATAN)
+109	0x064D	ٍ (ARABIC KASRATAN)
+110	0x064E	َ (ARABIC FATHA)
+111	0x064F	ُ (ARABIC DAMMA)
+112	0x0650	ِ (ARABIC KASRA)
+113	0x0651	ّ (ARABIC SHADDA)
+114	0x0652	ْ (ARABIC SUKUN)
diff --git a/test/js/node/test/fixtures/encoding/single-byte/index-iso-8859-7.txt b/test/js/node/test/fixtures/encoding/single-byte/index-iso-8859-7.txt
new file mode 100644
index 000000000000..484683ddcfd8
--- /dev/null
+++ b/test/js/node/test/fixtures/encoding/single-byte/index-iso-8859-7.txt
@@ -0,0 +1,131 @@
+# For details on index index-iso-8859-7.txt see the Encoding Standard
+# https://encoding.spec.whatwg.org/
+#
+# Identifier: f53d8aeba36314ef950eef02ffcf11dff540638ce27dfe7a86b6ccc6875afb24
+# Date: 2024-09-18
+
+  0	0x0080	€ (<control>)
+  1	0x0081	 (<control>)
+  2	0x0082	‚ (<control>)
+  3	0x0083	ƒ (<control>)
+  4	0x0084	„ (<control>)
+  5	0x0085	… (<control>)
+  6	0x0086	† (<control>)
+  7	0x0087	‡ (<control>)
+  8	0x0088	ˆ (<control>)
+  9	0x0089	‰ (<control>)
+ 10	0x008A	Š (<control>)
+ 11	0x008B	‹ (<control>)
+ 12	0x008C	Π(<control>)
+ 13	0x008D	 (<control>)
+ 14	0x008E	Ž (<control>)
+ 15	0x008F	 (<control>)
+ 16	0x0090	 (<control>)
+ 17	0x0091	‘ (<control>)
+ 18	0x0092	’ (<control>)
+ 19	0x0093	“ (<control>)
+ 20	0x0094	” (<control>)
+ 21	0x0095	• (<control>)
+ 22	0x0096	– (<control>)
+ 23	0x0097	— (<control>)
+ 24	0x0098	˜ (<control>)
+ 25	0x0099	™ (<control>)
+ 26	0x009A	š (<control>)
+ 27	0x009B	› (<control>)
+ 28	0x009C	œ (<control>)
+ 29	0x009D	 (<control>)
+ 30	0x009E	ž (<control>)
+ 31	0x009F	Ÿ (<control>)
+ 32	0x00A0	  (NO-BREAK SPACE)
+ 33	0x2018	‘ (LEFT SINGLE QUOTATION MARK)
+ 34	0x2019	’ (RIGHT SINGLE QUOTATION MARK)
+ 35	0x00A3	£ (POUND SIGN)
+ 36	0x20AC	€ (EURO SIGN)
+ 37	0x20AF	₯ (DRACHMA SIGN)
+ 38	0x00A6	¦ (BROKEN BAR)
+ 39	0x00A7	§ (SECTION SIGN)
+ 40	0x00A8	¨ (DIAERESIS)
+ 41	0x00A9	© (COPYRIGHT SIGN)
+ 42	0x037A	ͺ (GREEK YPOGEGRAMMENI)
+ 43	0x00AB	« (LEFT-POINTING DOUBLE ANGLE QUOTATION MARK)
+ 44	0x00AC	¬ (NOT SIGN)
+ 45	0x00AD	­ (SOFT HYPHEN)
+ 47	0x2015	― (HORIZONTAL BAR)
+ 48	0x00B0	° (DEGREE SIGN)
+ 49	0x00B1	± (PLUS-MINUS SIGN)
+ 50	0x00B2	² (SUPERSCRIPT TWO)
+ 51	0x00B3	³ (SUPERSCRIPT THREE)
+ 52	0x0384	΄ (GREEK TONOS)
+ 53	0x0385	΅ (GREEK DIALYTIKA TONOS)
+ 54	0x0386	Ά (GREEK CAPITAL LETTER ALPHA WITH TONOS)
+ 55	0x00B7	· (MIDDLE DOT)
+ 56	0x0388	Έ (GREEK CAPITAL LETTER EPSILON WITH TONOS)
+ 57	0x0389	Ή (GREEK CAPITAL LETTER ETA WITH TONOS)
+ 58	0x038A	Ί (GREEK CAPITAL LETTER IOTA WITH TONOS)
+ 59	0x00BB	» (RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK)
+ 60	0x038C	Ό (GREEK CAPITAL LETTER OMICRON WITH TONOS)
+ 61	0x00BD	½ (VULGAR FRACTION ONE HALF)
+ 62	0x038E	Ύ (GREEK CAPITAL LETTER UPSILON WITH TONOS)
+ 63	0x038F	Ώ (GREEK CAPITAL LETTER OMEGA WITH TONOS)
+ 64	0x0390	ΐ (GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS)
+ 65	0x0391	Α (GREEK CAPITAL LETTER ALPHA)
+ 66	0x0392	Β (GREEK CAPITAL LETTER BETA)
+ 67	0x0393	Γ (GREEK CAPITAL LETTER GAMMA)
+ 68	0x0394	Δ (GREEK CAPITAL LETTER DELTA)
+ 69	0x0395	Ε (GREEK CAPITAL LETTER EPSILON)
+ 70	0x0396	Ζ (GREEK CAPITAL LETTER ZETA)
+ 71	0x0397	Η (GREEK CAPITAL LETTER ETA)
+ 72	0x0398	Θ (GREEK CAPITAL LETTER THETA)
+ 73	0x0399	Ι (GREEK CAPITAL LETTER IOTA)
+ 74	0x039A	Κ (GREEK CAPITAL LETTER KAPPA)
+ 75	0x039B	Λ (GREEK CAPITAL LETTER LAMDA)
+ 76	0x039C	Μ (GREEK CAPITAL LETTER MU)
+ 77	0x039D	Ν (GREEK CAPITAL LETTER NU)
+ 78	0x039E	Ξ (GREEK CAPITAL LETTER XI)
+ 79	0x039F	Ο (GREEK CAPITAL LETTER OMICRON)
+ 80	0x03A0	Π (GREEK CAPITAL LETTER PI)
+ 81	0x03A1	Ρ (GREEK CAPITAL LETTER RHO)
+ 83	0x03A3	Σ (GREEK CAPITAL LETTER SIGMA)
+ 84	0x03A4	Τ (GREEK CAPITAL LETTER TAU)
+ 85	0x03A5	Υ (GREEK CAPITAL LETTER UPSILON)
+ 86	0x03A6	Φ (GREEK CAPITAL LETTER PHI)
+ 87	0x03A7	Χ (GREEK CAPITAL LETTER CHI)
+ 88	0x03A8	Ψ (GREEK CAPITAL LETTER PSI)
+ 89	0x03A9	Ω (GREEK CAPITAL LETTER OMEGA)
+ 90	0x03AA	Ϊ (GREEK CAPITAL LETTER IOTA WITH DIALYTIKA)
+ 91	0x03AB	Ϋ (GREEK CAPITAL LETTER UPSILON WITH DIALYTIKA)
+ 92	0x03AC	ά (GREEK SMALL LETTER ALPHA WITH TONOS)
+ 93	0x03AD	έ (GREEK SMALL LETTER EPSILON WITH TONOS)
+ 94	0x03AE	ή (GREEK SMALL LETTER ETA WITH TONOS)
+ 95	0x03AF	ί (GREEK SMALL LETTER IOTA WITH TONOS)
+ 96	0x03B0	ΰ (GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS)
+ 97	0x03B1	α (GREEK SMALL LETTER ALPHA)
+ 98	0x03B2	β (GREEK SMALL LETTER BETA)
+ 99	0x03B3	γ (GREEK SMALL LETTER GAMMA)
+100	0x03B4	δ (GREEK SMALL LETTER DELTA)
+101	0x03B5	ε (GREEK SMALL LETTER EPSILON)
+102	0x03B6	ζ (GREEK SMALL LETTER ZETA)
+103	0x03B7	η (GREEK SMALL LETTER ETA)
+104	0x03B8	θ (GREEK SMALL LETTER THETA)
+105	0x03B9	ι (GREEK SMALL LETTER IOTA)
+106	0x03BA	κ (GREEK SMALL LETTER KAPPA)
+107	0x03BB	λ (GREEK SMALL LETTER LAMDA)
+108	0x03BC	μ (GREEK SMALL LETTER MU)
+109	0x03BD	ν (GREEK SMALL LETTER NU)
+110	0x03BE	ξ (GREEK SMALL LETTER XI)
+111	0x03BF	ο (GREEK SMALL LETTER OMICRON)
+112	0x03C0	π (GREEK SMALL LETTER PI)
+113	0x03C1	ρ (GREEK SMALL LETTER RHO)
+114	0x03C2	ς (GREEK SMALL LETTER FINAL SIGMA)
+115	0x03C3	σ (GREEK SMALL LETTER SIGMA)
+116	0x03C4	τ (GREEK SMALL LETTER TAU)
+117	0x03C5	υ (GREEK SMALL LETTER UPSILON)
+118	0x03C6	φ (GREEK SMALL LETTER PHI)
+119	0x03C7	χ (GREEK SMALL LETTER CHI)
+120	0x03C8	ψ (GREEK SMALL LETTER PSI)
+121	0x03C9	ω (GREEK SMALL LETTER OMEGA)
+122	0x03CA	ϊ (GREEK SMALL LETTER IOTA WITH DIALYTIKA)
+123	0x03CB	ϋ (GREEK SMALL LETTER UPSILON WITH DIALYTIKA)
+124	0x03CC	ό (GREEK SMALL LETTER OMICRON WITH TONOS)
+125	0x03CD	ύ (GREEK SMALL LETTER UPSILON WITH TONOS)
+126	0x03CE	ώ (GREEK SMALL LETTER OMEGA WITH TONOS)
diff --git a/test/js/node/test/fixtures/encoding/single-byte/index-iso-8859-8.txt b/test/js/node/test/fixtures/encoding/single-byte/index-iso-8859-8.txt
new file mode 100644
index 000000000000..b60cf8db324e
--- /dev/null
+++ b/test/js/node/test/fixtures/encoding/single-byte/index-iso-8859-8.txt
@@ -0,0 +1,98 @@
+# For details on index index-iso-8859-8.txt see the Encoding Standard
+# https://encoding.spec.whatwg.org/
+#
+# Identifier: 7657a9ca3fa875990da960d3f812eea28dcd0ae6ed55a18d5394303c86f5484b
+# Date: 2024-09-18
+
+  0	0x0080	€ (<control>)
+  1	0x0081	 (<control>)
+  2	0x0082	‚ (<control>)
+  3	0x0083	ƒ (<control>)
+  4	0x0084	„ (<control>)
+  5	0x0085	… (<control>)
+  6	0x0086	† (<control>)
+  7	0x0087	‡ (<control>)
+  8	0x0088	ˆ (<control>)
+  9	0x0089	‰ (<control>)
+ 10	0x008A	Š (<control>)
+ 11	0x008B	‹ (<control>)
+ 12	0x008C	Π(<control>)
+ 13	0x008D	 (<control>)
+ 14	0x008E	Ž (<control>)
+ 15	0x008F	 (<control>)
+ 16	0x0090	 (<control>)
+ 17	0x0091	‘ (<control>)
+ 18	0x0092	’ (<control>)
+ 19	0x0093	“ (<control>)
+ 20	0x0094	” (<control>)
+ 21	0x0095	• (<control>)
+ 22	0x0096	– (<control>)
+ 23	0x0097	— (<control>)
+ 24	0x0098	˜ (<control>)
+ 25	0x0099	™ (<control>)
+ 26	0x009A	š (<control>)
+ 27	0x009B	› (<control>)
+ 28	0x009C	œ (<control>)
+ 29	0x009D	 (<control>)
+ 30	0x009E	ž (<control>)
+ 31	0x009F	Ÿ (<control>)
+ 32	0x00A0	  (NO-BREAK SPACE)
+ 34	0x00A2	¢ (CENT SIGN)
+ 35	0x00A3	£ (POUND SIGN)
+ 36	0x00A4	¤ (CURRENCY SIGN)
+ 37	0x00A5	¥ (YEN SIGN)
+ 38	0x00A6	¦ (BROKEN BAR)
+ 39	0x00A7	§ (SECTION SIGN)
+ 40	0x00A8	¨ (DIAERESIS)
+ 41	0x00A9	© (COPYRIGHT SIGN)
+ 42	0x00D7	× (MULTIPLICATION SIGN)
+ 43	0x00AB	« (LEFT-POINTING DOUBLE ANGLE QUOTATION MARK)
+ 44	0x00AC	¬ (NOT SIGN)
+ 45	0x00AD	­ (SOFT HYPHEN)
+ 46	0x00AE	® (REGISTERED SIGN)
+ 47	0x00AF	¯ (MACRON)
+ 48	0x00B0	° (DEGREE SIGN)
+ 49	0x00B1	± (PLUS-MINUS SIGN)
+ 50	0x00B2	² (SUPERSCRIPT TWO)
+ 51	0x00B3	³ (SUPERSCRIPT THREE)
+ 52	0x00B4	´ (ACUTE ACCENT)
+ 53	0x00B5	µ (MICRO SIGN)
+ 54	0x00B6	¶ (PILCROW SIGN)
+ 55	0x00B7	· (MIDDLE DOT)
+ 56	0x00B8	¸ (CEDILLA)
+ 57	0x00B9	¹ (SUPERSCRIPT ONE)
+ 58	0x00F7	÷ (DIVISION SIGN)
+ 59	0x00BB	» (RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK)
+ 60	0x00BC	¼ (VULGAR FRACTION ONE QUARTER)
+ 61	0x00BD	½ (VULGAR FRACTION ONE HALF)
+ 62	0x00BE	¾ (VULGAR FRACTION THREE QUARTERS)
+ 95	0x2017	‗ (DOUBLE LOW LINE)
+ 96	0x05D0	א (HEBREW LETTER ALEF)
+ 97	0x05D1	ב (HEBREW LETTER BET)
+ 98	0x05D2	ג (HEBREW LETTER GIMEL)
+ 99	0x05D3	ד (HEBREW LETTER DALET)
+100	0x05D4	ה (HEBREW LETTER HE)
+101	0x05D5	ו (HEBREW LETTER VAV)
+102	0x05D6	ז (HEBREW LETTER ZAYIN)
+103	0x05D7	ח (HEBREW LETTER HET)
+104	0x05D8	ט (HEBREW LETTER TET)
+105	0x05D9	י (HEBREW LETTER YOD)
+106	0x05DA	ך (HEBREW LETTER FINAL KAF)
+107	0x05DB	כ (HEBREW LETTER KAF)
+108	0x05DC	ל (HEBREW LETTER LAMED)
+109	0x05DD	ם (HEBREW LETTER FINAL MEM)
+110	0x05DE	מ (HEBREW LETTER MEM)
+111	0x05DF	ן (HEBREW LETTER FINAL NUN)
+112	0x05E0	נ (HEBREW LETTER NUN)
+113	0x05E1	ס (HEBREW LETTER SAMEKH)
+114	0x05E2	ע (HEBREW LETTER AYIN)
+115	0x05E3	ף (HEBREW LETTER FINAL PE)
+116	0x05E4	פ (HEBREW LETTER PE)
+117	0x05E5	ץ (HEBREW LETTER FINAL TSADI)
+118	0x05E6	צ (HEBREW LETTER TSADI)
+119	0x05E7	ק (HEBREW LETTER QOF)
+120	0x05E8	ר (HEBREW LETTER RESH)
+121	0x05E9	ש (HEBREW LETTER SHIN)
+122	0x05EA	ת (HEBREW LETTER TAV)
+125	0x200E	‎ (LEFT-TO-RIGHT MARK)
+126	0x200F	‏ (RIGHT-TO-LEFT MARK)
diff --git a/test/js/node/test/fixtures/encoding/single-byte/index-koi8-r.txt b/test/js/node/test/fixtures/encoding/single-byte/index-koi8-r.txt
new file mode 100644
index 000000000000..ef0b2d710b65
--- /dev/null
+++ b/test/js/node/test/fixtures/encoding/single-byte/index-koi8-r.txt
@@ -0,0 +1,134 @@
+# For details on index index-koi8-r.txt see the Encoding Standard
+# https://encoding.spec.whatwg.org/
+#
+# Identifier: c5497cd9071cb352c0e56b219154e539badf63de40b71578f09e2e11fe7d50ae
+# Date: 2024-09-18
+
+  0	0x2500	─ (BOX DRAWINGS LIGHT HORIZONTAL)
+  1	0x2502	│ (BOX DRAWINGS LIGHT VERTICAL)
+  2	0x250C	┌ (BOX DRAWINGS LIGHT DOWN AND RIGHT)
+  3	0x2510	┐ (BOX DRAWINGS LIGHT DOWN AND LEFT)
+  4	0x2514	└ (BOX DRAWINGS LIGHT UP AND RIGHT)
+  5	0x2518	┘ (BOX DRAWINGS LIGHT UP AND LEFT)
+  6	0x251C	├ (BOX DRAWINGS LIGHT VERTICAL AND RIGHT)
+  7	0x2524	┤ (BOX DRAWINGS LIGHT VERTICAL AND LEFT)
+  8	0x252C	┬ (BOX DRAWINGS LIGHT DOWN AND HORIZONTAL)
+  9	0x2534	┴ (BOX DRAWINGS LIGHT UP AND HORIZONTAL)
+ 10	0x253C	┼ (BOX DRAWINGS LIGHT VERTICAL AND HORIZONTAL)
+ 11	0x2580	▀ (UPPER HALF BLOCK)
+ 12	0x2584	▄ (LOWER HALF BLOCK)
+ 13	0x2588	█ (FULL BLOCK)
+ 14	0x258C	▌ (LEFT HALF BLOCK)
+ 15	0x2590	▐ (RIGHT HALF BLOCK)
+ 16	0x2591	░ (LIGHT SHADE)
+ 17	0x2592	▒ (MEDIUM SHADE)
+ 18	0x2593	▓ (DARK SHADE)
+ 19	0x2320	⌠ (TOP HALF INTEGRAL)
+ 20	0x25A0	■ (BLACK SQUARE)
+ 21	0x2219	∙ (BULLET OPERATOR)
+ 22	0x221A	√ (SQUARE ROOT)
+ 23	0x2248	≈ (ALMOST EQUAL TO)
+ 24	0x2264	≤ (LESS-THAN OR EQUAL TO)
+ 25	0x2265	≥ (GREATER-THAN OR EQUAL TO)
+ 26	0x00A0	  (NO-BREAK SPACE)
+ 27	0x2321	⌡ (BOTTOM HALF INTEGRAL)
+ 28	0x00B0	° (DEGREE SIGN)
+ 29	0x00B2	² (SUPERSCRIPT TWO)
+ 30	0x00B7	· (MIDDLE DOT)
+ 31	0x00F7	÷ (DIVISION SIGN)
+ 32	0x2550	═ (BOX DRAWINGS DOUBLE HORIZONTAL)
+ 33	0x2551	║ (BOX DRAWINGS DOUBLE VERTICAL)
+ 34	0x2552	╒ (BOX DRAWINGS DOWN SINGLE AND RIGHT DOUBLE)
+ 35	0x0451	ё (CYRILLIC SMALL LETTER IO)
+ 36	0x2553	╓ (BOX DRAWINGS DOWN DOUBLE AND RIGHT SINGLE)
+ 37	0x2554	╔ (BOX DRAWINGS DOUBLE DOWN AND RIGHT)
+ 38	0x2555	╕ (BOX DRAWINGS DOWN SINGLE AND LEFT DOUBLE)
+ 39	0x2556	╖ (BOX DRAWINGS DOWN DOUBLE AND LEFT SINGLE)
+ 40	0x2557	╗ (BOX DRAWINGS DOUBLE DOWN AND LEFT)
+ 41	0x2558	╘ (BOX DRAWINGS UP SINGLE AND RIGHT DOUBLE)
+ 42	0x2559	╙ (BOX DRAWINGS UP DOUBLE AND RIGHT SINGLE)
+ 43	0x255A	╚ (BOX DRAWINGS DOUBLE UP AND RIGHT)
+ 44	0x255B	╛ (BOX DRAWINGS UP SINGLE AND LEFT DOUBLE)
+ 45	0x255C	╜ (BOX DRAWINGS UP DOUBLE AND LEFT SINGLE)
+ 46	0x255D	╝ (BOX DRAWINGS DOUBLE UP AND LEFT)
+ 47	0x255E	╞ (BOX DRAWINGS VERTICAL SINGLE AND RIGHT DOUBLE)
+ 48	0x255F	╟ (BOX DRAWINGS VERTICAL DOUBLE AND RIGHT SINGLE)
+ 49	0x2560	╠ (BOX DRAWINGS DOUBLE VERTICAL AND RIGHT)
+ 50	0x2561	╡ (BOX DRAWINGS VERTICAL SINGLE AND LEFT DOUBLE)
+ 51	0x0401	Ё (CYRILLIC CAPITAL LETTER IO)
+ 52	0x2562	╢ (BOX DRAWINGS VERTICAL DOUBLE AND LEFT SINGLE)
+ 53	0x2563	╣ (BOX DRAWINGS DOUBLE VERTICAL AND LEFT)
+ 54	0x2564	╤ (BOX DRAWINGS DOWN SINGLE AND HORIZONTAL DOUBLE)
+ 55	0x2565	╥ (BOX DRAWINGS DOWN DOUBLE AND HORIZONTAL SINGLE)
+ 56	0x2566	╦ (BOX DRAWINGS DOUBLE DOWN AND HORIZONTAL)
+ 57	0x2567	╧ (BOX DRAWINGS UP SINGLE AND HORIZONTAL DOUBLE)
+ 58	0x2568	╨ (BOX DRAWINGS UP DOUBLE AND HORIZONTAL SINGLE)
+ 59	0x2569	╩ (BOX DRAWINGS DOUBLE UP AND HORIZONTAL)
+ 60	0x256A	╪ (BOX DRAWINGS VERTICAL SINGLE AND HORIZONTAL DOUBLE)
+ 61	0x256B	╫ (BOX DRAWINGS VERTICAL DOUBLE AND HORIZONTAL SINGLE)
+ 62	0x256C	╬ (BOX DRAWINGS DOUBLE VERTICAL AND HORIZONTAL)
+ 63	0x00A9	© (COPYRIGHT SIGN)
+ 64	0x044E	ю (CYRILLIC SMALL LETTER YU)
+ 65	0x0430	а (CYRILLIC SMALL LETTER A)
+ 66	0x0431	б (CYRILLIC SMALL LETTER BE)
+ 67	0x0446	ц (CYRILLIC SMALL LETTER TSE)
+ 68	0x0434	д (CYRILLIC SMALL LETTER DE)
+ 69	0x0435	е (CYRILLIC SMALL LETTER IE)
+ 70	0x0444	ф (CYRILLIC SMALL LETTER EF)
+ 71	0x0433	г (CYRILLIC SMALL LETTER GHE)
+ 72	0x0445	х (CYRILLIC SMALL LETTER HA)
+ 73	0x0438	и (CYRILLIC SMALL LETTER I)
+ 74	0x0439	й (CYRILLIC SMALL LETTER SHORT I)
+ 75	0x043A	к (CYRILLIC SMALL LETTER KA)
+ 76	0x043B	л (CYRILLIC SMALL LETTER EL)
+ 77	0x043C	м (CYRILLIC SMALL LETTER EM)
+ 78	0x043D	н (CYRILLIC SMALL LETTER EN)
+ 79	0x043E	о (CYRILLIC SMALL LETTER O)
+ 80	0x043F	п (CYRILLIC SMALL LETTER PE)
+ 81	0x044F	я (CYRILLIC SMALL LETTER YA)
+ 82	0x0440	р (CYRILLIC SMALL LETTER ER)
+ 83	0x0441	с (CYRILLIC SMALL LETTER ES)
+ 84	0x0442	т (CYRILLIC SMALL LETTER TE)
+ 85	0x0443	у (CYRILLIC SMALL LETTER U)
+ 86	0x0436	ж (CYRILLIC SMALL LETTER ZHE)
+ 87	0x0432	в (CYRILLIC SMALL LETTER VE)
+ 88	0x044C	ь (CYRILLIC SMALL LETTER SOFT SIGN)
+ 89	0x044B	ы (CYRILLIC SMALL LETTER YERU)
+ 90	0x0437	з (CYRILLIC SMALL LETTER ZE)
+ 91	0x0448	ш (CYRILLIC SMALL LETTER SHA)
+ 92	0x044D	э (CYRILLIC SMALL LETTER E)
+ 93	0x0449	щ (CYRILLIC SMALL LETTER SHCHA)
+ 94	0x0447	ч (CYRILLIC SMALL LETTER CHE)
+ 95	0x044A	ъ (CYRILLIC SMALL LETTER HARD SIGN)
+ 96	0x042E	Ю (CYRILLIC CAPITAL LETTER YU)
+ 97	0x0410	А (CYRILLIC CAPITAL LETTER A)
+ 98	0x0411	Б (CYRILLIC CAPITAL LETTER BE)
+ 99	0x0426	Ц (CYRILLIC CAPITAL LETTER TSE)
+100	0x0414	Д (CYRILLIC CAPITAL LETTER DE)
+101	0x0415	Е (CYRILLIC CAPITAL LETTER IE)
+102	0x0424	Ф (CYRILLIC CAPITAL LETTER EF)
+103	0x0413	Г (CYRILLIC CAPITAL LETTER GHE)
+104	0x0425	Х (CYRILLIC CAPITAL LETTER HA)
+105	0x0418	И (CYRILLIC CAPITAL LETTER I)
+106	0x0419	Й (CYRILLIC CAPITAL LETTER SHORT I)
+107	0x041A	К (CYRILLIC CAPITAL LETTER KA)
+108	0x041B	Л (CYRILLIC CAPITAL LETTER EL)
+109	0x041C	М (CYRILLIC CAPITAL LETTER EM)
+110	0x041D	Н (CYRILLIC CAPITAL LETTER EN)
+111	0x041E	О (CYRILLIC CAPITAL LETTER O)
+112	0x041F	П (CYRILLIC CAPITAL LETTER PE)
+113	0x042F	Я (CYRILLIC CAPITAL LETTER YA)
+114	0x0420	Р (CYRILLIC CAPITAL LETTER ER)
+115	0x0421	С (CYRILLIC CAPITAL LETTER ES)
+116	0x0422	Т (CYRILLIC CAPITAL LETTER TE)
+117	0x0423	У (CYRILLIC CAPITAL LETTER U)
+118	0x0416	Ж (CYRILLIC CAPITAL LETTER ZHE)
+119	0x0412	В (CYRILLIC CAPITAL LETTER VE)
+120	0x042C	Ь (CYRILLIC CAPITAL LETTER SOFT SIGN)
+121	0x042B	Ы (CYRILLIC CAPITAL LETTER YERU)
+122	0x0417	З (CYRILLIC CAPITAL LETTER ZE)
+123	0x0428	Ш (CYRILLIC CAPITAL LETTER SHA)
+124	0x042D	Э (CYRILLIC CAPITAL LETTER E)
+125	0x0429	Щ (CYRILLIC CAPITAL LETTER SHCHA)
+126	0x0427	Ч (CYRILLIC CAPITAL LETTER CHE)
+127	0x042A	Ъ (CYRILLIC CAPITAL LETTER HARD SIGN)
diff --git a/test/js/node/test/fixtures/encoding/single-byte/index-koi8-u.txt b/test/js/node/test/fixtures/encoding/single-byte/index-koi8-u.txt
new file mode 100644
index 000000000000..bfd717758c2e
--- /dev/null
+++ b/test/js/node/test/fixtures/encoding/single-byte/index-koi8-u.txt
@@ -0,0 +1,134 @@
+# For details on index index-koi8-u.txt see the Encoding Standard
+# https://encoding.spec.whatwg.org/
+#
+# Identifier: 19a4da2c3f245118bbc8019326f45a07832949938ff903f03d62ac4da1f61f40
+# Date: 2024-09-18
+
+  0	0x2500	─ (BOX DRAWINGS LIGHT HORIZONTAL)
+  1	0x2502	│ (BOX DRAWINGS LIGHT VERTICAL)
+  2	0x250C	┌ (BOX DRAWINGS LIGHT DOWN AND RIGHT)
+  3	0x2510	┐ (BOX DRAWINGS LIGHT DOWN AND LEFT)
+  4	0x2514	└ (BOX DRAWINGS LIGHT UP AND RIGHT)
+  5	0x2518	┘ (BOX DRAWINGS LIGHT UP AND LEFT)
+  6	0x251C	├ (BOX DRAWINGS LIGHT VERTICAL AND RIGHT)
+  7	0x2524	┤ (BOX DRAWINGS LIGHT VERTICAL AND LEFT)
+  8	0x252C	┬ (BOX DRAWINGS LIGHT DOWN AND HORIZONTAL)
+  9	0x2534	┴ (BOX DRAWINGS LIGHT UP AND HORIZONTAL)
+ 10	0x253C	┼ (BOX DRAWINGS LIGHT VERTICAL AND HORIZONTAL)
+ 11	0x2580	▀ (UPPER HALF BLOCK)
+ 12	0x2584	▄ (LOWER HALF BLOCK)
+ 13	0x2588	█ (FULL BLOCK)
+ 14	0x258C	▌ (LEFT HALF BLOCK)
+ 15	0x2590	▐ (RIGHT HALF BLOCK)
+ 16	0x2591	░ (LIGHT SHADE)
+ 17	0x2592	▒ (MEDIUM SHADE)
+ 18	0x2593	▓ (DARK SHADE)
+ 19	0x2320	⌠ (TOP HALF INTEGRAL)
+ 20	0x25A0	■ (BLACK SQUARE)
+ 21	0x2219	∙ (BULLET OPERATOR)
+ 22	0x221A	√ (SQUARE ROOT)
+ 23	0x2248	≈ (ALMOST EQUAL TO)
+ 24	0x2264	≤ (LESS-THAN OR EQUAL TO)
+ 25	0x2265	≥ (GREATER-THAN OR EQUAL TO)
+ 26	0x00A0	  (NO-BREAK SPACE)
+ 27	0x2321	⌡ (BOTTOM HALF INTEGRAL)
+ 28	0x00B0	° (DEGREE SIGN)
+ 29	0x00B2	² (SUPERSCRIPT TWO)
+ 30	0x00B7	· (MIDDLE DOT)
+ 31	0x00F7	÷ (DIVISION SIGN)
+ 32	0x2550	═ (BOX DRAWINGS DOUBLE HORIZONTAL)
+ 33	0x2551	║ (BOX DRAWINGS DOUBLE VERTICAL)
+ 34	0x2552	╒ (BOX DRAWINGS DOWN SINGLE AND RIGHT DOUBLE)
+ 35	0x0451	ё (CYRILLIC SMALL LETTER IO)
+ 36	0x0454	є (CYRILLIC SMALL LETTER UKRAINIAN IE)
+ 37	0x2554	╔ (BOX DRAWINGS DOUBLE DOWN AND RIGHT)
+ 38	0x0456	і (CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I)
+ 39	0x0457	ї (CYRILLIC SMALL LETTER YI)
+ 40	0x2557	╗ (BOX DRAWINGS DOUBLE DOWN AND LEFT)
+ 41	0x2558	╘ (BOX DRAWINGS UP SINGLE AND RIGHT DOUBLE)
+ 42	0x2559	╙ (BOX DRAWINGS UP DOUBLE AND RIGHT SINGLE)
+ 43	0x255A	╚ (BOX DRAWINGS DOUBLE UP AND RIGHT)
+ 44	0x255B	╛ (BOX DRAWINGS UP SINGLE AND LEFT DOUBLE)
+ 45	0x0491	ґ (CYRILLIC SMALL LETTER GHE WITH UPTURN)
+ 46	0x045E	ў (CYRILLIC SMALL LETTER SHORT U)
+ 47	0x255E	╞ (BOX DRAWINGS VERTICAL SINGLE AND RIGHT DOUBLE)
+ 48	0x255F	╟ (BOX DRAWINGS VERTICAL DOUBLE AND RIGHT SINGLE)
+ 49	0x2560	╠ (BOX DRAWINGS DOUBLE VERTICAL AND RIGHT)
+ 50	0x2561	╡ (BOX DRAWINGS VERTICAL SINGLE AND LEFT DOUBLE)
+ 51	0x0401	Ё (CYRILLIC CAPITAL LETTER IO)
+ 52	0x0404	Є (CYRILLIC CAPITAL LETTER UKRAINIAN IE)
+ 53	0x2563	╣ (BOX DRAWINGS DOUBLE VERTICAL AND LEFT)
+ 54	0x0406	І (CYRILLIC CAPITAL LETTER BYELORUSSIAN-UKRAINIAN I)
+ 55	0x0407	Ї (CYRILLIC CAPITAL LETTER YI)
+ 56	0x2566	╦ (BOX DRAWINGS DOUBLE DOWN AND HORIZONTAL)
+ 57	0x2567	╧ (BOX DRAWINGS UP SINGLE AND HORIZONTAL DOUBLE)
+ 58	0x2568	╨ (BOX DRAWINGS UP DOUBLE AND HORIZONTAL SINGLE)
+ 59	0x2569	╩ (BOX DRAWINGS DOUBLE UP AND HORIZONTAL)
+ 60	0x256A	╪ (BOX DRAWINGS VERTICAL SINGLE AND HORIZONTAL DOUBLE)
+ 61	0x0490	Ґ (CYRILLIC CAPITAL LETTER GHE WITH UPTURN)
+ 62	0x040E	Ў (CYRILLIC CAPITAL LETTER SHORT U)
+ 63	0x00A9	© (COPYRIGHT SIGN)
+ 64	0x044E	ю (CYRILLIC SMALL LETTER YU)
+ 65	0x0430	а (CYRILLIC SMALL LETTER A)
+ 66	0x0431	б (CYRILLIC SMALL LETTER BE)
+ 67	0x0446	ц (CYRILLIC SMALL LETTER TSE)
+ 68	0x0434	д (CYRILLIC SMALL LETTER DE)
+ 69	0x0435	е (CYRILLIC SMALL LETTER IE)
+ 70	0x0444	ф (CYRILLIC SMALL LETTER EF)
+ 71	0x0433	г (CYRILLIC SMALL LETTER GHE)
+ 72	0x0445	х (CYRILLIC SMALL LETTER HA)
+ 73	0x0438	и (CYRILLIC SMALL LETTER I)
+ 74	0x0439	й (CYRILLIC SMALL LETTER SHORT I)
+ 75	0x043A	к (CYRILLIC SMALL LETTER KA)
+ 76	0x043B	л (CYRILLIC SMALL LETTER EL)
+ 77	0x043C	м (CYRILLIC SMALL LETTER EM)
+ 78	0x043D	н (CYRILLIC SMALL LETTER EN)
+ 79	0x043E	о (CYRILLIC SMALL LETTER O)
+ 80	0x043F	п (CYRILLIC SMALL LETTER PE)
+ 81	0x044F	я (CYRILLIC SMALL LETTER YA)
+ 82	0x0440	р (CYRILLIC SMALL LETTER ER)
+ 83	0x0441	с (CYRILLIC SMALL LETTER ES)
+ 84	0x0442	т (CYRILLIC SMALL LETTER TE)
+ 85	0x0443	у (CYRILLIC SMALL LETTER U)
+ 86	0x0436	ж (CYRILLIC SMALL LETTER ZHE)
+ 87	0x0432	в (CYRILLIC SMALL LETTER VE)
+ 88	0x044C	ь (CYRILLIC SMALL LETTER SOFT SIGN)
+ 89	0x044B	ы (CYRILLIC SMALL LETTER YERU)
+ 90	0x0437	з (CYRILLIC SMALL LETTER ZE)
+ 91	0x0448	ш (CYRILLIC SMALL LETTER SHA)
+ 92	0x044D	э (CYRILLIC SMALL LETTER E)
+ 93	0x0449	щ (CYRILLIC SMALL LETTER SHCHA)
+ 94	0x0447	ч (CYRILLIC SMALL LETTER CHE)
+ 95	0x044A	ъ (CYRILLIC SMALL LETTER HARD SIGN)
+ 96	0x042E	Ю (CYRILLIC CAPITAL LETTER YU)
+ 97	0x0410	А (CYRILLIC CAPITAL LETTER A)
+ 98	0x0411	Б (CYRILLIC CAPITAL LETTER BE)
+ 99	0x0426	Ц (CYRILLIC CAPITAL LETTER TSE)
+100	0x0414	Д (CYRILLIC CAPITAL LETTER DE)
+101	0x0415	Е (CYRILLIC CAPITAL LETTER IE)
+102	0x0424	Ф (CYRILLIC CAPITAL LETTER EF)
+103	0x0413	Г (CYRILLIC CAPITAL LETTER GHE)
+104	0x0425	Х (CYRILLIC CAPITAL LETTER HA)
+105	0x0418	И (CYRILLIC CAPITAL LETTER I)
+106	0x0419	Й (CYRILLIC CAPITAL LETTER SHORT I)
+107	0x041A	К (CYRILLIC CAPITAL LETTER KA)
+108	0x041B	Л (CYRILLIC CAPITAL LETTER EL)
+109	0x041C	М (CYRILLIC CAPITAL LETTER EM)
+110	0x041D	Н (CYRILLIC CAPITAL LETTER EN)
+111	0x041E	О (CYRILLIC CAPITAL LETTER O)
+112	0x041F	П (CYRILLIC CAPITAL LETTER PE)
+113	0x042F	Я (CYRILLIC CAPITAL LETTER YA)
+114	0x0420	Р (CYRILLIC CAPITAL LETTER ER)
+115	0x0421	С (CYRILLIC CAPITAL LETTER ES)
+116	0x0422	Т (CYRILLIC CAPITAL LETTER TE)
+117	0x0423	У (CYRILLIC CAPITAL LETTER U)
+118	0x0416	Ж (CYRILLIC CAPITAL LETTER ZHE)
+119	0x0412	В (CYRILLIC CAPITAL LETTER VE)
+120	0x042C	Ь (CYRILLIC CAPITAL LETTER SOFT SIGN)
+121	0x042B	Ы (CYRILLIC CAPITAL LETTER YERU)
+122	0x0417	З (CYRILLIC CAPITAL LETTER ZE)
+123	0x0428	Ш (CYRILLIC CAPITAL LETTER SHA)
+124	0x042D	Э (CYRILLIC CAPITAL LETTER E)
+125	0x0429	Щ (CYRILLIC CAPITAL LETTER SHCHA)
+126	0x0427	Ч (CYRILLIC CAPITAL LETTER CHE)
+127	0x042A	Ъ (CYRILLIC CAPITAL LETTER HARD SIGN)
diff --git a/test/js/node/test/fixtures/encoding/single-byte/index-macintosh.txt b/test/js/node/test/fixtures/encoding/single-byte/index-macintosh.txt
new file mode 100644
index 000000000000..fb166d4dc13c
--- /dev/null
+++ b/test/js/node/test/fixtures/encoding/single-byte/index-macintosh.txt
@@ -0,0 +1,134 @@
+# For details on index index-macintosh.txt see the Encoding Standard
+# https://encoding.spec.whatwg.org/
+#
+# Identifier: f2c6a4f6406b3e86a50a5dba4d2b7dd48e2e33c0d82aefe764535c934ec11764
+# Date: 2024-09-18
+
+  0	0x00C4	Ä (LATIN CAPITAL LETTER A WITH DIAERESIS)
+  1	0x00C5	Å (LATIN CAPITAL LETTER A WITH RING ABOVE)
+  2	0x00C7	Ç (LATIN CAPITAL LETTER C WITH CEDILLA)
+  3	0x00C9	É (LATIN CAPITAL LETTER E WITH ACUTE)
+  4	0x00D1	Ñ (LATIN CAPITAL LETTER N WITH TILDE)
+  5	0x00D6	Ö (LATIN CAPITAL LETTER O WITH DIAERESIS)
+  6	0x00DC	Ü (LATIN CAPITAL LETTER U WITH DIAERESIS)
+  7	0x00E1	á (LATIN SMALL LETTER A WITH ACUTE)
+  8	0x00E0	à (LATIN SMALL LETTER A WITH GRAVE)
+  9	0x00E2	â (LATIN SMALL LETTER A WITH CIRCUMFLEX)
+ 10	0x00E4	ä (LATIN SMALL LETTER A WITH DIAERESIS)
+ 11	0x00E3	ã (LATIN SMALL LETTER A WITH TILDE)
+ 12	0x00E5	å (LATIN SMALL LETTER A WITH RING ABOVE)
+ 13	0x00E7	ç (LATIN SMALL LETTER C WITH CEDILLA)
+ 14	0x00E9	é (LATIN SMALL LETTER E WITH ACUTE)
+ 15	0x00E8	è (LATIN SMALL LETTER E WITH GRAVE)
+ 16	0x00EA	ê (LATIN SMALL LETTER E WITH CIRCUMFLEX)
+ 17	0x00EB	ë (LATIN SMALL LETTER E WITH DIAERESIS)
+ 18	0x00ED	í (LATIN SMALL LETTER I WITH ACUTE)
+ 19	0x00EC	ì (LATIN SMALL LETTER I WITH GRAVE)
+ 20	0x00EE	î (LATIN SMALL LETTER I WITH CIRCUMFLEX)
+ 21	0x00EF	ï (LATIN SMALL LETTER I WITH DIAERESIS)
+ 22	0x00F1	ñ (LATIN SMALL LETTER N WITH TILDE)
+ 23	0x00F3	ó (LATIN SMALL LETTER O WITH ACUTE)
+ 24	0x00F2	ò (LATIN SMALL LETTER O WITH GRAVE)
+ 25	0x00F4	ô (LATIN SMALL LETTER O WITH CIRCUMFLEX)
+ 26	0x00F6	ö (LATIN SMALL LETTER O WITH DIAERESIS)
+ 27	0x00F5	õ (LATIN SMALL LETTER O WITH TILDE)
+ 28	0x00FA	ú (LATIN SMALL LETTER U WITH ACUTE)
+ 29	0x00F9	ù (LATIN SMALL LETTER U WITH GRAVE)
+ 30	0x00FB	û (LATIN SMALL LETTER U WITH CIRCUMFLEX)
+ 31	0x00FC	ü (LATIN SMALL LETTER U WITH DIAERESIS)
+ 32	0x2020	† (DAGGER)
+ 33	0x00B0	° (DEGREE SIGN)
+ 34	0x00A2	¢ (CENT SIGN)
+ 35	0x00A3	£ (POUND SIGN)
+ 36	0x00A7	§ (SECTION SIGN)
+ 37	0x2022	• (BULLET)
+ 38	0x00B6	¶ (PILCROW SIGN)
+ 39	0x00DF	ß (LATIN SMALL LETTER SHARP S)
+ 40	0x00AE	® (REGISTERED SIGN)
+ 41	0x00A9	© (COPYRIGHT SIGN)
+ 42	0x2122	™ (TRADE MARK SIGN)
+ 43	0x00B4	´ (ACUTE ACCENT)
+ 44	0x00A8	¨ (DIAERESIS)
+ 45	0x2260	≠ (NOT EQUAL TO)
+ 46	0x00C6	Æ (LATIN CAPITAL LETTER AE)
+ 47	0x00D8	Ø (LATIN CAPITAL LETTER O WITH STROKE)
+ 48	0x221E	∞ (INFINITY)
+ 49	0x00B1	± (PLUS-MINUS SIGN)
+ 50	0x2264	≤ (LESS-THAN OR EQUAL TO)
+ 51	0x2265	≥ (GREATER-THAN OR EQUAL TO)
+ 52	0x00A5	¥ (YEN SIGN)
+ 53	0x00B5	µ (MICRO SIGN)
+ 54	0x2202	∂ (PARTIAL DIFFERENTIAL)
+ 55	0x2211	∑ (N-ARY SUMMATION)
+ 56	0x220F	∏ (N-ARY PRODUCT)
+ 57	0x03C0	π (GREEK SMALL LETTER PI)
+ 58	0x222B	∫ (INTEGRAL)
+ 59	0x00AA	ª (FEMININE ORDINAL INDICATOR)
+ 60	0x00BA	º (MASCULINE ORDINAL INDICATOR)
+ 61	0x03A9	Ω (GREEK CAPITAL LETTER OMEGA)
+ 62	0x00E6	æ (LATIN SMALL LETTER AE)
+ 63	0x00F8	ø (LATIN SMALL LETTER O WITH STROKE)
+ 64	0x00BF	¿ (INVERTED QUESTION MARK)
+ 65	0x00A1	¡ (INVERTED EXCLAMATION MARK)
+ 66	0x00AC	¬ (NOT SIGN)
+ 67	0x221A	√ (SQUARE ROOT)
+ 68	0x0192	ƒ (LATIN SMALL LETTER F WITH HOOK)
+ 69	0x2248	≈ (ALMOST EQUAL TO)
+ 70	0x2206	∆ (INCREMENT)
+ 71	0x00AB	« (LEFT-POINTING DOUBLE ANGLE QUOTATION MARK)
+ 72	0x00BB	» (RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK)
+ 73	0x2026	… (HORIZONTAL ELLIPSIS)
+ 74	0x00A0	  (NO-BREAK SPACE)
+ 75	0x00C0	À (LATIN CAPITAL LETTER A WITH GRAVE)
+ 76	0x00C3	Ã (LATIN CAPITAL LETTER A WITH TILDE)
+ 77	0x00D5	Õ (LATIN CAPITAL LETTER O WITH TILDE)
+ 78	0x0152	Π(LATIN CAPITAL LIGATURE OE)
+ 79	0x0153	œ (LATIN SMALL LIGATURE OE)
+ 80	0x2013	– (EN DASH)
+ 81	0x2014	— (EM DASH)
+ 82	0x201C	“ (LEFT DOUBLE QUOTATION MARK)
+ 83	0x201D	” (RIGHT DOUBLE QUOTATION MARK)
+ 84	0x2018	‘ (LEFT SINGLE QUOTATION MARK)
+ 85	0x2019	’ (RIGHT SINGLE QUOTATION MARK)
+ 86	0x00F7	÷ (DIVISION SIGN)
+ 87	0x25CA	◊ (LOZENGE)
+ 88	0x00FF	ÿ (LATIN SMALL LETTER Y WITH DIAERESIS)
+ 89	0x0178	Ÿ (LATIN CAPITAL LETTER Y WITH DIAERESIS)
+ 90	0x2044	⁄ (FRACTION SLASH)
+ 91	0x20AC	€ (EURO SIGN)
+ 92	0x2039	‹ (SINGLE LEFT-POINTING ANGLE QUOTATION MARK)
+ 93	0x203A	› (SINGLE RIGHT-POINTING ANGLE QUOTATION MARK)
+ 94	0xFB01	fi (LATIN SMALL LIGATURE FI)
+ 95	0xFB02	fl (LATIN SMALL LIGATURE FL)
+ 96	0x2021	‡ (DOUBLE DAGGER)
+ 97	0x00B7	· (MIDDLE DOT)
+ 98	0x201A	‚ (SINGLE LOW-9 QUOTATION MARK)
+ 99	0x201E	„ (DOUBLE LOW-9 QUOTATION MARK)
+100	0x2030	‰ (PER MILLE SIGN)
+101	0x00C2	Â (LATIN CAPITAL LETTER A WITH CIRCUMFLEX)
+102	0x00CA	Ê (LATIN CAPITAL LETTER E WITH CIRCUMFLEX)
+103	0x00C1	Á (LATIN CAPITAL LETTER A WITH ACUTE)
+104	0x00CB	Ë (LATIN CAPITAL LETTER E WITH DIAERESIS)
+105	0x00C8	È (LATIN CAPITAL LETTER E WITH GRAVE)
+106	0x00CD	Í (LATIN CAPITAL LETTER I WITH ACUTE)
+107	0x00CE	Î (LATIN CAPITAL LETTER I WITH CIRCUMFLEX)
+108	0x00CF	Ï (LATIN CAPITAL LETTER I WITH DIAERESIS)
+109	0x00CC	Ì (LATIN CAPITAL LETTER I WITH GRAVE)
+110	0x00D3	Ó (LATIN CAPITAL LETTER O WITH ACUTE)
+111	0x00D4	Ô (LATIN CAPITAL LETTER O WITH CIRCUMFLEX)
+112	0xF8FF	 (<Private Use>)
+113	0x00D2	Ò (LATIN CAPITAL LETTER O WITH GRAVE)
+114	0x00DA	Ú (LATIN CAPITAL LETTER U WITH ACUTE)
+115	0x00DB	Û (LATIN CAPITAL LETTER U WITH CIRCUMFLEX)
+116	0x00D9	Ù (LATIN CAPITAL LETTER U WITH GRAVE)
+117	0x0131	ı (LATIN SMALL LETTER DOTLESS I)
+118	0x02C6	ˆ (MODIFIER LETTER CIRCUMFLEX ACCENT)
+119	0x02DC	˜ (SMALL TILDE)
+120	0x00AF	¯ (MACRON)
+121	0x02D8	˘ (BREVE)
+122	0x02D9	˙ (DOT ABOVE)
+123	0x02DA	˚ (RING ABOVE)
+124	0x00B8	¸ (CEDILLA)
+125	0x02DD	˝ (DOUBLE ACUTE ACCENT)
+126	0x02DB	˛ (OGONEK)
+127	0x02C7	ˇ (CARON)
diff --git a/test/js/node/test/fixtures/encoding/single-byte/index-windows-1250.txt b/test/js/node/test/fixtures/encoding/single-byte/index-windows-1250.txt
new file mode 100644
index 000000000000..24fa6c9a89e3
--- /dev/null
+++ b/test/js/node/test/fixtures/encoding/single-byte/index-windows-1250.txt
@@ -0,0 +1,134 @@
+# For details on index index-windows-1250.txt see the Encoding Standard
+# https://encoding.spec.whatwg.org/
+#
+# Identifier: 0669455a7a1c70ba6003ea737991e8ee9adc455125c13cfe6705a361358de5fa
+# Date: 2024-09-18
+
+  0	0x20AC	€ (EURO SIGN)
+  1	0x0081	 (<control>)
+  2	0x201A	‚ (SINGLE LOW-9 QUOTATION MARK)
+  3	0x0083	ƒ (<control>)
+  4	0x201E	„ (DOUBLE LOW-9 QUOTATION MARK)
+  5	0x2026	… (HORIZONTAL ELLIPSIS)
+  6	0x2020	† (DAGGER)
+  7	0x2021	‡ (DOUBLE DAGGER)
+  8	0x0088	ˆ (<control>)
+  9	0x2030	‰ (PER MILLE SIGN)
+ 10	0x0160	Š (LATIN CAPITAL LETTER S WITH CARON)
+ 11	0x2039	‹ (SINGLE LEFT-POINTING ANGLE QUOTATION MARK)
+ 12	0x015A	Ś (LATIN CAPITAL LETTER S WITH ACUTE)
+ 13	0x0164	Ť (LATIN CAPITAL LETTER T WITH CARON)
+ 14	0x017D	Ž (LATIN CAPITAL LETTER Z WITH CARON)
+ 15	0x0179	Ź (LATIN CAPITAL LETTER Z WITH ACUTE)
+ 16	0x0090	 (<control>)
+ 17	0x2018	‘ (LEFT SINGLE QUOTATION MARK)
+ 18	0x2019	’ (RIGHT SINGLE QUOTATION MARK)
+ 19	0x201C	“ (LEFT DOUBLE QUOTATION MARK)
+ 20	0x201D	” (RIGHT DOUBLE QUOTATION MARK)
+ 21	0x2022	• (BULLET)
+ 22	0x2013	– (EN DASH)
+ 23	0x2014	— (EM DASH)
+ 24	0x0098	˜ (<control>)
+ 25	0x2122	™ (TRADE MARK SIGN)
+ 26	0x0161	š (LATIN SMALL LETTER S WITH CARON)
+ 27	0x203A	› (SINGLE RIGHT-POINTING ANGLE QUOTATION MARK)
+ 28	0x015B	ś (LATIN SMALL LETTER S WITH ACUTE)
+ 29	0x0165	ť (LATIN SMALL LETTER T WITH CARON)
+ 30	0x017E	ž (LATIN SMALL LETTER Z WITH CARON)
+ 31	0x017A	ź (LATIN SMALL LETTER Z WITH ACUTE)
+ 32	0x00A0	  (NO-BREAK SPACE)
+ 33	0x02C7	ˇ (CARON)
+ 34	0x02D8	˘ (BREVE)
+ 35	0x0141	Ł (LATIN CAPITAL LETTER L WITH STROKE)
+ 36	0x00A4	¤ (CURRENCY SIGN)
+ 37	0x0104	Ą (LATIN CAPITAL LETTER A WITH OGONEK)
+ 38	0x00A6	¦ (BROKEN BAR)
+ 39	0x00A7	§ (SECTION SIGN)
+ 40	0x00A8	¨ (DIAERESIS)
+ 41	0x00A9	© (COPYRIGHT SIGN)
+ 42	0x015E	Ş (LATIN CAPITAL LETTER S WITH CEDILLA)
+ 43	0x00AB	« (LEFT-POINTING DOUBLE ANGLE QUOTATION MARK)
+ 44	0x00AC	¬ (NOT SIGN)
+ 45	0x00AD	­ (SOFT HYPHEN)
+ 46	0x00AE	® (REGISTERED SIGN)
+ 47	0x017B	Ż (LATIN CAPITAL LETTER Z WITH DOT ABOVE)
+ 48	0x00B0	° (DEGREE SIGN)
+ 49	0x00B1	± (PLUS-MINUS SIGN)
+ 50	0x02DB	˛ (OGONEK)
+ 51	0x0142	ł (LATIN SMALL LETTER L WITH STROKE)
+ 52	0x00B4	´ (ACUTE ACCENT)
+ 53	0x00B5	µ (MICRO SIGN)
+ 54	0x00B6	¶ (PILCROW SIGN)
+ 55	0x00B7	· (MIDDLE DOT)
+ 56	0x00B8	¸ (CEDILLA)
+ 57	0x0105	ą (LATIN SMALL LETTER A WITH OGONEK)
+ 58	0x015F	ş (LATIN SMALL LETTER S WITH CEDILLA)
+ 59	0x00BB	» (RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK)
+ 60	0x013D	Ľ (LATIN CAPITAL LETTER L WITH CARON)
+ 61	0x02DD	˝ (DOUBLE ACUTE ACCENT)
+ 62	0x013E	ľ (LATIN SMALL LETTER L WITH CARON)
+ 63	0x017C	ż (LATIN SMALL LETTER Z WITH DOT ABOVE)
+ 64	0x0154	Ŕ (LATIN CAPITAL LETTER R WITH ACUTE)
+ 65	0x00C1	Á (LATIN CAPITAL LETTER A WITH ACUTE)
+ 66	0x00C2	Â (LATIN CAPITAL LETTER A WITH CIRCUMFLEX)
+ 67	0x0102	Ă (LATIN CAPITAL LETTER A WITH BREVE)
+ 68	0x00C4	Ä (LATIN CAPITAL LETTER A WITH DIAERESIS)
+ 69	0x0139	Ĺ (LATIN CAPITAL LETTER L WITH ACUTE)
+ 70	0x0106	Ć (LATIN CAPITAL LETTER C WITH ACUTE)
+ 71	0x00C7	Ç (LATIN CAPITAL LETTER C WITH CEDILLA)
+ 72	0x010C	Č (LATIN CAPITAL LETTER C WITH CARON)
+ 73	0x00C9	É (LATIN CAPITAL LETTER E WITH ACUTE)
+ 74	0x0118	Ę (LATIN CAPITAL LETTER E WITH OGONEK)
+ 75	0x00CB	Ë (LATIN CAPITAL LETTER E WITH DIAERESIS)
+ 76	0x011A	Ě (LATIN CAPITAL LETTER E WITH CARON)
+ 77	0x00CD	Í (LATIN CAPITAL LETTER I WITH ACUTE)
+ 78	0x00CE	Î (LATIN CAPITAL LETTER I WITH CIRCUMFLEX)
+ 79	0x010E	Ď (LATIN CAPITAL LETTER D WITH CARON)
+ 80	0x0110	Đ (LATIN CAPITAL LETTER D WITH STROKE)
+ 81	0x0143	Ń (LATIN CAPITAL LETTER N WITH ACUTE)
+ 82	0x0147	Ň (LATIN CAPITAL LETTER N WITH CARON)
+ 83	0x00D3	Ó (LATIN CAPITAL LETTER O WITH ACUTE)
+ 84	0x00D4	Ô (LATIN CAPITAL LETTER O WITH CIRCUMFLEX)
+ 85	0x0150	Ő (LATIN CAPITAL LETTER O WITH DOUBLE ACUTE)
+ 86	0x00D6	Ö (LATIN CAPITAL LETTER O WITH DIAERESIS)
+ 87	0x00D7	× (MULTIPLICATION SIGN)
+ 88	0x0158	Ř (LATIN CAPITAL LETTER R WITH CARON)
+ 89	0x016E	Ů (LATIN CAPITAL LETTER U WITH RING ABOVE)
+ 90	0x00DA	Ú (LATIN CAPITAL LETTER U WITH ACUTE)
+ 91	0x0170	Ű (LATIN CAPITAL LETTER U WITH DOUBLE ACUTE)
+ 92	0x00DC	Ü (LATIN CAPITAL LETTER U WITH DIAERESIS)
+ 93	0x00DD	Ý (LATIN CAPITAL LETTER Y WITH ACUTE)
+ 94	0x0162	Ţ (LATIN CAPITAL LETTER T WITH CEDILLA)
+ 95	0x00DF	ß (LATIN SMALL LETTER SHARP S)
+ 96	0x0155	ŕ (LATIN SMALL LETTER R WITH ACUTE)
+ 97	0x00E1	á (LATIN SMALL LETTER A WITH ACUTE)
+ 98	0x00E2	â (LATIN SMALL LETTER A WITH CIRCUMFLEX)
+ 99	0x0103	ă (LATIN SMALL LETTER A WITH BREVE)
+100	0x00E4	ä (LATIN SMALL LETTER A WITH DIAERESIS)
+101	0x013A	ĺ (LATIN SMALL LETTER L WITH ACUTE)
+102	0x0107	ć (LATIN SMALL LETTER C WITH ACUTE)
+103	0x00E7	ç (LATIN SMALL LETTER C WITH CEDILLA)
+104	0x010D	č (LATIN SMALL LETTER C WITH CARON)
+105	0x00E9	é (LATIN SMALL LETTER E WITH ACUTE)
+106	0x0119	ę (LATIN SMALL LETTER E WITH OGONEK)
+107	0x00EB	ë (LATIN SMALL LETTER E WITH DIAERESIS)
+108	0x011B	ě (LATIN SMALL LETTER E WITH CARON)
+109	0x00ED	í (LATIN SMALL LETTER I WITH ACUTE)
+110	0x00EE	î (LATIN SMALL LETTER I WITH CIRCUMFLEX)
+111	0x010F	ď (LATIN SMALL LETTER D WITH CARON)
+112	0x0111	đ (LATIN SMALL LETTER D WITH STROKE)
+113	0x0144	ń (LATIN SMALL LETTER N WITH ACUTE)
+114	0x0148	ň (LATIN SMALL LETTER N WITH CARON)
+115	0x00F3	ó (LATIN SMALL LETTER O WITH ACUTE)
+116	0x00F4	ô (LATIN SMALL LETTER O WITH CIRCUMFLEX)
+117	0x0151	ő (LATIN SMALL LETTER O WITH DOUBLE ACUTE)
+118	0x00F6	ö (LATIN SMALL LETTER O WITH DIAERESIS)
+119	0x00F7	÷ (DIVISION SIGN)
+120	0x0159	ř (LATIN SMALL LETTER R WITH CARON)
+121	0x016F	ů (LATIN SMALL LETTER U WITH RING ABOVE)
+122	0x00FA	ú (LATIN SMALL LETTER U WITH ACUTE)
+123	0x0171	ű (LATIN SMALL LETTER U WITH DOUBLE ACUTE)
+124	0x00FC	ü (LATIN SMALL LETTER U WITH DIAERESIS)
+125	0x00FD	ý (LATIN SMALL LETTER Y WITH ACUTE)
+126	0x0163	ţ (LATIN SMALL LETTER T WITH CEDILLA)
+127	0x02D9	˙ (DOT ABOVE)
diff --git a/test/js/node/test/fixtures/encoding/single-byte/index-windows-1251.txt b/test/js/node/test/fixtures/encoding/single-byte/index-windows-1251.txt
new file mode 100644
index 000000000000..ee4533c51ce7
--- /dev/null
+++ b/test/js/node/test/fixtures/encoding/single-byte/index-windows-1251.txt
@@ -0,0 +1,134 @@
+# For details on index index-windows-1251.txt see the Encoding Standard
+# https://encoding.spec.whatwg.org/
+#
+# Identifier: 7592ef921679ba168b00a9e9afa3b4eebd67bf13dc7e84c4b6e120de856826e0
+# Date: 2024-09-18
+
+  0	0x0402	Ђ (CYRILLIC CAPITAL LETTER DJE)
+  1	0x0403	Ѓ (CYRILLIC CAPITAL LETTER GJE)
+  2	0x201A	‚ (SINGLE LOW-9 QUOTATION MARK)
+  3	0x0453	ѓ (CYRILLIC SMALL LETTER GJE)
+  4	0x201E	„ (DOUBLE LOW-9 QUOTATION MARK)
+  5	0x2026	… (HORIZONTAL ELLIPSIS)
+  6	0x2020	† (DAGGER)
+  7	0x2021	‡ (DOUBLE DAGGER)
+  8	0x20AC	€ (EURO SIGN)
+  9	0x2030	‰ (PER MILLE SIGN)
+ 10	0x0409	Љ (CYRILLIC CAPITAL LETTER LJE)
+ 11	0x2039	‹ (SINGLE LEFT-POINTING ANGLE QUOTATION MARK)
+ 12	0x040A	Њ (CYRILLIC CAPITAL LETTER NJE)
+ 13	0x040C	Ќ (CYRILLIC CAPITAL LETTER KJE)
+ 14	0x040B	Ћ (CYRILLIC CAPITAL LETTER TSHE)
+ 15	0x040F	Џ (CYRILLIC CAPITAL LETTER DZHE)
+ 16	0x0452	ђ (CYRILLIC SMALL LETTER DJE)
+ 17	0x2018	‘ (LEFT SINGLE QUOTATION MARK)
+ 18	0x2019	’ (RIGHT SINGLE QUOTATION MARK)
+ 19	0x201C	“ (LEFT DOUBLE QUOTATION MARK)
+ 20	0x201D	” (RIGHT DOUBLE QUOTATION MARK)
+ 21	0x2022	• (BULLET)
+ 22	0x2013	– (EN DASH)
+ 23	0x2014	— (EM DASH)
+ 24	0x0098	˜ (<control>)
+ 25	0x2122	™ (TRADE MARK SIGN)
+ 26	0x0459	љ (CYRILLIC SMALL LETTER LJE)
+ 27	0x203A	› (SINGLE RIGHT-POINTING ANGLE QUOTATION MARK)
+ 28	0x045A	њ (CYRILLIC SMALL LETTER NJE)
+ 29	0x045C	ќ (CYRILLIC SMALL LETTER KJE)
+ 30	0x045B	ћ (CYRILLIC SMALL LETTER TSHE)
+ 31	0x045F	џ (CYRILLIC SMALL LETTER DZHE)
+ 32	0x00A0	  (NO-BREAK SPACE)
+ 33	0x040E	Ў (CYRILLIC CAPITAL LETTER SHORT U)
+ 34	0x045E	ў (CYRILLIC SMALL LETTER SHORT U)
+ 35	0x0408	Ј (CYRILLIC CAPITAL LETTER JE)
+ 36	0x00A4	¤ (CURRENCY SIGN)
+ 37	0x0490	Ґ (CYRILLIC CAPITAL LETTER GHE WITH UPTURN)
+ 38	0x00A6	¦ (BROKEN BAR)
+ 39	0x00A7	§ (SECTION SIGN)
+ 40	0x0401	Ё (CYRILLIC CAPITAL LETTER IO)
+ 41	0x00A9	© (COPYRIGHT SIGN)
+ 42	0x0404	Є (CYRILLIC CAPITAL LETTER UKRAINIAN IE)
+ 43	0x00AB	« (LEFT-POINTING DOUBLE ANGLE QUOTATION MARK)
+ 44	0x00AC	¬ (NOT SIGN)
+ 45	0x00AD	­ (SOFT HYPHEN)
+ 46	0x00AE	® (REGISTERED SIGN)
+ 47	0x0407	Ї (CYRILLIC CAPITAL LETTER YI)
+ 48	0x00B0	° (DEGREE SIGN)
+ 49	0x00B1	± (PLUS-MINUS SIGN)
+ 50	0x0406	І (CYRILLIC CAPITAL LETTER BYELORUSSIAN-UKRAINIAN I)
+ 51	0x0456	і (CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I)
+ 52	0x0491	ґ (CYRILLIC SMALL LETTER GHE WITH UPTURN)
+ 53	0x00B5	µ (MICRO SIGN)
+ 54	0x00B6	¶ (PILCROW SIGN)
+ 55	0x00B7	· (MIDDLE DOT)
+ 56	0x0451	ё (CYRILLIC SMALL LETTER IO)
+ 57	0x2116	№ (NUMERO SIGN)
+ 58	0x0454	є (CYRILLIC SMALL LETTER UKRAINIAN IE)
+ 59	0x00BB	» (RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK)
+ 60	0x0458	ј (CYRILLIC SMALL LETTER JE)
+ 61	0x0405	Ѕ (CYRILLIC CAPITAL LETTER DZE)
+ 62	0x0455	ѕ (CYRILLIC SMALL LETTER DZE)
+ 63	0x0457	ї (CYRILLIC SMALL LETTER YI)
+ 64	0x0410	А (CYRILLIC CAPITAL LETTER A)
+ 65	0x0411	Б (CYRILLIC CAPITAL LETTER BE)
+ 66	0x0412	В (CYRILLIC CAPITAL LETTER VE)
+ 67	0x0413	Г (CYRILLIC CAPITAL LETTER GHE)
+ 68	0x0414	Д (CYRILLIC CAPITAL LETTER DE)
+ 69	0x0415	Е (CYRILLIC CAPITAL LETTER IE)
+ 70	0x0416	Ж (CYRILLIC CAPITAL LETTER ZHE)
+ 71	0x0417	З (CYRILLIC CAPITAL LETTER ZE)
+ 72	0x0418	И (CYRILLIC CAPITAL LETTER I)
+ 73	0x0419	Й (CYRILLIC CAPITAL LETTER SHORT I)
+ 74	0x041A	К (CYRILLIC CAPITAL LETTER KA)
+ 75	0x041B	Л (CYRILLIC CAPITAL LETTER EL)
+ 76	0x041C	М (CYRILLIC CAPITAL LETTER EM)
+ 77	0x041D	Н (CYRILLIC CAPITAL LETTER EN)
+ 78	0x041E	О (CYRILLIC CAPITAL LETTER O)
+ 79	0x041F	П (CYRILLIC CAPITAL LETTER PE)
+ 80	0x0420	Р (CYRILLIC CAPITAL LETTER ER)
+ 81	0x0421	С (CYRILLIC CAPITAL LETTER ES)
+ 82	0x0422	Т (CYRILLIC CAPITAL LETTER TE)
+ 83	0x0423	У (CYRILLIC CAPITAL LETTER U)
+ 84	0x0424	Ф (CYRILLIC CAPITAL LETTER EF)
+ 85	0x0425	Х (CYRILLIC CAPITAL LETTER HA)
+ 86	0x0426	Ц (CYRILLIC CAPITAL LETTER TSE)
+ 87	0x0427	Ч (CYRILLIC CAPITAL LETTER CHE)
+ 88	0x0428	Ш (CYRILLIC CAPITAL LETTER SHA)
+ 89	0x0429	Щ (CYRILLIC CAPITAL LETTER SHCHA)
+ 90	0x042A	Ъ (CYRILLIC CAPITAL LETTER HARD SIGN)
+ 91	0x042B	Ы (CYRILLIC CAPITAL LETTER YERU)
+ 92	0x042C	Ь (CYRILLIC CAPITAL LETTER SOFT SIGN)
+ 93	0x042D	Э (CYRILLIC CAPITAL LETTER E)
+ 94	0x042E	Ю (CYRILLIC CAPITAL LETTER YU)
+ 95	0x042F	Я (CYRILLIC CAPITAL LETTER YA)
+ 96	0x0430	а (CYRILLIC SMALL LETTER A)
+ 97	0x0431	б (CYRILLIC SMALL LETTER BE)
+ 98	0x0432	в (CYRILLIC SMALL LETTER VE)
+ 99	0x0433	г (CYRILLIC SMALL LETTER GHE)
+100	0x0434	д (CYRILLIC SMALL LETTER DE)
+101	0x0435	е (CYRILLIC SMALL LETTER IE)
+102	0x0436	ж (CYRILLIC SMALL LETTER ZHE)
+103	0x0437	з (CYRILLIC SMALL LETTER ZE)
+104	0x0438	и (CYRILLIC SMALL LETTER I)
+105	0x0439	й (CYRILLIC SMALL LETTER SHORT I)
+106	0x043A	к (CYRILLIC SMALL LETTER KA)
+107	0x043B	л (CYRILLIC SMALL LETTER EL)
+108	0x043C	м (CYRILLIC SMALL LETTER EM)
+109	0x043D	н (CYRILLIC SMALL LETTER EN)
+110	0x043E	о (CYRILLIC SMALL LETTER O)
+111	0x043F	п (CYRILLIC SMALL LETTER PE)
+112	0x0440	р (CYRILLIC SMALL LETTER ER)
+113	0x0441	с (CYRILLIC SMALL LETTER ES)
+114	0x0442	т (CYRILLIC SMALL LETTER TE)
+115	0x0443	у (CYRILLIC SMALL LETTER U)
+116	0x0444	ф (CYRILLIC SMALL LETTER EF)
+117	0x0445	х (CYRILLIC SMALL LETTER HA)
+118	0x0446	ц (CYRILLIC SMALL LETTER TSE)
+119	0x0447	ч (CYRILLIC SMALL LETTER CHE)
+120	0x0448	ш (CYRILLIC SMALL LETTER SHA)
+121	0x0449	щ (CYRILLIC SMALL LETTER SHCHA)
+122	0x044A	ъ (CYRILLIC SMALL LETTER HARD SIGN)
+123	0x044B	ы (CYRILLIC SMALL LETTER YERU)
+124	0x044C	ь (CYRILLIC SMALL LETTER SOFT SIGN)
+125	0x044D	э (CYRILLIC SMALL LETTER E)
+126	0x044E	ю (CYRILLIC SMALL LETTER YU)
+127	0x044F	я (CYRILLIC SMALL LETTER YA)
diff --git a/test/js/node/test/fixtures/encoding/single-byte/index-windows-1252.txt b/test/js/node/test/fixtures/encoding/single-byte/index-windows-1252.txt
new file mode 100644
index 000000000000..af1edbcd19ce
--- /dev/null
+++ b/test/js/node/test/fixtures/encoding/single-byte/index-windows-1252.txt
@@ -0,0 +1,134 @@
+# For details on index index-windows-1252.txt see the Encoding Standard
+# https://encoding.spec.whatwg.org/
+#
+# Identifier: e56d49d9176e9a412283cf29ac9bd613f5620462f2a080a84eceaf974cfa18b7
+# Date: 2024-09-18
+
+  0	0x20AC	€ (EURO SIGN)
+  1	0x0081	 (<control>)
+  2	0x201A	‚ (SINGLE LOW-9 QUOTATION MARK)
+  3	0x0192	ƒ (LATIN SMALL LETTER F WITH HOOK)
+  4	0x201E	„ (DOUBLE LOW-9 QUOTATION MARK)
+  5	0x2026	… (HORIZONTAL ELLIPSIS)
+  6	0x2020	† (DAGGER)
+  7	0x2021	‡ (DOUBLE DAGGER)
+  8	0x02C6	ˆ (MODIFIER LETTER CIRCUMFLEX ACCENT)
+  9	0x2030	‰ (PER MILLE SIGN)
+ 10	0x0160	Š (LATIN CAPITAL LETTER S WITH CARON)
+ 11	0x2039	‹ (SINGLE LEFT-POINTING ANGLE QUOTATION MARK)
+ 12	0x0152	Π(LATIN CAPITAL LIGATURE OE)
+ 13	0x008D	 (<control>)
+ 14	0x017D	Ž (LATIN CAPITAL LETTER Z WITH CARON)
+ 15	0x008F	 (<control>)
+ 16	0x0090	 (<control>)
+ 17	0x2018	‘ (LEFT SINGLE QUOTATION MARK)
+ 18	0x2019	’ (RIGHT SINGLE QUOTATION MARK)
+ 19	0x201C	“ (LEFT DOUBLE QUOTATION MARK)
+ 20	0x201D	” (RIGHT DOUBLE QUOTATION MARK)
+ 21	0x2022	• (BULLET)
+ 22	0x2013	– (EN DASH)
+ 23	0x2014	— (EM DASH)
+ 24	0x02DC	˜ (SMALL TILDE)
+ 25	0x2122	™ (TRADE MARK SIGN)
+ 26	0x0161	š (LATIN SMALL LETTER S WITH CARON)
+ 27	0x203A	› (SINGLE RIGHT-POINTING ANGLE QUOTATION MARK)
+ 28	0x0153	œ (LATIN SMALL LIGATURE OE)
+ 29	0x009D	 (<control>)
+ 30	0x017E	ž (LATIN SMALL LETTER Z WITH CARON)
+ 31	0x0178	Ÿ (LATIN CAPITAL LETTER Y WITH DIAERESIS)
+ 32	0x00A0	  (NO-BREAK SPACE)
+ 33	0x00A1	¡ (INVERTED EXCLAMATION MARK)
+ 34	0x00A2	¢ (CENT SIGN)
+ 35	0x00A3	£ (POUND SIGN)
+ 36	0x00A4	¤ (CURRENCY SIGN)
+ 37	0x00A5	¥ (YEN SIGN)
+ 38	0x00A6	¦ (BROKEN BAR)
+ 39	0x00A7	§ (SECTION SIGN)
+ 40	0x00A8	¨ (DIAERESIS)
+ 41	0x00A9	© (COPYRIGHT SIGN)
+ 42	0x00AA	ª (FEMININE ORDINAL INDICATOR)
+ 43	0x00AB	« (LEFT-POINTING DOUBLE ANGLE QUOTATION MARK)
+ 44	0x00AC	¬ (NOT SIGN)
+ 45	0x00AD	­ (SOFT HYPHEN)
+ 46	0x00AE	® (REGISTERED SIGN)
+ 47	0x00AF	¯ (MACRON)
+ 48	0x00B0	° (DEGREE SIGN)
+ 49	0x00B1	± (PLUS-MINUS SIGN)
+ 50	0x00B2	² (SUPERSCRIPT TWO)
+ 51	0x00B3	³ (SUPERSCRIPT THREE)
+ 52	0x00B4	´ (ACUTE ACCENT)
+ 53	0x00B5	µ (MICRO SIGN)
+ 54	0x00B6	¶ (PILCROW SIGN)
+ 55	0x00B7	· (MIDDLE DOT)
+ 56	0x00B8	¸ (CEDILLA)
+ 57	0x00B9	¹ (SUPERSCRIPT ONE)
+ 58	0x00BA	º (MASCULINE ORDINAL INDICATOR)
+ 59	0x00BB	» (RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK)
+ 60	0x00BC	¼ (VULGAR FRACTION ONE QUARTER)
+ 61	0x00BD	½ (VULGAR FRACTION ONE HALF)
+ 62	0x00BE	¾ (VULGAR FRACTION THREE QUARTERS)
+ 63	0x00BF	¿ (INVERTED QUESTION MARK)
+ 64	0x00C0	À (LATIN CAPITAL LETTER A WITH GRAVE)
+ 65	0x00C1	Á (LATIN CAPITAL LETTER A WITH ACUTE)
+ 66	0x00C2	Â (LATIN CAPITAL LETTER A WITH CIRCUMFLEX)
+ 67	0x00C3	Ã (LATIN CAPITAL LETTER A WITH TILDE)
+ 68	0x00C4	Ä (LATIN CAPITAL LETTER A WITH DIAERESIS)
+ 69	0x00C5	Å (LATIN CAPITAL LETTER A WITH RING ABOVE)
+ 70	0x00C6	Æ (LATIN CAPITAL LETTER AE)
+ 71	0x00C7	Ç (LATIN CAPITAL LETTER C WITH CEDILLA)
+ 72	0x00C8	È (LATIN CAPITAL LETTER E WITH GRAVE)
+ 73	0x00C9	É (LATIN CAPITAL LETTER E WITH ACUTE)
+ 74	0x00CA	Ê (LATIN CAPITAL LETTER E WITH CIRCUMFLEX)
+ 75	0x00CB	Ë (LATIN CAPITAL LETTER E WITH DIAERESIS)
+ 76	0x00CC	Ì (LATIN CAPITAL LETTER I WITH GRAVE)
+ 77	0x00CD	Í (LATIN CAPITAL LETTER I WITH ACUTE)
+ 78	0x00CE	Î (LATIN CAPITAL LETTER I WITH CIRCUMFLEX)
+ 79	0x00CF	Ï (LATIN CAPITAL LETTER I WITH DIAERESIS)
+ 80	0x00D0	Ð (LATIN CAPITAL LETTER ETH)
+ 81	0x00D1	Ñ (LATIN CAPITAL LETTER N WITH TILDE)
+ 82	0x00D2	Ò (LATIN CAPITAL LETTER O WITH GRAVE)
+ 83	0x00D3	Ó (LATIN CAPITAL LETTER O WITH ACUTE)
+ 84	0x00D4	Ô (LATIN CAPITAL LETTER O WITH CIRCUMFLEX)
+ 85	0x00D5	Õ (LATIN CAPITAL LETTER O WITH TILDE)
+ 86	0x00D6	Ö (LATIN CAPITAL LETTER O WITH DIAERESIS)
+ 87	0x00D7	× (MULTIPLICATION SIGN)
+ 88	0x00D8	Ø (LATIN CAPITAL LETTER O WITH STROKE)
+ 89	0x00D9	Ù (LATIN CAPITAL LETTER U WITH GRAVE)
+ 90	0x00DA	Ú (LATIN CAPITAL LETTER U WITH ACUTE)
+ 91	0x00DB	Û (LATIN CAPITAL LETTER U WITH CIRCUMFLEX)
+ 92	0x00DC	Ü (LATIN CAPITAL LETTER U WITH DIAERESIS)
+ 93	0x00DD	Ý (LATIN CAPITAL LETTER Y WITH ACUTE)
+ 94	0x00DE	Þ (LATIN CAPITAL LETTER THORN)
+ 95	0x00DF	ß (LATIN SMALL LETTER SHARP S)
+ 96	0x00E0	à (LATIN SMALL LETTER A WITH GRAVE)
+ 97	0x00E1	á (LATIN SMALL LETTER A WITH ACUTE)
+ 98	0x00E2	â (LATIN SMALL LETTER A WITH CIRCUMFLEX)
+ 99	0x00E3	ã (LATIN SMALL LETTER A WITH TILDE)
+100	0x00E4	ä (LATIN SMALL LETTER A WITH DIAERESIS)
+101	0x00E5	å (LATIN SMALL LETTER A WITH RING ABOVE)
+102	0x00E6	æ (LATIN SMALL LETTER AE)
+103	0x00E7	ç (LATIN SMALL LETTER C WITH CEDILLA)
+104	0x00E8	è (LATIN SMALL LETTER E WITH GRAVE)
+105	0x00E9	é (LATIN SMALL LETTER E WITH ACUTE)
+106	0x00EA	ê (LATIN SMALL LETTER E WITH CIRCUMFLEX)
+107	0x00EB	ë (LATIN SMALL LETTER E WITH DIAERESIS)
+108	0x00EC	ì (LATIN SMALL LETTER I WITH GRAVE)
+109	0x00ED	í (LATIN SMALL LETTER I WITH ACUTE)
+110	0x00EE	î (LATIN SMALL LETTER I WITH CIRCUMFLEX)
+111	0x00EF	ï (LATIN SMALL LETTER I WITH DIAERESIS)
+112	0x00F0	ð (LATIN SMALL LETTER ETH)
+113	0x00F1	ñ (LATIN SMALL LETTER N WITH TILDE)
+114	0x00F2	ò (LATIN SMALL LETTER O WITH GRAVE)
+115	0x00F3	ó (LATIN SMALL LETTER O WITH ACUTE)
+116	0x00F4	ô (LATIN SMALL LETTER O WITH CIRCUMFLEX)
+117	0x00F5	õ (LATIN SMALL LETTER O WITH TILDE)
+118	0x00F6	ö (LATIN SMALL LETTER O WITH DIAERESIS)
+119	0x00F7	÷ (DIVISION SIGN)
+120	0x00F8	ø (LATIN SMALL LETTER O WITH STROKE)
+121	0x00F9	ù (LATIN SMALL LETTER U WITH GRAVE)
+122	0x00FA	ú (LATIN SMALL LETTER U WITH ACUTE)
+123	0x00FB	û (LATIN SMALL LETTER U WITH CIRCUMFLEX)
+124	0x00FC	ü (LATIN SMALL LETTER U WITH DIAERESIS)
+125	0x00FD	ý (LATIN SMALL LETTER Y WITH ACUTE)
+126	0x00FE	þ (LATIN SMALL LETTER THORN)
+127	0x00FF	ÿ (LATIN SMALL LETTER Y WITH DIAERESIS)
diff --git a/test/js/node/test/fixtures/encoding/single-byte/index-windows-1253.txt b/test/js/node/test/fixtures/encoding/single-byte/index-windows-1253.txt
new file mode 100644
index 000000000000..1b025ce1588d
--- /dev/null
+++ b/test/js/node/test/fixtures/encoding/single-byte/index-windows-1253.txt
@@ -0,0 +1,131 @@
+# For details on index index-windows-1253.txt see the Encoding Standard
+# https://encoding.spec.whatwg.org/
+#
+# Identifier: 49fdc881a3488904dd1e8dfba9aef3258454249958b611bcded1d4c981ab5561
+# Date: 2024-09-18
+
+  0	0x20AC	€ (EURO SIGN)
+  1	0x0081	 (<control>)
+  2	0x201A	‚ (SINGLE LOW-9 QUOTATION MARK)
+  3	0x0192	ƒ (LATIN SMALL LETTER F WITH HOOK)
+  4	0x201E	„ (DOUBLE LOW-9 QUOTATION MARK)
+  5	0x2026	… (HORIZONTAL ELLIPSIS)
+  6	0x2020	† (DAGGER)
+  7	0x2021	‡ (DOUBLE DAGGER)
+  8	0x0088	ˆ (<control>)
+  9	0x2030	‰ (PER MILLE SIGN)
+ 10	0x008A	Š (<control>)
+ 11	0x2039	‹ (SINGLE LEFT-POINTING ANGLE QUOTATION MARK)
+ 12	0x008C	Π(<control>)
+ 13	0x008D	 (<control>)
+ 14	0x008E	Ž (<control>)
+ 15	0x008F	 (<control>)
+ 16	0x0090	 (<control>)
+ 17	0x2018	‘ (LEFT SINGLE QUOTATION MARK)
+ 18	0x2019	’ (RIGHT SINGLE QUOTATION MARK)
+ 19	0x201C	“ (LEFT DOUBLE QUOTATION MARK)
+ 20	0x201D	” (RIGHT DOUBLE QUOTATION MARK)
+ 21	0x2022	• (BULLET)
+ 22	0x2013	– (EN DASH)
+ 23	0x2014	— (EM DASH)
+ 24	0x0098	˜ (<control>)
+ 25	0x2122	™ (TRADE MARK SIGN)
+ 26	0x009A	š (<control>)
+ 27	0x203A	› (SINGLE RIGHT-POINTING ANGLE QUOTATION MARK)
+ 28	0x009C	œ (<control>)
+ 29	0x009D	 (<control>)
+ 30	0x009E	ž (<control>)
+ 31	0x009F	Ÿ (<control>)
+ 32	0x00A0	  (NO-BREAK SPACE)
+ 33	0x0385	΅ (GREEK DIALYTIKA TONOS)
+ 34	0x0386	Ά (GREEK CAPITAL LETTER ALPHA WITH TONOS)
+ 35	0x00A3	£ (POUND SIGN)
+ 36	0x00A4	¤ (CURRENCY SIGN)
+ 37	0x00A5	¥ (YEN SIGN)
+ 38	0x00A6	¦ (BROKEN BAR)
+ 39	0x00A7	§ (SECTION SIGN)
+ 40	0x00A8	¨ (DIAERESIS)
+ 41	0x00A9	© (COPYRIGHT SIGN)
+ 43	0x00AB	« (LEFT-POINTING DOUBLE ANGLE QUOTATION MARK)
+ 44	0x00AC	¬ (NOT SIGN)
+ 45	0x00AD	­ (SOFT HYPHEN)
+ 46	0x00AE	® (REGISTERED SIGN)
+ 47	0x2015	― (HORIZONTAL BAR)
+ 48	0x00B0	° (DEGREE SIGN)
+ 49	0x00B1	± (PLUS-MINUS SIGN)
+ 50	0x00B2	² (SUPERSCRIPT TWO)
+ 51	0x00B3	³ (SUPERSCRIPT THREE)
+ 52	0x0384	΄ (GREEK TONOS)
+ 53	0x00B5	µ (MICRO SIGN)
+ 54	0x00B6	¶ (PILCROW SIGN)
+ 55	0x00B7	· (MIDDLE DOT)
+ 56	0x0388	Έ (GREEK CAPITAL LETTER EPSILON WITH TONOS)
+ 57	0x0389	Ή (GREEK CAPITAL LETTER ETA WITH TONOS)
+ 58	0x038A	Ί (GREEK CAPITAL LETTER IOTA WITH TONOS)
+ 59	0x00BB	» (RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK)
+ 60	0x038C	Ό (GREEK CAPITAL LETTER OMICRON WITH TONOS)
+ 61	0x00BD	½ (VULGAR FRACTION ONE HALF)
+ 62	0x038E	Ύ (GREEK CAPITAL LETTER UPSILON WITH TONOS)
+ 63	0x038F	Ώ (GREEK CAPITAL LETTER OMEGA WITH TONOS)
+ 64	0x0390	ΐ (GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS)
+ 65	0x0391	Α (GREEK CAPITAL LETTER ALPHA)
+ 66	0x0392	Β (GREEK CAPITAL LETTER BETA)
+ 67	0x0393	Γ (GREEK CAPITAL LETTER GAMMA)
+ 68	0x0394	Δ (GREEK CAPITAL LETTER DELTA)
+ 69	0x0395	Ε (GREEK CAPITAL LETTER EPSILON)
+ 70	0x0396	Ζ (GREEK CAPITAL LETTER ZETA)
+ 71	0x0397	Η (GREEK CAPITAL LETTER ETA)
+ 72	0x0398	Θ (GREEK CAPITAL LETTER THETA)
+ 73	0x0399	Ι (GREEK CAPITAL LETTER IOTA)
+ 74	0x039A	Κ (GREEK CAPITAL LETTER KAPPA)
+ 75	0x039B	Λ (GREEK CAPITAL LETTER LAMDA)
+ 76	0x039C	Μ (GREEK CAPITAL LETTER MU)
+ 77	0x039D	Ν (GREEK CAPITAL LETTER NU)
+ 78	0x039E	Ξ (GREEK CAPITAL LETTER XI)
+ 79	0x039F	Ο (GREEK CAPITAL LETTER OMICRON)
+ 80	0x03A0	Π (GREEK CAPITAL LETTER PI)
+ 81	0x03A1	Ρ (GREEK CAPITAL LETTER RHO)
+ 83	0x03A3	Σ (GREEK CAPITAL LETTER SIGMA)
+ 84	0x03A4	Τ (GREEK CAPITAL LETTER TAU)
+ 85	0x03A5	Υ (GREEK CAPITAL LETTER UPSILON)
+ 86	0x03A6	Φ (GREEK CAPITAL LETTER PHI)
+ 87	0x03A7	Χ (GREEK CAPITAL LETTER CHI)
+ 88	0x03A8	Ψ (GREEK CAPITAL LETTER PSI)
+ 89	0x03A9	Ω (GREEK CAPITAL LETTER OMEGA)
+ 90	0x03AA	Ϊ (GREEK CAPITAL LETTER IOTA WITH DIALYTIKA)
+ 91	0x03AB	Ϋ (GREEK CAPITAL LETTER UPSILON WITH DIALYTIKA)
+ 92	0x03AC	ά (GREEK SMALL LETTER ALPHA WITH TONOS)
+ 93	0x03AD	έ (GREEK SMALL LETTER EPSILON WITH TONOS)
+ 94	0x03AE	ή (GREEK SMALL LETTER ETA WITH TONOS)
+ 95	0x03AF	ί (GREEK SMALL LETTER IOTA WITH TONOS)
+ 96	0x03B0	ΰ (GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS)
+ 97	0x03B1	α (GREEK SMALL LETTER ALPHA)
+ 98	0x03B2	β (GREEK SMALL LETTER BETA)
+ 99	0x03B3	γ (GREEK SMALL LETTER GAMMA)
+100	0x03B4	δ (GREEK SMALL LETTER DELTA)
+101	0x03B5	ε (GREEK SMALL LETTER EPSILON)
+102	0x03B6	ζ (GREEK SMALL LETTER ZETA)
+103	0x03B7	η (GREEK SMALL LETTER ETA)
+104	0x03B8	θ (GREEK SMALL LETTER THETA)
+105	0x03B9	ι (GREEK SMALL LETTER IOTA)
+106	0x03BA	κ (GREEK SMALL LETTER KAPPA)
+107	0x03BB	λ (GREEK SMALL LETTER LAMDA)
+108	0x03BC	μ (GREEK SMALL LETTER MU)
+109	0x03BD	ν (GREEK SMALL LETTER NU)
+110	0x03BE	ξ (GREEK SMALL LETTER XI)
+111	0x03BF	ο (GREEK SMALL LETTER OMICRON)
+112	0x03C0	π (GREEK SMALL LETTER PI)
+113	0x03C1	ρ (GREEK SMALL LETTER RHO)
+114	0x03C2	ς (GREEK SMALL LETTER FINAL SIGMA)
+115	0x03C3	σ (GREEK SMALL LETTER SIGMA)
+116	0x03C4	τ (GREEK SMALL LETTER TAU)
+117	0x03C5	υ (GREEK SMALL LETTER UPSILON)
+118	0x03C6	φ (GREEK SMALL LETTER PHI)
+119	0x03C7	χ (GREEK SMALL LETTER CHI)
+120	0x03C8	ψ (GREEK SMALL LETTER PSI)
+121	0x03C9	ω (GREEK SMALL LETTER OMEGA)
+122	0x03CA	ϊ (GREEK SMALL LETTER IOTA WITH DIALYTIKA)
+123	0x03CB	ϋ (GREEK SMALL LETTER UPSILON WITH DIALYTIKA)
+124	0x03CC	ό (GREEK SMALL LETTER OMICRON WITH TONOS)
+125	0x03CD	ύ (GREEK SMALL LETTER UPSILON WITH TONOS)
+126	0x03CE	ώ (GREEK SMALL LETTER OMEGA WITH TONOS)
diff --git a/test/js/node/test/fixtures/encoding/single-byte/index-windows-1254.txt b/test/js/node/test/fixtures/encoding/single-byte/index-windows-1254.txt
new file mode 100644
index 000000000000..4195f3dbc029
--- /dev/null
+++ b/test/js/node/test/fixtures/encoding/single-byte/index-windows-1254.txt
@@ -0,0 +1,134 @@
+# For details on index index-windows-1254.txt see the Encoding Standard
+# https://encoding.spec.whatwg.org/
+#
+# Identifier: e80a27adf377438be8ba5bd223875ea56d6a4d47f958cce1c957a2c446825caa
+# Date: 2024-09-18
+
+  0	0x20AC	€ (EURO SIGN)
+  1	0x0081	 (<control>)
+  2	0x201A	‚ (SINGLE LOW-9 QUOTATION MARK)
+  3	0x0192	ƒ (LATIN SMALL LETTER F WITH HOOK)
+  4	0x201E	„ (DOUBLE LOW-9 QUOTATION MARK)
+  5	0x2026	… (HORIZONTAL ELLIPSIS)
+  6	0x2020	† (DAGGER)
+  7	0x2021	‡ (DOUBLE DAGGER)
+  8	0x02C6	ˆ (MODIFIER LETTER CIRCUMFLEX ACCENT)
+  9	0x2030	‰ (PER MILLE SIGN)
+ 10	0x0160	Š (LATIN CAPITAL LETTER S WITH CARON)
+ 11	0x2039	‹ (SINGLE LEFT-POINTING ANGLE QUOTATION MARK)
+ 12	0x0152	Π(LATIN CAPITAL LIGATURE OE)
+ 13	0x008D	 (<control>)
+ 14	0x008E	Ž (<control>)
+ 15	0x008F	 (<control>)
+ 16	0x0090	 (<control>)
+ 17	0x2018	‘ (LEFT SINGLE QUOTATION MARK)
+ 18	0x2019	’ (RIGHT SINGLE QUOTATION MARK)
+ 19	0x201C	“ (LEFT DOUBLE QUOTATION MARK)
+ 20	0x201D	” (RIGHT DOUBLE QUOTATION MARK)
+ 21	0x2022	• (BULLET)
+ 22	0x2013	– (EN DASH)
+ 23	0x2014	— (EM DASH)
+ 24	0x02DC	˜ (SMALL TILDE)
+ 25	0x2122	™ (TRADE MARK SIGN)
+ 26	0x0161	š (LATIN SMALL LETTER S WITH CARON)
+ 27	0x203A	› (SINGLE RIGHT-POINTING ANGLE QUOTATION MARK)
+ 28	0x0153	œ (LATIN SMALL LIGATURE OE)
+ 29	0x009D	 (<control>)
+ 30	0x009E	ž (<control>)
+ 31	0x0178	Ÿ (LATIN CAPITAL LETTER Y WITH DIAERESIS)
+ 32	0x00A0	  (NO-BREAK SPACE)
+ 33	0x00A1	¡ (INVERTED EXCLAMATION MARK)
+ 34	0x00A2	¢ (CENT SIGN)
+ 35	0x00A3	£ (POUND SIGN)
+ 36	0x00A4	¤ (CURRENCY SIGN)
+ 37	0x00A5	¥ (YEN SIGN)
+ 38	0x00A6	¦ (BROKEN BAR)
+ 39	0x00A7	§ (SECTION SIGN)
+ 40	0x00A8	¨ (DIAERESIS)
+ 41	0x00A9	© (COPYRIGHT SIGN)
+ 42	0x00AA	ª (FEMININE ORDINAL INDICATOR)
+ 43	0x00AB	« (LEFT-POINTING DOUBLE ANGLE QUOTATION MARK)
+ 44	0x00AC	¬ (NOT SIGN)
+ 45	0x00AD	­ (SOFT HYPHEN)
+ 46	0x00AE	® (REGISTERED SIGN)
+ 47	0x00AF	¯ (MACRON)
+ 48	0x00B0	° (DEGREE SIGN)
+ 49	0x00B1	± (PLUS-MINUS SIGN)
+ 50	0x00B2	² (SUPERSCRIPT TWO)
+ 51	0x00B3	³ (SUPERSCRIPT THREE)
+ 52	0x00B4	´ (ACUTE ACCENT)
+ 53	0x00B5	µ (MICRO SIGN)
+ 54	0x00B6	¶ (PILCROW SIGN)
+ 55	0x00B7	· (MIDDLE DOT)
+ 56	0x00B8	¸ (CEDILLA)
+ 57	0x00B9	¹ (SUPERSCRIPT ONE)
+ 58	0x00BA	º (MASCULINE ORDINAL INDICATOR)
+ 59	0x00BB	» (RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK)
+ 60	0x00BC	¼ (VULGAR FRACTION ONE QUARTER)
+ 61	0x00BD	½ (VULGAR FRACTION ONE HALF)
+ 62	0x00BE	¾ (VULGAR FRACTION THREE QUARTERS)
+ 63	0x00BF	¿ (INVERTED QUESTION MARK)
+ 64	0x00C0	À (LATIN CAPITAL LETTER A WITH GRAVE)
+ 65	0x00C1	Á (LATIN CAPITAL LETTER A WITH ACUTE)
+ 66	0x00C2	Â (LATIN CAPITAL LETTER A WITH CIRCUMFLEX)
+ 67	0x00C3	Ã (LATIN CAPITAL LETTER A WITH TILDE)
+ 68	0x00C4	Ä (LATIN CAPITAL LETTER A WITH DIAERESIS)
+ 69	0x00C5	Å (LATIN CAPITAL LETTER A WITH RING ABOVE)
+ 70	0x00C6	Æ (LATIN CAPITAL LETTER AE)
+ 71	0x00C7	Ç (LATIN CAPITAL LETTER C WITH CEDILLA)
+ 72	0x00C8	È (LATIN CAPITAL LETTER E WITH GRAVE)
+ 73	0x00C9	É (LATIN CAPITAL LETTER E WITH ACUTE)
+ 74	0x00CA	Ê (LATIN CAPITAL LETTER E WITH CIRCUMFLEX)
+ 75	0x00CB	Ë (LATIN CAPITAL LETTER E WITH DIAERESIS)
+ 76	0x00CC	Ì (LATIN CAPITAL LETTER I WITH GRAVE)
+ 77	0x00CD	Í (LATIN CAPITAL LETTER I WITH ACUTE)
+ 78	0x00CE	Î (LATIN CAPITAL LETTER I WITH CIRCUMFLEX)
+ 79	0x00CF	Ï (LATIN CAPITAL LETTER I WITH DIAERESIS)
+ 80	0x011E	Ğ (LATIN CAPITAL LETTER G WITH BREVE)
+ 81	0x00D1	Ñ (LATIN CAPITAL LETTER N WITH TILDE)
+ 82	0x00D2	Ò (LATIN CAPITAL LETTER O WITH GRAVE)
+ 83	0x00D3	Ó (LATIN CAPITAL LETTER O WITH ACUTE)
+ 84	0x00D4	Ô (LATIN CAPITAL LETTER O WITH CIRCUMFLEX)
+ 85	0x00D5	Õ (LATIN CAPITAL LETTER O WITH TILDE)
+ 86	0x00D6	Ö (LATIN CAPITAL LETTER O WITH DIAERESIS)
+ 87	0x00D7	× (MULTIPLICATION SIGN)
+ 88	0x00D8	Ø (LATIN CAPITAL LETTER O WITH STROKE)
+ 89	0x00D9	Ù (LATIN CAPITAL LETTER U WITH GRAVE)
+ 90	0x00DA	Ú (LATIN CAPITAL LETTER U WITH ACUTE)
+ 91	0x00DB	Û (LATIN CAPITAL LETTER U WITH CIRCUMFLEX)
+ 92	0x00DC	Ü (LATIN CAPITAL LETTER U WITH DIAERESIS)
+ 93	0x0130	İ (LATIN CAPITAL LETTER I WITH DOT ABOVE)
+ 94	0x015E	Ş (LATIN CAPITAL LETTER S WITH CEDILLA)
+ 95	0x00DF	ß (LATIN SMALL LETTER SHARP S)
+ 96	0x00E0	à (LATIN SMALL LETTER A WITH GRAVE)
+ 97	0x00E1	á (LATIN SMALL LETTER A WITH ACUTE)
+ 98	0x00E2	â (LATIN SMALL LETTER A WITH CIRCUMFLEX)
+ 99	0x00E3	ã (LATIN SMALL LETTER A WITH TILDE)
+100	0x00E4	ä (LATIN SMALL LETTER A WITH DIAERESIS)
+101	0x00E5	å (LATIN SMALL LETTER A WITH RING ABOVE)
+102	0x00E6	æ (LATIN SMALL LETTER AE)
+103	0x00E7	ç (LATIN SMALL LETTER C WITH CEDILLA)
+104	0x00E8	è (LATIN SMALL LETTER E WITH GRAVE)
+105	0x00E9	é (LATIN SMALL LETTER E WITH ACUTE)
+106	0x00EA	ê (LATIN SMALL LETTER E WITH CIRCUMFLEX)
+107	0x00EB	ë (LATIN SMALL LETTER E WITH DIAERESIS)
+108	0x00EC	ì (LATIN SMALL LETTER I WITH GRAVE)
+109	0x00ED	í (LATIN SMALL LETTER I WITH ACUTE)
+110	0x00EE	î (LATIN SMALL LETTER I WITH CIRCUMFLEX)
+111	0x00EF	ï (LATIN SMALL LETTER I WITH DIAERESIS)
+112	0x011F	ğ (LATIN SMALL LETTER G WITH BREVE)
+113	0x00F1	ñ (LATIN SMALL LETTER N WITH TILDE)
+114	0x00F2	ò (LATIN SMALL LETTER O WITH GRAVE)
+115	0x00F3	ó (LATIN SMALL LETTER O WITH ACUTE)
+116	0x00F4	ô (LATIN SMALL LETTER O WITH CIRCUMFLEX)
+117	0x00F5	õ (LATIN SMALL LETTER O WITH TILDE)
+118	0x00F6	ö (LATIN SMALL LETTER O WITH DIAERESIS)
+119	0x00F7	÷ (DIVISION SIGN)
+120	0x00F8	ø (LATIN SMALL LETTER O WITH STROKE)
+121	0x00F9	ù (LATIN SMALL LETTER U WITH GRAVE)
+122	0x00FA	ú (LATIN SMALL LETTER U WITH ACUTE)
+123	0x00FB	û (LATIN SMALL LETTER U WITH CIRCUMFLEX)
+124	0x00FC	ü (LATIN SMALL LETTER U WITH DIAERESIS)
+125	0x0131	ı (LATIN SMALL LETTER DOTLESS I)
+126	0x015F	ş (LATIN SMALL LETTER S WITH CEDILLA)
+127	0x00FF	ÿ (LATIN SMALL LETTER Y WITH DIAERESIS)
diff --git a/test/js/node/test/fixtures/encoding/single-byte/index-windows-1255.txt b/test/js/node/test/fixtures/encoding/single-byte/index-windows-1255.txt
new file mode 100644
index 000000000000..3efcbc74e8c8
--- /dev/null
+++ b/test/js/node/test/fixtures/encoding/single-byte/index-windows-1255.txt
@@ -0,0 +1,124 @@
+# For details on index index-windows-1255.txt see the Encoding Standard
+# https://encoding.spec.whatwg.org/
+#
+# Identifier: cd7fb43c97eefa1651084d92d02af53ad668bd848528c18c3b1af5c06b499651
+# Date: 2024-09-18
+
+  0	0x20AC	€ (EURO SIGN)
+  1	0x0081	 (<control>)
+  2	0x201A	‚ (SINGLE LOW-9 QUOTATION MARK)
+  3	0x0192	ƒ (LATIN SMALL LETTER F WITH HOOK)
+  4	0x201E	„ (DOUBLE LOW-9 QUOTATION MARK)
+  5	0x2026	… (HORIZONTAL ELLIPSIS)
+  6	0x2020	† (DAGGER)
+  7	0x2021	‡ (DOUBLE DAGGER)
+  8	0x02C6	ˆ (MODIFIER LETTER CIRCUMFLEX ACCENT)
+  9	0x2030	‰ (PER MILLE SIGN)
+ 10	0x008A	Š (<control>)
+ 11	0x2039	‹ (SINGLE LEFT-POINTING ANGLE QUOTATION MARK)
+ 12	0x008C	Π(<control>)
+ 13	0x008D	 (<control>)
+ 14	0x008E	Ž (<control>)
+ 15	0x008F	 (<control>)
+ 16	0x0090	 (<control>)
+ 17	0x2018	‘ (LEFT SINGLE QUOTATION MARK)
+ 18	0x2019	’ (RIGHT SINGLE QUOTATION MARK)
+ 19	0x201C	“ (LEFT DOUBLE QUOTATION MARK)
+ 20	0x201D	” (RIGHT DOUBLE QUOTATION MARK)
+ 21	0x2022	• (BULLET)
+ 22	0x2013	– (EN DASH)
+ 23	0x2014	— (EM DASH)
+ 24	0x02DC	˜ (SMALL TILDE)
+ 25	0x2122	™ (TRADE MARK SIGN)
+ 26	0x009A	š (<control>)
+ 27	0x203A	› (SINGLE RIGHT-POINTING ANGLE QUOTATION MARK)
+ 28	0x009C	œ (<control>)
+ 29	0x009D	 (<control>)
+ 30	0x009E	ž (<control>)
+ 31	0x009F	Ÿ (<control>)
+ 32	0x00A0	  (NO-BREAK SPACE)
+ 33	0x00A1	¡ (INVERTED EXCLAMATION MARK)
+ 34	0x00A2	¢ (CENT SIGN)
+ 35	0x00A3	£ (POUND SIGN)
+ 36	0x20AA	₪ (NEW SHEQEL SIGN)
+ 37	0x00A5	¥ (YEN SIGN)
+ 38	0x00A6	¦ (BROKEN BAR)
+ 39	0x00A7	§ (SECTION SIGN)
+ 40	0x00A8	¨ (DIAERESIS)
+ 41	0x00A9	© (COPYRIGHT SIGN)
+ 42	0x00D7	× (MULTIPLICATION SIGN)
+ 43	0x00AB	« (LEFT-POINTING DOUBLE ANGLE QUOTATION MARK)
+ 44	0x00AC	¬ (NOT SIGN)
+ 45	0x00AD	­ (SOFT HYPHEN)
+ 46	0x00AE	® (REGISTERED SIGN)
+ 47	0x00AF	¯ (MACRON)
+ 48	0x00B0	° (DEGREE SIGN)
+ 49	0x00B1	± (PLUS-MINUS SIGN)
+ 50	0x00B2	² (SUPERSCRIPT TWO)
+ 51	0x00B3	³ (SUPERSCRIPT THREE)
+ 52	0x00B4	´ (ACUTE ACCENT)
+ 53	0x00B5	µ (MICRO SIGN)
+ 54	0x00B6	¶ (PILCROW SIGN)
+ 55	0x00B7	· (MIDDLE DOT)
+ 56	0x00B8	¸ (CEDILLA)
+ 57	0x00B9	¹ (SUPERSCRIPT ONE)
+ 58	0x00F7	÷ (DIVISION SIGN)
+ 59	0x00BB	» (RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK)
+ 60	0x00BC	¼ (VULGAR FRACTION ONE QUARTER)
+ 61	0x00BD	½ (VULGAR FRACTION ONE HALF)
+ 62	0x00BE	¾ (VULGAR FRACTION THREE QUARTERS)
+ 63	0x00BF	¿ (INVERTED QUESTION MARK)
+ 64	0x05B0	ְ (HEBREW POINT SHEVA)
+ 65	0x05B1	ֱ (HEBREW POINT HATAF SEGOL)
+ 66	0x05B2	ֲ (HEBREW POINT HATAF PATAH)
+ 67	0x05B3	ֳ (HEBREW POINT HATAF QAMATS)
+ 68	0x05B4	ִ (HEBREW POINT HIRIQ)
+ 69	0x05B5	ֵ (HEBREW POINT TSERE)
+ 70	0x05B6	ֶ (HEBREW POINT SEGOL)
+ 71	0x05B7	ַ (HEBREW POINT PATAH)
+ 72	0x05B8	ָ (HEBREW POINT QAMATS)
+ 73	0x05B9	ֹ (HEBREW POINT HOLAM)
+ 74	0x05BA	ֺ (HEBREW POINT HOLAM HASER FOR VAV)
+ 75	0x05BB	ֻ (HEBREW POINT QUBUTS)
+ 76	0x05BC	ּ (HEBREW POINT DAGESH OR MAPIQ)
+ 77	0x05BD	ֽ (HEBREW POINT METEG)
+ 78	0x05BE	־ (HEBREW PUNCTUATION MAQAF)
+ 79	0x05BF	ֿ (HEBREW POINT RAFE)
+ 80	0x05C0	׀ (HEBREW PUNCTUATION PASEQ)
+ 81	0x05C1	ׁ (HEBREW POINT SHIN DOT)
+ 82	0x05C2	ׂ (HEBREW POINT SIN DOT)
+ 83	0x05C3	׃ (HEBREW PUNCTUATION SOF PASUQ)
+ 84	0x05F0	װ (HEBREW LIGATURE YIDDISH DOUBLE VAV)
+ 85	0x05F1	ױ (HEBREW LIGATURE YIDDISH VAV YOD)
+ 86	0x05F2	ײ (HEBREW LIGATURE YIDDISH DOUBLE YOD)
+ 87	0x05F3	׳ (HEBREW PUNCTUATION GERESH)
+ 88	0x05F4	״ (HEBREW PUNCTUATION GERSHAYIM)
+ 96	0x05D0	א (HEBREW LETTER ALEF)
+ 97	0x05D1	ב (HEBREW LETTER BET)
+ 98	0x05D2	ג (HEBREW LETTER GIMEL)
+ 99	0x05D3	ד (HEBREW LETTER DALET)
+100	0x05D4	ה (HEBREW LETTER HE)
+101	0x05D5	ו (HEBREW LETTER VAV)
+102	0x05D6	ז (HEBREW LETTER ZAYIN)
+103	0x05D7	ח (HEBREW LETTER HET)
+104	0x05D8	ט (HEBREW LETTER TET)
+105	0x05D9	י (HEBREW LETTER YOD)
+106	0x05DA	ך (HEBREW LETTER FINAL KAF)
+107	0x05DB	כ (HEBREW LETTER KAF)
+108	0x05DC	ל (HEBREW LETTER LAMED)
+109	0x05DD	ם (HEBREW LETTER FINAL MEM)
+110	0x05DE	מ (HEBREW LETTER MEM)
+111	0x05DF	ן (HEBREW LETTER FINAL NUN)
+112	0x05E0	נ (HEBREW LETTER NUN)
+113	0x05E1	ס (HEBREW LETTER SAMEKH)
+114	0x05E2	ע (HEBREW LETTER AYIN)
+115	0x05E3	ף (HEBREW LETTER FINAL PE)
+116	0x05E4	פ (HEBREW LETTER PE)
+117	0x05E5	ץ (HEBREW LETTER FINAL TSADI)
+118	0x05E6	צ (HEBREW LETTER TSADI)
+119	0x05E7	ק (HEBREW LETTER QOF)
+120	0x05E8	ר (HEBREW LETTER RESH)
+121	0x05E9	ש (HEBREW LETTER SHIN)
+122	0x05EA	ת (HEBREW LETTER TAV)
+125	0x200E	‎ (LEFT-TO-RIGHT MARK)
+126	0x200F	‏ (RIGHT-TO-LEFT MARK)
diff --git a/test/js/node/test/fixtures/encoding/single-byte/index-windows-1256.txt b/test/js/node/test/fixtures/encoding/single-byte/index-windows-1256.txt
new file mode 100644
index 000000000000..8baa3fa8f5a3
--- /dev/null
+++ b/test/js/node/test/fixtures/encoding/single-byte/index-windows-1256.txt
@@ -0,0 +1,134 @@
+# For details on index index-windows-1256.txt see the Encoding Standard
+# https://encoding.spec.whatwg.org/
+#
+# Identifier: 161bdb381f16408e8bebcc8f5310c4190af0e359de8d9bbaa3628ce2f0875509
+# Date: 2024-09-18
+
+  0	0x20AC	€ (EURO SIGN)
+  1	0x067E	پ (ARABIC LETTER PEH)
+  2	0x201A	‚ (SINGLE LOW-9 QUOTATION MARK)
+  3	0x0192	ƒ (LATIN SMALL LETTER F WITH HOOK)
+  4	0x201E	„ (DOUBLE LOW-9 QUOTATION MARK)
+  5	0x2026	… (HORIZONTAL ELLIPSIS)
+  6	0x2020	† (DAGGER)
+  7	0x2021	‡ (DOUBLE DAGGER)
+  8	0x02C6	ˆ (MODIFIER LETTER CIRCUMFLEX ACCENT)
+  9	0x2030	‰ (PER MILLE SIGN)
+ 10	0x0679	ٹ (ARABIC LETTER TTEH)
+ 11	0x2039	‹ (SINGLE LEFT-POINTING ANGLE QUOTATION MARK)
+ 12	0x0152	Π(LATIN CAPITAL LIGATURE OE)
+ 13	0x0686	چ (ARABIC LETTER TCHEH)
+ 14	0x0698	ژ (ARABIC LETTER JEH)
+ 15	0x0688	ڈ (ARABIC LETTER DDAL)
+ 16	0x06AF	گ (ARABIC LETTER GAF)
+ 17	0x2018	‘ (LEFT SINGLE QUOTATION MARK)
+ 18	0x2019	’ (RIGHT SINGLE QUOTATION MARK)
+ 19	0x201C	“ (LEFT DOUBLE QUOTATION MARK)
+ 20	0x201D	” (RIGHT DOUBLE QUOTATION MARK)
+ 21	0x2022	• (BULLET)
+ 22	0x2013	– (EN DASH)
+ 23	0x2014	— (EM DASH)
+ 24	0x06A9	ک (ARABIC LETTER KEHEH)
+ 25	0x2122	™ (TRADE MARK SIGN)
+ 26	0x0691	ڑ (ARABIC LETTER RREH)
+ 27	0x203A	› (SINGLE RIGHT-POINTING ANGLE QUOTATION MARK)
+ 28	0x0153	œ (LATIN SMALL LIGATURE OE)
+ 29	0x200C	‌ (ZERO WIDTH NON-JOINER)
+ 30	0x200D	‍ (ZERO WIDTH JOINER)
+ 31	0x06BA	ں (ARABIC LETTER NOON GHUNNA)
+ 32	0x00A0	  (NO-BREAK SPACE)
+ 33	0x060C	، (ARABIC COMMA)
+ 34	0x00A2	¢ (CENT SIGN)
+ 35	0x00A3	£ (POUND SIGN)
+ 36	0x00A4	¤ (CURRENCY SIGN)
+ 37	0x00A5	¥ (YEN SIGN)
+ 38	0x00A6	¦ (BROKEN BAR)
+ 39	0x00A7	§ (SECTION SIGN)
+ 40	0x00A8	¨ (DIAERESIS)
+ 41	0x00A9	© (COPYRIGHT SIGN)
+ 42	0x06BE	ھ (ARABIC LETTER HEH DOACHASHMEE)
+ 43	0x00AB	« (LEFT-POINTING DOUBLE ANGLE QUOTATION MARK)
+ 44	0x00AC	¬ (NOT SIGN)
+ 45	0x00AD	­ (SOFT HYPHEN)
+ 46	0x00AE	® (REGISTERED SIGN)
+ 47	0x00AF	¯ (MACRON)
+ 48	0x00B0	° (DEGREE SIGN)
+ 49	0x00B1	± (PLUS-MINUS SIGN)
+ 50	0x00B2	² (SUPERSCRIPT TWO)
+ 51	0x00B3	³ (SUPERSCRIPT THREE)
+ 52	0x00B4	´ (ACUTE ACCENT)
+ 53	0x00B5	µ (MICRO SIGN)
+ 54	0x00B6	¶ (PILCROW SIGN)
+ 55	0x00B7	· (MIDDLE DOT)
+ 56	0x00B8	¸ (CEDILLA)
+ 57	0x00B9	¹ (SUPERSCRIPT ONE)
+ 58	0x061B	؛ (ARABIC SEMICOLON)
+ 59	0x00BB	» (RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK)
+ 60	0x00BC	¼ (VULGAR FRACTION ONE QUARTER)
+ 61	0x00BD	½ (VULGAR FRACTION ONE HALF)
+ 62	0x00BE	¾ (VULGAR FRACTION THREE QUARTERS)
+ 63	0x061F	؟ (ARABIC QUESTION MARK)
+ 64	0x06C1	ہ (ARABIC LETTER HEH GOAL)
+ 65	0x0621	ء (ARABIC LETTER HAMZA)
+ 66	0x0622	آ (ARABIC LETTER ALEF WITH MADDA ABOVE)
+ 67	0x0623	أ (ARABIC LETTER ALEF WITH HAMZA ABOVE)
+ 68	0x0624	ؤ (ARABIC LETTER WAW WITH HAMZA ABOVE)
+ 69	0x0625	إ (ARABIC LETTER ALEF WITH HAMZA BELOW)
+ 70	0x0626	ئ (ARABIC LETTER YEH WITH HAMZA ABOVE)
+ 71	0x0627	ا (ARABIC LETTER ALEF)
+ 72	0x0628	ب (ARABIC LETTER BEH)
+ 73	0x0629	ة (ARABIC LETTER TEH MARBUTA)
+ 74	0x062A	ت (ARABIC LETTER TEH)
+ 75	0x062B	ث (ARABIC LETTER THEH)
+ 76	0x062C	ج (ARABIC LETTER JEEM)
+ 77	0x062D	ح (ARABIC LETTER HAH)
+ 78	0x062E	خ (ARABIC LETTER KHAH)
+ 79	0x062F	د (ARABIC LETTER DAL)
+ 80	0x0630	ذ (ARABIC LETTER THAL)
+ 81	0x0631	ر (ARABIC LETTER REH)
+ 82	0x0632	ز (ARABIC LETTER ZAIN)
+ 83	0x0633	س (ARABIC LETTER SEEN)
+ 84	0x0634	ش (ARABIC LETTER SHEEN)
+ 85	0x0635	ص (ARABIC LETTER SAD)
+ 86	0x0636	ض (ARABIC LETTER DAD)
+ 87	0x00D7	× (MULTIPLICATION SIGN)
+ 88	0x0637	ط (ARABIC LETTER TAH)
+ 89	0x0638	ظ (ARABIC LETTER ZAH)
+ 90	0x0639	ع (ARABIC LETTER AIN)
+ 91	0x063A	غ (ARABIC LETTER GHAIN)
+ 92	0x0640	ـ (ARABIC TATWEEL)
+ 93	0x0641	ف (ARABIC LETTER FEH)
+ 94	0x0642	ق (ARABIC LETTER QAF)
+ 95	0x0643	ك (ARABIC LETTER KAF)
+ 96	0x00E0	à (LATIN SMALL LETTER A WITH GRAVE)
+ 97	0x0644	ل (ARABIC LETTER LAM)
+ 98	0x00E2	â (LATIN SMALL LETTER A WITH CIRCUMFLEX)
+ 99	0x0645	م (ARABIC LETTER MEEM)
+100	0x0646	ن (ARABIC LETTER NOON)
+101	0x0647	ه (ARABIC LETTER HEH)
+102	0x0648	و (ARABIC LETTER WAW)
+103	0x00E7	ç (LATIN SMALL LETTER C WITH CEDILLA)
+104	0x00E8	è (LATIN SMALL LETTER E WITH GRAVE)
+105	0x00E9	é (LATIN SMALL LETTER E WITH ACUTE)
+106	0x00EA	ê (LATIN SMALL LETTER E WITH CIRCUMFLEX)
+107	0x00EB	ë (LATIN SMALL LETTER E WITH DIAERESIS)
+108	0x0649	ى (ARABIC LETTER ALEF MAKSURA)
+109	0x064A	ي (ARABIC LETTER YEH)
+110	0x00EE	î (LATIN SMALL LETTER I WITH CIRCUMFLEX)
+111	0x00EF	ï (LATIN SMALL LETTER I WITH DIAERESIS)
+112	0x064B	ً (ARABIC FATHATAN)
+113	0x064C	ٌ (ARABIC DAMMATAN)
+114	0x064D	ٍ (ARABIC KASRATAN)
+115	0x064E	َ (ARABIC FATHA)
+116	0x00F4	ô (LATIN SMALL LETTER O WITH CIRCUMFLEX)
+117	0x064F	ُ (ARABIC DAMMA)
+118	0x0650	ِ (ARABIC KASRA)
+119	0x00F7	÷ (DIVISION SIGN)
+120	0x0651	ّ (ARABIC SHADDA)
+121	0x00F9	ù (LATIN SMALL LETTER U WITH GRAVE)
+122	0x0652	ْ (ARABIC SUKUN)
+123	0x00FB	û (LATIN SMALL LETTER U WITH CIRCUMFLEX)
+124	0x00FC	ü (LATIN SMALL LETTER U WITH DIAERESIS)
+125	0x200E	‎ (LEFT-TO-RIGHT MARK)
+126	0x200F	‏ (RIGHT-TO-LEFT MARK)
+127	0x06D2	ے (ARABIC LETTER YEH BARREE)
diff --git a/test/js/node/test/fixtures/encoding/single-byte/index-windows-1257.txt b/test/js/node/test/fixtures/encoding/single-byte/index-windows-1257.txt
new file mode 100644
index 000000000000..ffbf66120894
--- /dev/null
+++ b/test/js/node/test/fixtures/encoding/single-byte/index-windows-1257.txt
@@ -0,0 +1,132 @@
+# For details on index index-windows-1257.txt see the Encoding Standard
+# https://encoding.spec.whatwg.org/
+#
+# Identifier: cc7256bdd10a5b8dc7fb6f994659f307dfcae60def9aa6c29d811f85e2842c47
+# Date: 2024-09-18
+
+  0	0x20AC	€ (EURO SIGN)
+  1	0x0081	 (<control>)
+  2	0x201A	‚ (SINGLE LOW-9 QUOTATION MARK)
+  3	0x0083	ƒ (<control>)
+  4	0x201E	„ (DOUBLE LOW-9 QUOTATION MARK)
+  5	0x2026	… (HORIZONTAL ELLIPSIS)
+  6	0x2020	† (DAGGER)
+  7	0x2021	‡ (DOUBLE DAGGER)
+  8	0x0088	ˆ (<control>)
+  9	0x2030	‰ (PER MILLE SIGN)
+ 10	0x008A	Š (<control>)
+ 11	0x2039	‹ (SINGLE LEFT-POINTING ANGLE QUOTATION MARK)
+ 12	0x008C	Π(<control>)
+ 13	0x00A8	¨ (DIAERESIS)
+ 14	0x02C7	ˇ (CARON)
+ 15	0x00B8	¸ (CEDILLA)
+ 16	0x0090	 (<control>)
+ 17	0x2018	‘ (LEFT SINGLE QUOTATION MARK)
+ 18	0x2019	’ (RIGHT SINGLE QUOTATION MARK)
+ 19	0x201C	“ (LEFT DOUBLE QUOTATION MARK)
+ 20	0x201D	” (RIGHT DOUBLE QUOTATION MARK)
+ 21	0x2022	• (BULLET)
+ 22	0x2013	– (EN DASH)
+ 23	0x2014	— (EM DASH)
+ 24	0x0098	˜ (<control>)
+ 25	0x2122	™ (TRADE MARK SIGN)
+ 26	0x009A	š (<control>)
+ 27	0x203A	› (SINGLE RIGHT-POINTING ANGLE QUOTATION MARK)
+ 28	0x009C	œ (<control>)
+ 29	0x00AF	¯ (MACRON)
+ 30	0x02DB	˛ (OGONEK)
+ 31	0x009F	Ÿ (<control>)
+ 32	0x00A0	  (NO-BREAK SPACE)
+ 34	0x00A2	¢ (CENT SIGN)
+ 35	0x00A3	£ (POUND SIGN)
+ 36	0x00A4	¤ (CURRENCY SIGN)
+ 38	0x00A6	¦ (BROKEN BAR)
+ 39	0x00A7	§ (SECTION SIGN)
+ 40	0x00D8	Ø (LATIN CAPITAL LETTER O WITH STROKE)
+ 41	0x00A9	© (COPYRIGHT SIGN)
+ 42	0x0156	Ŗ (LATIN CAPITAL LETTER R WITH CEDILLA)
+ 43	0x00AB	« (LEFT-POINTING DOUBLE ANGLE QUOTATION MARK)
+ 44	0x00AC	¬ (NOT SIGN)
+ 45	0x00AD	­ (SOFT HYPHEN)
+ 46	0x00AE	® (REGISTERED SIGN)
+ 47	0x00C6	Æ (LATIN CAPITAL LETTER AE)
+ 48	0x00B0	° (DEGREE SIGN)
+ 49	0x00B1	± (PLUS-MINUS SIGN)
+ 50	0x00B2	² (SUPERSCRIPT TWO)
+ 51	0x00B3	³ (SUPERSCRIPT THREE)
+ 52	0x00B4	´ (ACUTE ACCENT)
+ 53	0x00B5	µ (MICRO SIGN)
+ 54	0x00B6	¶ (PILCROW SIGN)
+ 55	0x00B7	· (MIDDLE DOT)
+ 56	0x00F8	ø (LATIN SMALL LETTER O WITH STROKE)
+ 57	0x00B9	¹ (SUPERSCRIPT ONE)
+ 58	0x0157	ŗ (LATIN SMALL LETTER R WITH CEDILLA)
+ 59	0x00BB	» (RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK)
+ 60	0x00BC	¼ (VULGAR FRACTION ONE QUARTER)
+ 61	0x00BD	½ (VULGAR FRACTION ONE HALF)
+ 62	0x00BE	¾ (VULGAR FRACTION THREE QUARTERS)
+ 63	0x00E6	æ (LATIN SMALL LETTER AE)
+ 64	0x0104	Ą (LATIN CAPITAL LETTER A WITH OGONEK)
+ 65	0x012E	Į (LATIN CAPITAL LETTER I WITH OGONEK)
+ 66	0x0100	Ā (LATIN CAPITAL LETTER A WITH MACRON)
+ 67	0x0106	Ć (LATIN CAPITAL LETTER C WITH ACUTE)
+ 68	0x00C4	Ä (LATIN CAPITAL LETTER A WITH DIAERESIS)
+ 69	0x00C5	Å (LATIN CAPITAL LETTER A WITH RING ABOVE)
+ 70	0x0118	Ę (LATIN CAPITAL LETTER E WITH OGONEK)
+ 71	0x0112	Ē (LATIN CAPITAL LETTER E WITH MACRON)
+ 72	0x010C	Č (LATIN CAPITAL LETTER C WITH CARON)
+ 73	0x00C9	É (LATIN CAPITAL LETTER E WITH ACUTE)
+ 74	0x0179	Ź (LATIN CAPITAL LETTER Z WITH ACUTE)
+ 75	0x0116	Ė (LATIN CAPITAL LETTER E WITH DOT ABOVE)
+ 76	0x0122	Ģ (LATIN CAPITAL LETTER G WITH CEDILLA)
+ 77	0x0136	Ķ (LATIN CAPITAL LETTER K WITH CEDILLA)
+ 78	0x012A	Ī (LATIN CAPITAL LETTER I WITH MACRON)
+ 79	0x013B	Ļ (LATIN CAPITAL LETTER L WITH CEDILLA)
+ 80	0x0160	Š (LATIN CAPITAL LETTER S WITH CARON)
+ 81	0x0143	Ń (LATIN CAPITAL LETTER N WITH ACUTE)
+ 82	0x0145	Ņ (LATIN CAPITAL LETTER N WITH CEDILLA)
+ 83	0x00D3	Ó (LATIN CAPITAL LETTER O WITH ACUTE)
+ 84	0x014C	Ō (LATIN CAPITAL LETTER O WITH MACRON)
+ 85	0x00D5	Õ (LATIN CAPITAL LETTER O WITH TILDE)
+ 86	0x00D6	Ö (LATIN CAPITAL LETTER O WITH DIAERESIS)
+ 87	0x00D7	× (MULTIPLICATION SIGN)
+ 88	0x0172	Ų (LATIN CAPITAL LETTER U WITH OGONEK)
+ 89	0x0141	Ł (LATIN CAPITAL LETTER L WITH STROKE)
+ 90	0x015A	Ś (LATIN CAPITAL LETTER S WITH ACUTE)
+ 91	0x016A	Ū (LATIN CAPITAL LETTER U WITH MACRON)
+ 92	0x00DC	Ü (LATIN CAPITAL LETTER U WITH DIAERESIS)
+ 93	0x017B	Ż (LATIN CAPITAL LETTER Z WITH DOT ABOVE)
+ 94	0x017D	Ž (LATIN CAPITAL LETTER Z WITH CARON)
+ 95	0x00DF	ß (LATIN SMALL LETTER SHARP S)
+ 96	0x0105	ą (LATIN SMALL LETTER A WITH OGONEK)
+ 97	0x012F	į (LATIN SMALL LETTER I WITH OGONEK)
+ 98	0x0101	ā (LATIN SMALL LETTER A WITH MACRON)
+ 99	0x0107	ć (LATIN SMALL LETTER C WITH ACUTE)
+100	0x00E4	ä (LATIN SMALL LETTER A WITH DIAERESIS)
+101	0x00E5	å (LATIN SMALL LETTER A WITH RING ABOVE)
+102	0x0119	ę (LATIN SMALL LETTER E WITH OGONEK)
+103	0x0113	ē (LATIN SMALL LETTER E WITH MACRON)
+104	0x010D	č (LATIN SMALL LETTER C WITH CARON)
+105	0x00E9	é (LATIN SMALL LETTER E WITH ACUTE)
+106	0x017A	ź (LATIN SMALL LETTER Z WITH ACUTE)
+107	0x0117	ė (LATIN SMALL LETTER E WITH DOT ABOVE)
+108	0x0123	ģ (LATIN SMALL LETTER G WITH CEDILLA)
+109	0x0137	ķ (LATIN SMALL LETTER K WITH CEDILLA)
+110	0x012B	ī (LATIN SMALL LETTER I WITH MACRON)
+111	0x013C	ļ (LATIN SMALL LETTER L WITH CEDILLA)
+112	0x0161	š (LATIN SMALL LETTER S WITH CARON)
+113	0x0144	ń (LATIN SMALL LETTER N WITH ACUTE)
+114	0x0146	ņ (LATIN SMALL LETTER N WITH CEDILLA)
+115	0x00F3	ó (LATIN SMALL LETTER O WITH ACUTE)
+116	0x014D	ō (LATIN SMALL LETTER O WITH MACRON)
+117	0x00F5	õ (LATIN SMALL LETTER O WITH TILDE)
+118	0x00F6	ö (LATIN SMALL LETTER O WITH DIAERESIS)
+119	0x00F7	÷ (DIVISION SIGN)
+120	0x0173	ų (LATIN SMALL LETTER U WITH OGONEK)
+121	0x0142	ł (LATIN SMALL LETTER L WITH STROKE)
+122	0x015B	ś (LATIN SMALL LETTER S WITH ACUTE)
+123	0x016B	ū (LATIN SMALL LETTER U WITH MACRON)
+124	0x00FC	ü (LATIN SMALL LETTER U WITH DIAERESIS)
+125	0x017C	ż (LATIN SMALL LETTER Z WITH DOT ABOVE)
+126	0x017E	ž (LATIN SMALL LETTER Z WITH CARON)
+127	0x02D9	˙ (DOT ABOVE)
diff --git a/test/js/node/test/fixtures/encoding/single-byte/index-windows-1258.txt b/test/js/node/test/fixtures/encoding/single-byte/index-windows-1258.txt
new file mode 100644
index 000000000000..568141350ab0
--- /dev/null
+++ b/test/js/node/test/fixtures/encoding/single-byte/index-windows-1258.txt
@@ -0,0 +1,134 @@
+# For details on index index-windows-1258.txt see the Encoding Standard
+# https://encoding.spec.whatwg.org/
+#
+# Identifier: 198bacedfcf24390e219240a7b776b6cec34cff070330b08a601a69c67f7eb24
+# Date: 2024-09-18
+
+  0	0x20AC	€ (EURO SIGN)
+  1	0x0081	 (<control>)
+  2	0x201A	‚ (SINGLE LOW-9 QUOTATION MARK)
+  3	0x0192	ƒ (LATIN SMALL LETTER F WITH HOOK)
+  4	0x201E	„ (DOUBLE LOW-9 QUOTATION MARK)
+  5	0x2026	… (HORIZONTAL ELLIPSIS)
+  6	0x2020	† (DAGGER)
+  7	0x2021	‡ (DOUBLE DAGGER)
+  8	0x02C6	ˆ (MODIFIER LETTER CIRCUMFLEX ACCENT)
+  9	0x2030	‰ (PER MILLE SIGN)
+ 10	0x008A	Š (<control>)
+ 11	0x2039	‹ (SINGLE LEFT-POINTING ANGLE QUOTATION MARK)
+ 12	0x0152	Π(LATIN CAPITAL LIGATURE OE)
+ 13	0x008D	 (<control>)
+ 14	0x008E	Ž (<control>)
+ 15	0x008F	 (<control>)
+ 16	0x0090	 (<control>)
+ 17	0x2018	‘ (LEFT SINGLE QUOTATION MARK)
+ 18	0x2019	’ (RIGHT SINGLE QUOTATION MARK)
+ 19	0x201C	“ (LEFT DOUBLE QUOTATION MARK)
+ 20	0x201D	” (RIGHT DOUBLE QUOTATION MARK)
+ 21	0x2022	• (BULLET)
+ 22	0x2013	– (EN DASH)
+ 23	0x2014	— (EM DASH)
+ 24	0x02DC	˜ (SMALL TILDE)
+ 25	0x2122	™ (TRADE MARK SIGN)
+ 26	0x009A	š (<control>)
+ 27	0x203A	› (SINGLE RIGHT-POINTING ANGLE QUOTATION MARK)
+ 28	0x0153	œ (LATIN SMALL LIGATURE OE)
+ 29	0x009D	 (<control>)
+ 30	0x009E	ž (<control>)
+ 31	0x0178	Ÿ (LATIN CAPITAL LETTER Y WITH DIAERESIS)
+ 32	0x00A0	  (NO-BREAK SPACE)
+ 33	0x00A1	¡ (INVERTED EXCLAMATION MARK)
+ 34	0x00A2	¢ (CENT SIGN)
+ 35	0x00A3	£ (POUND SIGN)
+ 36	0x00A4	¤ (CURRENCY SIGN)
+ 37	0x00A5	¥ (YEN SIGN)
+ 38	0x00A6	¦ (BROKEN BAR)
+ 39	0x00A7	§ (SECTION SIGN)
+ 40	0x00A8	¨ (DIAERESIS)
+ 41	0x00A9	© (COPYRIGHT SIGN)
+ 42	0x00AA	ª (FEMININE ORDINAL INDICATOR)
+ 43	0x00AB	« (LEFT-POINTING DOUBLE ANGLE QUOTATION MARK)
+ 44	0x00AC	¬ (NOT SIGN)
+ 45	0x00AD	­ (SOFT HYPHEN)
+ 46	0x00AE	® (REGISTERED SIGN)
+ 47	0x00AF	¯ (MACRON)
+ 48	0x00B0	° (DEGREE SIGN)
+ 49	0x00B1	± (PLUS-MINUS SIGN)
+ 50	0x00B2	² (SUPERSCRIPT TWO)
+ 51	0x00B3	³ (SUPERSCRIPT THREE)
+ 52	0x00B4	´ (ACUTE ACCENT)
+ 53	0x00B5	µ (MICRO SIGN)
+ 54	0x00B6	¶ (PILCROW SIGN)
+ 55	0x00B7	· (MIDDLE DOT)
+ 56	0x00B8	¸ (CEDILLA)
+ 57	0x00B9	¹ (SUPERSCRIPT ONE)
+ 58	0x00BA	º (MASCULINE ORDINAL INDICATOR)
+ 59	0x00BB	» (RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK)
+ 60	0x00BC	¼ (VULGAR FRACTION ONE QUARTER)
+ 61	0x00BD	½ (VULGAR FRACTION ONE HALF)
+ 62	0x00BE	¾ (VULGAR FRACTION THREE QUARTERS)
+ 63	0x00BF	¿ (INVERTED QUESTION MARK)
+ 64	0x00C0	À (LATIN CAPITAL LETTER A WITH GRAVE)
+ 65	0x00C1	Á (LATIN CAPITAL LETTER A WITH ACUTE)
+ 66	0x00C2	Â (LATIN CAPITAL LETTER A WITH CIRCUMFLEX)
+ 67	0x0102	Ă (LATIN CAPITAL LETTER A WITH BREVE)
+ 68	0x00C4	Ä (LATIN CAPITAL LETTER A WITH DIAERESIS)
+ 69	0x00C5	Å (LATIN CAPITAL LETTER A WITH RING ABOVE)
+ 70	0x00C6	Æ (LATIN CAPITAL LETTER AE)
+ 71	0x00C7	Ç (LATIN CAPITAL LETTER C WITH CEDILLA)
+ 72	0x00C8	È (LATIN CAPITAL LETTER E WITH GRAVE)
+ 73	0x00C9	É (LATIN CAPITAL LETTER E WITH ACUTE)
+ 74	0x00CA	Ê (LATIN CAPITAL LETTER E WITH CIRCUMFLEX)
+ 75	0x00CB	Ë (LATIN CAPITAL LETTER E WITH DIAERESIS)
+ 76	0x0300	̀ (COMBINING GRAVE ACCENT)
+ 77	0x00CD	Í (LATIN CAPITAL LETTER I WITH ACUTE)
+ 78	0x00CE	Î (LATIN CAPITAL LETTER I WITH CIRCUMFLEX)
+ 79	0x00CF	Ï (LATIN CAPITAL LETTER I WITH DIAERESIS)
+ 80	0x0110	Đ (LATIN CAPITAL LETTER D WITH STROKE)
+ 81	0x00D1	Ñ (LATIN CAPITAL LETTER N WITH TILDE)
+ 82	0x0309	̉ (COMBINING HOOK ABOVE)
+ 83	0x00D3	Ó (LATIN CAPITAL LETTER O WITH ACUTE)
+ 84	0x00D4	Ô (LATIN CAPITAL LETTER O WITH CIRCUMFLEX)
+ 85	0x01A0	Ơ (LATIN CAPITAL LETTER O WITH HORN)
+ 86	0x00D6	Ö (LATIN CAPITAL LETTER O WITH DIAERESIS)
+ 87	0x00D7	× (MULTIPLICATION SIGN)
+ 88	0x00D8	Ø (LATIN CAPITAL LETTER O WITH STROKE)
+ 89	0x00D9	Ù (LATIN CAPITAL LETTER U WITH GRAVE)
+ 90	0x00DA	Ú (LATIN CAPITAL LETTER U WITH ACUTE)
+ 91	0x00DB	Û (LATIN CAPITAL LETTER U WITH CIRCUMFLEX)
+ 92	0x00DC	Ü (LATIN CAPITAL LETTER U WITH DIAERESIS)
+ 93	0x01AF	Ư (LATIN CAPITAL LETTER U WITH HORN)
+ 94	0x0303	̃ (COMBINING TILDE)
+ 95	0x00DF	ß (LATIN SMALL LETTER SHARP S)
+ 96	0x00E0	à (LATIN SMALL LETTER A WITH GRAVE)
+ 97	0x00E1	á (LATIN SMALL LETTER A WITH ACUTE)
+ 98	0x00E2	â (LATIN SMALL LETTER A WITH CIRCUMFLEX)
+ 99	0x0103	ă (LATIN SMALL LETTER A WITH BREVE)
+100	0x00E4	ä (LATIN SMALL LETTER A WITH DIAERESIS)
+101	0x00E5	å (LATIN SMALL LETTER A WITH RING ABOVE)
+102	0x00E6	æ (LATIN SMALL LETTER AE)
+103	0x00E7	ç (LATIN SMALL LETTER C WITH CEDILLA)
+104	0x00E8	è (LATIN SMALL LETTER E WITH GRAVE)
+105	0x00E9	é (LATIN SMALL LETTER E WITH ACUTE)
+106	0x00EA	ê (LATIN SMALL LETTER E WITH CIRCUMFLEX)
+107	0x00EB	ë (LATIN SMALL LETTER E WITH DIAERESIS)
+108	0x0301	́ (COMBINING ACUTE ACCENT)
+109	0x00ED	í (LATIN SMALL LETTER I WITH ACUTE)
+110	0x00EE	î (LATIN SMALL LETTER I WITH CIRCUMFLEX)
+111	0x00EF	ï (LATIN SMALL LETTER I WITH DIAERESIS)
+112	0x0111	đ (LATIN SMALL LETTER D WITH STROKE)
+113	0x00F1	ñ (LATIN SMALL LETTER N WITH TILDE)
+114	0x0323	̣ (COMBINING DOT BELOW)
+115	0x00F3	ó (LATIN SMALL LETTER O WITH ACUTE)
+116	0x00F4	ô (LATIN SMALL LETTER O WITH CIRCUMFLEX)
+117	0x01A1	ơ (LATIN SMALL LETTER O WITH HORN)
+118	0x00F6	ö (LATIN SMALL LETTER O WITH DIAERESIS)
+119	0x00F7	÷ (DIVISION SIGN)
+120	0x00F8	ø (LATIN SMALL LETTER O WITH STROKE)
+121	0x00F9	ù (LATIN SMALL LETTER U WITH GRAVE)
+122	0x00FA	ú (LATIN SMALL LETTER U WITH ACUTE)
+123	0x00FB	û (LATIN SMALL LETTER U WITH CIRCUMFLEX)
+124	0x00FC	ü (LATIN SMALL LETTER U WITH DIAERESIS)
+125	0x01B0	ư (LATIN SMALL LETTER U WITH HORN)
+126	0x20AB	₫ (DONG SIGN)
+127	0x00FF	ÿ (LATIN SMALL LETTER Y WITH DIAERESIS)
diff --git a/test/js/node/test/fixtures/encoding/single-byte/index-windows-874.txt b/test/js/node/test/fixtures/encoding/single-byte/index-windows-874.txt
new file mode 100644
index 000000000000..57315c20ff16
--- /dev/null
+++ b/test/js/node/test/fixtures/encoding/single-byte/index-windows-874.txt
@@ -0,0 +1,126 @@
+# For details on index index-windows-874.txt see the Encoding Standard
+# https://encoding.spec.whatwg.org/
+#
+# Identifier: b416583ce125e38474381b31b401a98b19ecf2e57e0998e78a1e18b14894905d
+# Date: 2024-09-18
+
+  0	0x20AC	€ (EURO SIGN)
+  1	0x0081	 (<control>)
+  2	0x0082	‚ (<control>)
+  3	0x0083	ƒ (<control>)
+  4	0x0084	„ (<control>)
+  5	0x2026	… (HORIZONTAL ELLIPSIS)
+  6	0x0086	† (<control>)
+  7	0x0087	‡ (<control>)
+  8	0x0088	ˆ (<control>)
+  9	0x0089	‰ (<control>)
+ 10	0x008A	Š (<control>)
+ 11	0x008B	‹ (<control>)
+ 12	0x008C	Π(<control>)
+ 13	0x008D	 (<control>)
+ 14	0x008E	Ž (<control>)
+ 15	0x008F	 (<control>)
+ 16	0x0090	 (<control>)
+ 17	0x2018	‘ (LEFT SINGLE QUOTATION MARK)
+ 18	0x2019	’ (RIGHT SINGLE QUOTATION MARK)
+ 19	0x201C	“ (LEFT DOUBLE QUOTATION MARK)
+ 20	0x201D	” (RIGHT DOUBLE QUOTATION MARK)
+ 21	0x2022	• (BULLET)
+ 22	0x2013	– (EN DASH)
+ 23	0x2014	— (EM DASH)
+ 24	0x0098	˜ (<control>)
+ 25	0x0099	™ (<control>)
+ 26	0x009A	š (<control>)
+ 27	0x009B	› (<control>)
+ 28	0x009C	œ (<control>)
+ 29	0x009D	 (<control>)
+ 30	0x009E	ž (<control>)
+ 31	0x009F	Ÿ (<control>)
+ 32	0x00A0	  (NO-BREAK SPACE)
+ 33	0x0E01	ก (THAI CHARACTER KO KAI)
+ 34	0x0E02	ข (THAI CHARACTER KHO KHAI)
+ 35	0x0E03	ฃ (THAI CHARACTER KHO KHUAT)
+ 36	0x0E04	ค (THAI CHARACTER KHO KHWAI)
+ 37	0x0E05	ฅ (THAI CHARACTER KHO KHON)
+ 38	0x0E06	ฆ (THAI CHARACTER KHO RAKHANG)
+ 39	0x0E07	ง (THAI CHARACTER NGO NGU)
+ 40	0x0E08	จ (THAI CHARACTER CHO CHAN)
+ 41	0x0E09	ฉ (THAI CHARACTER CHO CHING)
+ 42	0x0E0A	ช (THAI CHARACTER CHO CHANG)
+ 43	0x0E0B	ซ (THAI CHARACTER SO SO)
+ 44	0x0E0C	ฌ (THAI CHARACTER CHO CHOE)
+ 45	0x0E0D	ญ (THAI CHARACTER YO YING)
+ 46	0x0E0E	ฎ (THAI CHARACTER DO CHADA)
+ 47	0x0E0F	ฏ (THAI CHARACTER TO PATAK)
+ 48	0x0E10	ฐ (THAI CHARACTER THO THAN)
+ 49	0x0E11	ฑ (THAI CHARACTER THO NANGMONTHO)
+ 50	0x0E12	ฒ (THAI CHARACTER THO PHUTHAO)
+ 51	0x0E13	ณ (THAI CHARACTER NO NEN)
+ 52	0x0E14	ด (THAI CHARACTER DO DEK)
+ 53	0x0E15	ต (THAI CHARACTER TO TAO)
+ 54	0x0E16	ถ (THAI CHARACTER THO THUNG)
+ 55	0x0E17	ท (THAI CHARACTER THO THAHAN)
+ 56	0x0E18	ธ (THAI CHARACTER THO THONG)
+ 57	0x0E19	น (THAI CHARACTER NO NU)
+ 58	0x0E1A	บ (THAI CHARACTER BO BAIMAI)
+ 59	0x0E1B	ป (THAI CHARACTER PO PLA)
+ 60	0x0E1C	ผ (THAI CHARACTER PHO PHUNG)
+ 61	0x0E1D	ฝ (THAI CHARACTER FO FA)
+ 62	0x0E1E	พ (THAI CHARACTER PHO PHAN)
+ 63	0x0E1F	ฟ (THAI CHARACTER FO FAN)
+ 64	0x0E20	ภ (THAI CHARACTER PHO SAMPHAO)
+ 65	0x0E21	ม (THAI CHARACTER MO MA)
+ 66	0x0E22	ย (THAI CHARACTER YO YAK)
+ 67	0x0E23	ร (THAI CHARACTER RO RUA)
+ 68	0x0E24	ฤ (THAI CHARACTER RU)
+ 69	0x0E25	ล (THAI CHARACTER LO LING)
+ 70	0x0E26	ฦ (THAI CHARACTER LU)
+ 71	0x0E27	ว (THAI CHARACTER WO WAEN)
+ 72	0x0E28	ศ (THAI CHARACTER SO SALA)
+ 73	0x0E29	ษ (THAI CHARACTER SO RUSI)
+ 74	0x0E2A	ส (THAI CHARACTER SO SUA)
+ 75	0x0E2B	ห (THAI CHARACTER HO HIP)
+ 76	0x0E2C	ฬ (THAI CHARACTER LO CHULA)
+ 77	0x0E2D	อ (THAI CHARACTER O ANG)
+ 78	0x0E2E	ฮ (THAI CHARACTER HO NOKHUK)
+ 79	0x0E2F	ฯ (THAI CHARACTER PAIYANNOI)
+ 80	0x0E30	ะ (THAI CHARACTER SARA A)
+ 81	0x0E31	ั (THAI CHARACTER MAI HAN-AKAT)
+ 82	0x0E32	า (THAI CHARACTER SARA AA)
+ 83	0x0E33	ำ (THAI CHARACTER SARA AM)
+ 84	0x0E34	ิ (THAI CHARACTER SARA I)
+ 85	0x0E35	ี (THAI CHARACTER SARA II)
+ 86	0x0E36	ึ (THAI CHARACTER SARA UE)
+ 87	0x0E37	ื (THAI CHARACTER SARA UEE)
+ 88	0x0E38	ุ (THAI CHARACTER SARA U)
+ 89	0x0E39	ู (THAI CHARACTER SARA UU)
+ 90	0x0E3A	ฺ (THAI CHARACTER PHINTHU)
+ 95	0x0E3F	฿ (THAI CURRENCY SYMBOL BAHT)
+ 96	0x0E40	เ (THAI CHARACTER SARA E)
+ 97	0x0E41	แ (THAI CHARACTER SARA AE)
+ 98	0x0E42	โ (THAI CHARACTER SARA O)
+ 99	0x0E43	ใ (THAI CHARACTER SARA AI MAIMUAN)
+100	0x0E44	ไ (THAI CHARACTER SARA AI MAIMALAI)
+101	0x0E45	ๅ (THAI CHARACTER LAKKHANGYAO)
+102	0x0E46	ๆ (THAI CHARACTER MAIYAMOK)
+103	0x0E47	็ (THAI CHARACTER MAITAIKHU)
+104	0x0E48	่ (THAI CHARACTER MAI EK)
+105	0x0E49	้ (THAI CHARACTER MAI THO)
+106	0x0E4A	๊ (THAI CHARACTER MAI TRI)
+107	0x0E4B	๋ (THAI CHARACTER MAI CHATTAWA)
+108	0x0E4C	์ (THAI CHARACTER THANTHAKHAT)
+109	0x0E4D	ํ (THAI CHARACTER NIKHAHIT)
+110	0x0E4E	๎ (THAI CHARACTER YAMAKKAN)
+111	0x0E4F	๏ (THAI CHARACTER FONGMAN)
+112	0x0E50	๐ (THAI DIGIT ZERO)
+113	0x0E51	๑ (THAI DIGIT ONE)
+114	0x0E52	๒ (THAI DIGIT TWO)
+115	0x0E53	๓ (THAI DIGIT THREE)
+116	0x0E54	๔ (THAI DIGIT FOUR)
+117	0x0E55	๕ (THAI DIGIT FIVE)
+118	0x0E56	๖ (THAI DIGIT SIX)
+119	0x0E57	๗ (THAI DIGIT SEVEN)
+120	0x0E58	๘ (THAI DIGIT EIGHT)
+121	0x0E59	๙ (THAI DIGIT NINE)
+122	0x0E5A	๚ (THAI CHARACTER ANGKHANKHU)
+123	0x0E5B	๛ (THAI CHARACTER KHOMUT)
diff --git a/test/js/node/test/fixtures/encoding/single-byte/index-x-mac-cyrillic.txt b/test/js/node/test/fixtures/encoding/single-byte/index-x-mac-cyrillic.txt
new file mode 100644
index 000000000000..333b361dfce6
--- /dev/null
+++ b/test/js/node/test/fixtures/encoding/single-byte/index-x-mac-cyrillic.txt
@@ -0,0 +1,134 @@
+# For details on index index-x-mac-cyrillic.txt see the Encoding Standard
+# https://encoding.spec.whatwg.org/
+#
+# Identifier: 73e8e7642c6fa9de29d42819b47fba55b58666fb1e339faeb4a89a0bd7c24d43
+# Date: 2024-09-18
+
+  0	0x0410	А (CYRILLIC CAPITAL LETTER A)
+  1	0x0411	Б (CYRILLIC CAPITAL LETTER BE)
+  2	0x0412	В (CYRILLIC CAPITAL LETTER VE)
+  3	0x0413	Г (CYRILLIC CAPITAL LETTER GHE)
+  4	0x0414	Д (CYRILLIC CAPITAL LETTER DE)
+  5	0x0415	Е (CYRILLIC CAPITAL LETTER IE)
+  6	0x0416	Ж (CYRILLIC CAPITAL LETTER ZHE)
+  7	0x0417	З (CYRILLIC CAPITAL LETTER ZE)
+  8	0x0418	И (CYRILLIC CAPITAL LETTER I)
+  9	0x0419	Й (CYRILLIC CAPITAL LETTER SHORT I)
+ 10	0x041A	К (CYRILLIC CAPITAL LETTER KA)
+ 11	0x041B	Л (CYRILLIC CAPITAL LETTER EL)
+ 12	0x041C	М (CYRILLIC CAPITAL LETTER EM)
+ 13	0x041D	Н (CYRILLIC CAPITAL LETTER EN)
+ 14	0x041E	О (CYRILLIC CAPITAL LETTER O)
+ 15	0x041F	П (CYRILLIC CAPITAL LETTER PE)
+ 16	0x0420	Р (CYRILLIC CAPITAL LETTER ER)
+ 17	0x0421	С (CYRILLIC CAPITAL LETTER ES)
+ 18	0x0422	Т (CYRILLIC CAPITAL LETTER TE)
+ 19	0x0423	У (CYRILLIC CAPITAL LETTER U)
+ 20	0x0424	Ф (CYRILLIC CAPITAL LETTER EF)
+ 21	0x0425	Х (CYRILLIC CAPITAL LETTER HA)
+ 22	0x0426	Ц (CYRILLIC CAPITAL LETTER TSE)
+ 23	0x0427	Ч (CYRILLIC CAPITAL LETTER CHE)
+ 24	0x0428	Ш (CYRILLIC CAPITAL LETTER SHA)
+ 25	0x0429	Щ (CYRILLIC CAPITAL LETTER SHCHA)
+ 26	0x042A	Ъ (CYRILLIC CAPITAL LETTER HARD SIGN)
+ 27	0x042B	Ы (CYRILLIC CAPITAL LETTER YERU)
+ 28	0x042C	Ь (CYRILLIC CAPITAL LETTER SOFT SIGN)
+ 29	0x042D	Э (CYRILLIC CAPITAL LETTER E)
+ 30	0x042E	Ю (CYRILLIC CAPITAL LETTER YU)
+ 31	0x042F	Я (CYRILLIC CAPITAL LETTER YA)
+ 32	0x2020	† (DAGGER)
+ 33	0x00B0	° (DEGREE SIGN)
+ 34	0x0490	Ґ (CYRILLIC CAPITAL LETTER GHE WITH UPTURN)
+ 35	0x00A3	£ (POUND SIGN)
+ 36	0x00A7	§ (SECTION SIGN)
+ 37	0x2022	• (BULLET)
+ 38	0x00B6	¶ (PILCROW SIGN)
+ 39	0x0406	І (CYRILLIC CAPITAL LETTER BYELORUSSIAN-UKRAINIAN I)
+ 40	0x00AE	® (REGISTERED SIGN)
+ 41	0x00A9	© (COPYRIGHT SIGN)
+ 42	0x2122	™ (TRADE MARK SIGN)
+ 43	0x0402	Ђ (CYRILLIC CAPITAL LETTER DJE)
+ 44	0x0452	ђ (CYRILLIC SMALL LETTER DJE)
+ 45	0x2260	≠ (NOT EQUAL TO)
+ 46	0x0403	Ѓ (CYRILLIC CAPITAL LETTER GJE)
+ 47	0x0453	ѓ (CYRILLIC SMALL LETTER GJE)
+ 48	0x221E	∞ (INFINITY)
+ 49	0x00B1	± (PLUS-MINUS SIGN)
+ 50	0x2264	≤ (LESS-THAN OR EQUAL TO)
+ 51	0x2265	≥ (GREATER-THAN OR EQUAL TO)
+ 52	0x0456	і (CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I)
+ 53	0x00B5	µ (MICRO SIGN)
+ 54	0x0491	ґ (CYRILLIC SMALL LETTER GHE WITH UPTURN)
+ 55	0x0408	Ј (CYRILLIC CAPITAL LETTER JE)
+ 56	0x0404	Є (CYRILLIC CAPITAL LETTER UKRAINIAN IE)
+ 57	0x0454	є (CYRILLIC SMALL LETTER UKRAINIAN IE)
+ 58	0x0407	Ї (CYRILLIC CAPITAL LETTER YI)
+ 59	0x0457	ї (CYRILLIC SMALL LETTER YI)
+ 60	0x0409	Љ (CYRILLIC CAPITAL LETTER LJE)
+ 61	0x0459	љ (CYRILLIC SMALL LETTER LJE)
+ 62	0x040A	Њ (CYRILLIC CAPITAL LETTER NJE)
+ 63	0x045A	њ (CYRILLIC SMALL LETTER NJE)
+ 64	0x0458	ј (CYRILLIC SMALL LETTER JE)
+ 65	0x0405	Ѕ (CYRILLIC CAPITAL LETTER DZE)
+ 66	0x00AC	¬ (NOT SIGN)
+ 67	0x221A	√ (SQUARE ROOT)
+ 68	0x0192	ƒ (LATIN SMALL LETTER F WITH HOOK)
+ 69	0x2248	≈ (ALMOST EQUAL TO)
+ 70	0x2206	∆ (INCREMENT)
+ 71	0x00AB	« (LEFT-POINTING DOUBLE ANGLE QUOTATION MARK)
+ 72	0x00BB	» (RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK)
+ 73	0x2026	… (HORIZONTAL ELLIPSIS)
+ 74	0x00A0	  (NO-BREAK SPACE)
+ 75	0x040B	Ћ (CYRILLIC CAPITAL LETTER TSHE)
+ 76	0x045B	ћ (CYRILLIC SMALL LETTER TSHE)
+ 77	0x040C	Ќ (CYRILLIC CAPITAL LETTER KJE)
+ 78	0x045C	ќ (CYRILLIC SMALL LETTER KJE)
+ 79	0x0455	ѕ (CYRILLIC SMALL LETTER DZE)
+ 80	0x2013	– (EN DASH)
+ 81	0x2014	— (EM DASH)
+ 82	0x201C	“ (LEFT DOUBLE QUOTATION MARK)
+ 83	0x201D	” (RIGHT DOUBLE QUOTATION MARK)
+ 84	0x2018	‘ (LEFT SINGLE QUOTATION MARK)
+ 85	0x2019	’ (RIGHT SINGLE QUOTATION MARK)
+ 86	0x00F7	÷ (DIVISION SIGN)
+ 87	0x201E	„ (DOUBLE LOW-9 QUOTATION MARK)
+ 88	0x040E	Ў (CYRILLIC CAPITAL LETTER SHORT U)
+ 89	0x045E	ў (CYRILLIC SMALL LETTER SHORT U)
+ 90	0x040F	Џ (CYRILLIC CAPITAL LETTER DZHE)
+ 91	0x045F	џ (CYRILLIC SMALL LETTER DZHE)
+ 92	0x2116	№ (NUMERO SIGN)
+ 93	0x0401	Ё (CYRILLIC CAPITAL LETTER IO)
+ 94	0x0451	ё (CYRILLIC SMALL LETTER IO)
+ 95	0x044F	я (CYRILLIC SMALL LETTER YA)
+ 96	0x0430	а (CYRILLIC SMALL LETTER A)
+ 97	0x0431	б (CYRILLIC SMALL LETTER BE)
+ 98	0x0432	в (CYRILLIC SMALL LETTER VE)
+ 99	0x0433	г (CYRILLIC SMALL LETTER GHE)
+100	0x0434	д (CYRILLIC SMALL LETTER DE)
+101	0x0435	е (CYRILLIC SMALL LETTER IE)
+102	0x0436	ж (CYRILLIC SMALL LETTER ZHE)
+103	0x0437	з (CYRILLIC SMALL LETTER ZE)
+104	0x0438	и (CYRILLIC SMALL LETTER I)
+105	0x0439	й (CYRILLIC SMALL LETTER SHORT I)
+106	0x043A	к (CYRILLIC SMALL LETTER KA)
+107	0x043B	л (CYRILLIC SMALL LETTER EL)
+108	0x043C	м (CYRILLIC SMALL LETTER EM)
+109	0x043D	н (CYRILLIC SMALL LETTER EN)
+110	0x043E	о (CYRILLIC SMALL LETTER O)
+111	0x043F	п (CYRILLIC SMALL LETTER PE)
+112	0x0440	р (CYRILLIC SMALL LETTER ER)
+113	0x0441	с (CYRILLIC SMALL LETTER ES)
+114	0x0442	т (CYRILLIC SMALL LETTER TE)
+115	0x0443	у (CYRILLIC SMALL LETTER U)
+116	0x0444	ф (CYRILLIC SMALL LETTER EF)
+117	0x0445	х (CYRILLIC SMALL LETTER HA)
+118	0x0446	ц (CYRILLIC SMALL LETTER TSE)
+119	0x0447	ч (CYRILLIC SMALL LETTER CHE)
+120	0x0448	ш (CYRILLIC SMALL LETTER SHA)
+121	0x0449	щ (CYRILLIC SMALL LETTER SHCHA)
+122	0x044A	ъ (CYRILLIC SMALL LETTER HARD SIGN)
+123	0x044B	ы (CYRILLIC SMALL LETTER YERU)
+124	0x044C	ь (CYRILLIC SMALL LETTER SOFT SIGN)
+125	0x044D	э (CYRILLIC SMALL LETTER E)
+126	0x044E	ю (CYRILLIC SMALL LETTER YU)
+127	0x20AC	€ (EURO SIGN)
diff --git a/test/js/node/test/fixtures/icu-punycode-toascii.json b/test/js/node/test/fixtures/icu-punycode-toascii.json
new file mode 100644
index 000000000000..814f06e79486
--- /dev/null
+++ b/test/js/node/test/fixtures/icu-punycode-toascii.json
@@ -0,0 +1,149 @@
+[
+  "This resource is focused on highlighting issues with UTS #46 ToASCII",
+  {
+    "comment": "Label with hyphens in 3rd and 4th position",
+    "input": "aa--",
+    "output": "aa--"
+  },
+  {
+    "input": "a†--",
+    "output": "xn--a---kp0a"
+  },
+  {
+    "input": "ab--c",
+    "output": "ab--c"
+  },
+  {
+    "comment": "Label with leading hyphen",
+    "input": "-x",
+    "output": "-x"
+  },
+  {
+    "input": "-†",
+    "output": "xn----xhn"
+  },
+  {
+    "input": "-x.xn--nxa",
+    "output": "-x.xn--nxa"
+  },
+  {
+    "input": "-x.β",
+    "output": "-x.xn--nxa"
+  },
+  {
+    "comment": "Label with trailing hyphen",
+    "input": "x-.xn--nxa",
+    "output": "x-.xn--nxa"
+  },
+  {
+    "input": "x-.β",
+    "output": "x-.xn--nxa"
+  },
+  {
+    "comment": "Empty labels",
+    "input": "x..xn--nxa",
+    "output": "x..xn--nxa"
+  },
+  {
+    "input": "x..β",
+    "output": "x..xn--nxa"
+  },
+  {
+    "comment": "Invalid Punycode",
+    "input": "xn--a",
+    "output": null
+  },
+  {
+    "input": "xn--a.xn--nxa",
+    "output": null
+  },
+  {
+    "input": "xn--a.β",
+    "output": null
+  },
+  {
+    "comment": "Valid Punycode",
+    "input": "xn--nxa.xn--nxa",
+    "output": "xn--nxa.xn--nxa"
+  },
+  {
+    "comment": "Mixed",
+    "input": "xn--nxa.β",
+    "output": "xn--nxa.xn--nxa"
+  },
+  {
+    "input": "ab--c.xn--nxa",
+    "output": "ab--c.xn--nxa"
+  },
+  {
+    "input": "ab--c.β",
+    "output": "ab--c.xn--nxa"
+  },
+  {
+    "comment": "CheckJoiners is true",
+    "input": "\u200D.example",
+    "output": null
+  },
+  {
+    "input": "xn--1ug.example",
+    "output": null
+  },
+  {
+    "comment": "CheckBidi is true",
+    "input": "يa",
+    "output": null
+  },
+  {
+    "input": "xn--a-yoc",
+    "output": null
+  },
+  {
+    "comment": "processing_option is Nontransitional_Processing",
+    "input": "ශ්‍රී",
+    "output": "xn--10cl1a0b660p"
+  },
+  {
+    "input": "نامه‌ای",
+    "output": "xn--mgba3gch31f060k"
+  },
+  {
+    "comment": "U+FFFD",
+    "input": "\uFFFD.com",
+    "output": null
+  },
+  {
+    "comment": "U+FFFD character encoded in Punycode",
+    "input": "xn--zn7c.com",
+    "output": null
+  },
+  {
+    "comment": "Label longer than 63 code points",
+    "input": "x01234567890123456789012345678901234567890123456789012345678901x",
+    "output": "x01234567890123456789012345678901234567890123456789012345678901x"
+  },
+  {
+    "input": "x01234567890123456789012345678901234567890123456789012345678901†",
+    "output": "xn--x01234567890123456789012345678901234567890123456789012345678901-6963b"
+  },
+  {
+    "input": "x01234567890123456789012345678901234567890123456789012345678901x.xn--nxa",
+    "output": "x01234567890123456789012345678901234567890123456789012345678901x.xn--nxa"
+  },
+  {
+    "input": "x01234567890123456789012345678901234567890123456789012345678901x.β",
+    "output": "x01234567890123456789012345678901234567890123456789012345678901x.xn--nxa"
+  },
+  {
+    "comment": "Domain excluding TLD longer than 253 code points",
+    "input": "01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.0123456789012345678901234567890123456789012345678.x",
+    "output": "01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.0123456789012345678901234567890123456789012345678.x"
+  },
+  {
+    "input": "01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.0123456789012345678901234567890123456789012345678.xn--nxa",
+    "output": "01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.0123456789012345678901234567890123456789012345678.xn--nxa"
+  },
+  {
+    "input": "01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.0123456789012345678901234567890123456789012345678.β",
+    "output": "01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.0123456789012345678901234567890123456789012345678.xn--nxa"
+  }
+]
diff --git a/test/js/node/test/fixtures/kill-signal-for-watch.js b/test/js/node/test/fixtures/kill-signal-for-watch.js
new file mode 100644
index 000000000000..fe1e91fb5c39
--- /dev/null
+++ b/test/js/node/test/fixtures/kill-signal-for-watch.js
@@ -0,0 +1,13 @@
+process.on('SIGTERM', () => {
+  console.log(`__SIGTERM received__ ${process.pid}`);
+  process.exit();
+});
+process.on('SIGINT', () => {
+  console.log(`__SIGINT received__ ${process.pid}`);
+  process.exit();
+});
+process.send(`script ready ${process.pid}`);
+const timeout = 100_000;
+setTimeout(() => {
+  process._rawDebug(`[CHILD] Timeout ${timeout} fired`);
+}, timeout);
diff --git a/test/js/node/test/fixtures/require-resolve.js b/test/js/node/test/fixtures/require-resolve.js
index ec9152c7245d..4fc241918860 100644
--- a/test/js/node/test/fixtures/require-resolve.js
+++ b/test/js/node/test/fixtures/require-resolve.js
@@ -16,7 +16,10 @@ if (require.resolve.paths) {
   // Verify that existing paths are removed.
   assert.throws(() => {
     require.resolve('bar', { paths: [] })
-  }, /Cannot find package 'bar'/);
+    // Upstream anchors /^Error: .../ — Bun's error class stringifies as
+    // "ResolveMessage:", so only the anchor is dropped here (message and
+    // MODULE_NOT_FOUND code match node v26.3.0).
+  }, /Cannot find module 'bar'/);
 }
 
 // Verify that resolution path can be overwritten.
@@ -24,14 +27,14 @@ if (require.resolve.paths) {
   // three.js cannot be loaded from this file by default.
   assert.throws(() => {
     require.resolve('three')
-  }, /Cannot find package 'three'/);
+  }, /Cannot find module 'three'/);
 
   // If the nested-index directory is provided as a resolve path, 'three'
   // cannot be found because nested-index is used as a starting point and not
   // a searched directory.
   assert.throws(() => {
     require.resolve('three', { paths: [nestedIndex] })
-  }, /Cannot find package 'three'/);
+  }, /Cannot find module 'three'/);
 
   // Resolution from nested index directory also checks node_modules.
   assert.strictEqual(
diff --git a/test/js/node/test/fixtures/snapshot/typescript.js b/test/js/node/test/fixtures/snapshot/typescript.js
new file mode 100644
index 000000000000..034d1637906e
--- /dev/null
+++ b/test/js/node/test/fixtures/snapshot/typescript.js
@@ -0,0 +1,50004 @@
+// Compile-cache workload fixture (upstream uses the TypeScript bundle).
+"use strict";
+let acc = 0;
+acc += Math.sin(0) + Math.cos(1) * 0;
+acc += Math.sin(1) + Math.cos(2) * 1;
+acc += Math.sin(2) + Math.cos(3) * 2;
+acc += Math.sin(3) + Math.cos(4) * 3;
+acc += Math.sin(4) + Math.cos(5) * 4;
+acc += Math.sin(5) + Math.cos(6) * 5;
+acc += Math.sin(6) + Math.cos(7) * 6;
+acc += Math.sin(7) + Math.cos(8) * 7;
+acc += Math.sin(8) + Math.cos(9) * 8;
+acc += Math.sin(9) + Math.cos(10) * 9;
+acc += Math.sin(10) + Math.cos(11) * 10;
+acc += Math.sin(11) + Math.cos(12) * 11;
+acc += Math.sin(12) + Math.cos(13) * 12;
+acc += Math.sin(13) + Math.cos(14) * 13;
+acc += Math.sin(14) + Math.cos(15) * 14;
+acc += Math.sin(15) + Math.cos(16) * 15;
+acc += Math.sin(16) + Math.cos(17) * 16;
+acc += Math.sin(17) + Math.cos(18) * 17;
+acc += Math.sin(18) + Math.cos(19) * 18;
+acc += Math.sin(19) + Math.cos(20) * 19;
+acc += Math.sin(20) + Math.cos(21) * 20;
+acc += Math.sin(21) + Math.cos(22) * 21;
+acc += Math.sin(22) + Math.cos(23) * 22;
+acc += Math.sin(23) + Math.cos(24) * 23;
+acc += Math.sin(24) + Math.cos(25) * 24;
+acc += Math.sin(25) + Math.cos(26) * 25;
+acc += Math.sin(26) + Math.cos(27) * 26;
+acc += Math.sin(27) + Math.cos(28) * 27;
+acc += Math.sin(28) + Math.cos(29) * 28;
+acc += Math.sin(29) + Math.cos(30) * 29;
+acc += Math.sin(30) + Math.cos(31) * 30;
+acc += Math.sin(31) + Math.cos(32) * 31;
+acc += Math.sin(32) + Math.cos(33) * 32;
+acc += Math.sin(33) + Math.cos(34) * 33;
+acc += Math.sin(34) + Math.cos(35) * 34;
+acc += Math.sin(35) + Math.cos(36) * 35;
+acc += Math.sin(36) + Math.cos(37) * 36;
+acc += Math.sin(37) + Math.cos(38) * 37;
+acc += Math.sin(38) + Math.cos(39) * 38;
+acc += Math.sin(39) + Math.cos(40) * 39;
+acc += Math.sin(40) + Math.cos(41) * 40;
+acc += Math.sin(41) + Math.cos(42) * 41;
+acc += Math.sin(42) + Math.cos(43) * 42;
+acc += Math.sin(43) + Math.cos(44) * 43;
+acc += Math.sin(44) + Math.cos(45) * 44;
+acc += Math.sin(45) + Math.cos(46) * 45;
+acc += Math.sin(46) + Math.cos(47) * 46;
+acc += Math.sin(47) + Math.cos(48) * 47;
+acc += Math.sin(48) + Math.cos(49) * 48;
+acc += Math.sin(49) + Math.cos(50) * 49;
+acc += Math.sin(50) + Math.cos(51) * 50;
+acc += Math.sin(51) + Math.cos(52) * 51;
+acc += Math.sin(52) + Math.cos(53) * 52;
+acc += Math.sin(53) + Math.cos(54) * 53;
+acc += Math.sin(54) + Math.cos(55) * 54;
+acc += Math.sin(55) + Math.cos(56) * 55;
+acc += Math.sin(56) + Math.cos(57) * 56;
+acc += Math.sin(57) + Math.cos(58) * 57;
+acc += Math.sin(58) + Math.cos(59) * 58;
+acc += Math.sin(59) + Math.cos(60) * 59;
+acc += Math.sin(60) + Math.cos(61) * 60;
+acc += Math.sin(61) + Math.cos(62) * 61;
+acc += Math.sin(62) + Math.cos(63) * 62;
+acc += Math.sin(63) + Math.cos(64) * 63;
+acc += Math.sin(64) + Math.cos(65) * 64;
+acc += Math.sin(65) + Math.cos(66) * 65;
+acc += Math.sin(66) + Math.cos(67) * 66;
+acc += Math.sin(67) + Math.cos(68) * 67;
+acc += Math.sin(68) + Math.cos(69) * 68;
+acc += Math.sin(69) + Math.cos(70) * 69;
+acc += Math.sin(70) + Math.cos(71) * 70;
+acc += Math.sin(71) + Math.cos(72) * 71;
+acc += Math.sin(72) + Math.cos(73) * 72;
+acc += Math.sin(73) + Math.cos(74) * 73;
+acc += Math.sin(74) + Math.cos(75) * 74;
+acc += Math.sin(75) + Math.cos(76) * 75;
+acc += Math.sin(76) + Math.cos(77) * 76;
+acc += Math.sin(77) + Math.cos(78) * 77;
+acc += Math.sin(78) + Math.cos(79) * 78;
+acc += Math.sin(79) + Math.cos(80) * 79;
+acc += Math.sin(80) + Math.cos(81) * 80;
+acc += Math.sin(81) + Math.cos(82) * 81;
+acc += Math.sin(82) + Math.cos(83) * 82;
+acc += Math.sin(83) + Math.cos(84) * 83;
+acc += Math.sin(84) + Math.cos(85) * 84;
+acc += Math.sin(85) + Math.cos(86) * 85;
+acc += Math.sin(86) + Math.cos(87) * 86;
+acc += Math.sin(87) + Math.cos(88) * 87;
+acc += Math.sin(88) + Math.cos(89) * 88;
+acc += Math.sin(89) + Math.cos(90) * 89;
+acc += Math.sin(90) + Math.cos(91) * 90;
+acc += Math.sin(91) + Math.cos(92) * 91;
+acc += Math.sin(92) + Math.cos(93) * 92;
+acc += Math.sin(93) + Math.cos(94) * 93;
+acc += Math.sin(94) + Math.cos(95) * 94;
+acc += Math.sin(95) + Math.cos(96) * 95;
+acc += Math.sin(96) + Math.cos(97) * 96;
+acc += Math.sin(97) + Math.cos(98) * 0;
+acc += Math.sin(98) + Math.cos(99) * 1;
+acc += Math.sin(99) + Math.cos(100) * 2;
+acc += Math.sin(100) + Math.cos(101) * 3;
+acc += Math.sin(101) + Math.cos(102) * 4;
+acc += Math.sin(102) + Math.cos(103) * 5;
+acc += Math.sin(103) + Math.cos(104) * 6;
+acc += Math.sin(104) + Math.cos(105) * 7;
+acc += Math.sin(105) + Math.cos(106) * 8;
+acc += Math.sin(106) + Math.cos(107) * 9;
+acc += Math.sin(107) + Math.cos(108) * 10;
+acc += Math.sin(108) + Math.cos(109) * 11;
+acc += Math.sin(109) + Math.cos(110) * 12;
+acc += Math.sin(110) + Math.cos(111) * 13;
+acc += Math.sin(111) + Math.cos(112) * 14;
+acc += Math.sin(112) + Math.cos(113) * 15;
+acc += Math.sin(113) + Math.cos(114) * 16;
+acc += Math.sin(114) + Math.cos(115) * 17;
+acc += Math.sin(115) + Math.cos(116) * 18;
+acc += Math.sin(116) + Math.cos(117) * 19;
+acc += Math.sin(117) + Math.cos(118) * 20;
+acc += Math.sin(118) + Math.cos(119) * 21;
+acc += Math.sin(119) + Math.cos(120) * 22;
+acc += Math.sin(120) + Math.cos(121) * 23;
+acc += Math.sin(121) + Math.cos(122) * 24;
+acc += Math.sin(122) + Math.cos(123) * 25;
+acc += Math.sin(123) + Math.cos(124) * 26;
+acc += Math.sin(124) + Math.cos(125) * 27;
+acc += Math.sin(125) + Math.cos(126) * 28;
+acc += Math.sin(126) + Math.cos(127) * 29;
+acc += Math.sin(127) + Math.cos(128) * 30;
+acc += Math.sin(128) + Math.cos(129) * 31;
+acc += Math.sin(129) + Math.cos(130) * 32;
+acc += Math.sin(130) + Math.cos(131) * 33;
+acc += Math.sin(131) + Math.cos(132) * 34;
+acc += Math.sin(132) + Math.cos(133) * 35;
+acc += Math.sin(133) + Math.cos(134) * 36;
+acc += Math.sin(134) + Math.cos(135) * 37;
+acc += Math.sin(135) + Math.cos(136) * 38;
+acc += Math.sin(136) + Math.cos(137) * 39;
+acc += Math.sin(137) + Math.cos(138) * 40;
+acc += Math.sin(138) + Math.cos(139) * 41;
+acc += Math.sin(139) + Math.cos(140) * 42;
+acc += Math.sin(140) + Math.cos(141) * 43;
+acc += Math.sin(141) + Math.cos(142) * 44;
+acc += Math.sin(142) + Math.cos(143) * 45;
+acc += Math.sin(143) + Math.cos(144) * 46;
+acc += Math.sin(144) + Math.cos(145) * 47;
+acc += Math.sin(145) + Math.cos(146) * 48;
+acc += Math.sin(146) + Math.cos(147) * 49;
+acc += Math.sin(147) + Math.cos(148) * 50;
+acc += Math.sin(148) + Math.cos(149) * 51;
+acc += Math.sin(149) + Math.cos(150) * 52;
+acc += Math.sin(150) + Math.cos(151) * 53;
+acc += Math.sin(151) + Math.cos(152) * 54;
+acc += Math.sin(152) + Math.cos(153) * 55;
+acc += Math.sin(153) + Math.cos(154) * 56;
+acc += Math.sin(154) + Math.cos(155) * 57;
+acc += Math.sin(155) + Math.cos(156) * 58;
+acc += Math.sin(156) + Math.cos(157) * 59;
+acc += Math.sin(157) + Math.cos(158) * 60;
+acc += Math.sin(158) + Math.cos(159) * 61;
+acc += Math.sin(159) + Math.cos(160) * 62;
+acc += Math.sin(160) + Math.cos(161) * 63;
+acc += Math.sin(161) + Math.cos(162) * 64;
+acc += Math.sin(162) + Math.cos(163) * 65;
+acc += Math.sin(163) + Math.cos(164) * 66;
+acc += Math.sin(164) + Math.cos(165) * 67;
+acc += Math.sin(165) + Math.cos(166) * 68;
+acc += Math.sin(166) + Math.cos(167) * 69;
+acc += Math.sin(167) + Math.cos(168) * 70;
+acc += Math.sin(168) + Math.cos(169) * 71;
+acc += Math.sin(169) + Math.cos(170) * 72;
+acc += Math.sin(170) + Math.cos(171) * 73;
+acc += Math.sin(171) + Math.cos(172) * 74;
+acc += Math.sin(172) + Math.cos(173) * 75;
+acc += Math.sin(173) + Math.cos(174) * 76;
+acc += Math.sin(174) + Math.cos(175) * 77;
+acc += Math.sin(175) + Math.cos(176) * 78;
+acc += Math.sin(176) + Math.cos(177) * 79;
+acc += Math.sin(177) + Math.cos(178) * 80;
+acc += Math.sin(178) + Math.cos(179) * 81;
+acc += Math.sin(179) + Math.cos(180) * 82;
+acc += Math.sin(180) + Math.cos(181) * 83;
+acc += Math.sin(181) + Math.cos(182) * 84;
+acc += Math.sin(182) + Math.cos(183) * 85;
+acc += Math.sin(183) + Math.cos(184) * 86;
+acc += Math.sin(184) + Math.cos(185) * 87;
+acc += Math.sin(185) + Math.cos(186) * 88;
+acc += Math.sin(186) + Math.cos(187) * 89;
+acc += Math.sin(187) + Math.cos(188) * 90;
+acc += Math.sin(188) + Math.cos(189) * 91;
+acc += Math.sin(189) + Math.cos(190) * 92;
+acc += Math.sin(190) + Math.cos(191) * 93;
+acc += Math.sin(191) + Math.cos(192) * 94;
+acc += Math.sin(192) + Math.cos(193) * 95;
+acc += Math.sin(193) + Math.cos(194) * 96;
+acc += Math.sin(194) + Math.cos(195) * 0;
+acc += Math.sin(195) + Math.cos(196) * 1;
+acc += Math.sin(196) + Math.cos(197) * 2;
+acc += Math.sin(197) + Math.cos(198) * 3;
+acc += Math.sin(198) + Math.cos(199) * 4;
+acc += Math.sin(199) + Math.cos(200) * 5;
+acc += Math.sin(200) + Math.cos(201) * 6;
+acc += Math.sin(201) + Math.cos(202) * 7;
+acc += Math.sin(202) + Math.cos(203) * 8;
+acc += Math.sin(203) + Math.cos(204) * 9;
+acc += Math.sin(204) + Math.cos(205) * 10;
+acc += Math.sin(205) + Math.cos(206) * 11;
+acc += Math.sin(206) + Math.cos(207) * 12;
+acc += Math.sin(207) + Math.cos(208) * 13;
+acc += Math.sin(208) + Math.cos(209) * 14;
+acc += Math.sin(209) + Math.cos(210) * 15;
+acc += Math.sin(210) + Math.cos(211) * 16;
+acc += Math.sin(211) + Math.cos(212) * 17;
+acc += Math.sin(212) + Math.cos(213) * 18;
+acc += Math.sin(213) + Math.cos(214) * 19;
+acc += Math.sin(214) + Math.cos(215) * 20;
+acc += Math.sin(215) + Math.cos(216) * 21;
+acc += Math.sin(216) + Math.cos(217) * 22;
+acc += Math.sin(217) + Math.cos(218) * 23;
+acc += Math.sin(218) + Math.cos(219) * 24;
+acc += Math.sin(219) + Math.cos(220) * 25;
+acc += Math.sin(220) + Math.cos(221) * 26;
+acc += Math.sin(221) + Math.cos(222) * 27;
+acc += Math.sin(222) + Math.cos(223) * 28;
+acc += Math.sin(223) + Math.cos(224) * 29;
+acc += Math.sin(224) + Math.cos(225) * 30;
+acc += Math.sin(225) + Math.cos(226) * 31;
+acc += Math.sin(226) + Math.cos(227) * 32;
+acc += Math.sin(227) + Math.cos(228) * 33;
+acc += Math.sin(228) + Math.cos(229) * 34;
+acc += Math.sin(229) + Math.cos(230) * 35;
+acc += Math.sin(230) + Math.cos(231) * 36;
+acc += Math.sin(231) + Math.cos(232) * 37;
+acc += Math.sin(232) + Math.cos(233) * 38;
+acc += Math.sin(233) + Math.cos(234) * 39;
+acc += Math.sin(234) + Math.cos(235) * 40;
+acc += Math.sin(235) + Math.cos(236) * 41;
+acc += Math.sin(236) + Math.cos(237) * 42;
+acc += Math.sin(237) + Math.cos(238) * 43;
+acc += Math.sin(238) + Math.cos(239) * 44;
+acc += Math.sin(239) + Math.cos(240) * 45;
+acc += Math.sin(240) + Math.cos(241) * 46;
+acc += Math.sin(241) + Math.cos(242) * 47;
+acc += Math.sin(242) + Math.cos(243) * 48;
+acc += Math.sin(243) + Math.cos(244) * 49;
+acc += Math.sin(244) + Math.cos(245) * 50;
+acc += Math.sin(245) + Math.cos(246) * 51;
+acc += Math.sin(246) + Math.cos(247) * 52;
+acc += Math.sin(247) + Math.cos(248) * 53;
+acc += Math.sin(248) + Math.cos(249) * 54;
+acc += Math.sin(249) + Math.cos(250) * 55;
+acc += Math.sin(250) + Math.cos(251) * 56;
+acc += Math.sin(251) + Math.cos(252) * 57;
+acc += Math.sin(252) + Math.cos(253) * 58;
+acc += Math.sin(253) + Math.cos(254) * 59;
+acc += Math.sin(254) + Math.cos(255) * 60;
+acc += Math.sin(255) + Math.cos(256) * 61;
+acc += Math.sin(256) + Math.cos(257) * 62;
+acc += Math.sin(257) + Math.cos(258) * 63;
+acc += Math.sin(258) + Math.cos(259) * 64;
+acc += Math.sin(259) + Math.cos(260) * 65;
+acc += Math.sin(260) + Math.cos(261) * 66;
+acc += Math.sin(261) + Math.cos(262) * 67;
+acc += Math.sin(262) + Math.cos(263) * 68;
+acc += Math.sin(263) + Math.cos(264) * 69;
+acc += Math.sin(264) + Math.cos(265) * 70;
+acc += Math.sin(265) + Math.cos(266) * 71;
+acc += Math.sin(266) + Math.cos(267) * 72;
+acc += Math.sin(267) + Math.cos(268) * 73;
+acc += Math.sin(268) + Math.cos(269) * 74;
+acc += Math.sin(269) + Math.cos(270) * 75;
+acc += Math.sin(270) + Math.cos(271) * 76;
+acc += Math.sin(271) + Math.cos(272) * 77;
+acc += Math.sin(272) + Math.cos(273) * 78;
+acc += Math.sin(273) + Math.cos(274) * 79;
+acc += Math.sin(274) + Math.cos(275) * 80;
+acc += Math.sin(275) + Math.cos(276) * 81;
+acc += Math.sin(276) + Math.cos(277) * 82;
+acc += Math.sin(277) + Math.cos(278) * 83;
+acc += Math.sin(278) + Math.cos(279) * 84;
+acc += Math.sin(279) + Math.cos(280) * 85;
+acc += Math.sin(280) + Math.cos(281) * 86;
+acc += Math.sin(281) + Math.cos(282) * 87;
+acc += Math.sin(282) + Math.cos(283) * 88;
+acc += Math.sin(283) + Math.cos(284) * 89;
+acc += Math.sin(284) + Math.cos(285) * 90;
+acc += Math.sin(285) + Math.cos(286) * 91;
+acc += Math.sin(286) + Math.cos(287) * 92;
+acc += Math.sin(287) + Math.cos(288) * 93;
+acc += Math.sin(288) + Math.cos(289) * 94;
+acc += Math.sin(289) + Math.cos(290) * 95;
+acc += Math.sin(290) + Math.cos(291) * 96;
+acc += Math.sin(291) + Math.cos(292) * 0;
+acc += Math.sin(292) + Math.cos(293) * 1;
+acc += Math.sin(293) + Math.cos(294) * 2;
+acc += Math.sin(294) + Math.cos(295) * 3;
+acc += Math.sin(295) + Math.cos(296) * 4;
+acc += Math.sin(296) + Math.cos(297) * 5;
+acc += Math.sin(297) + Math.cos(298) * 6;
+acc += Math.sin(298) + Math.cos(299) * 7;
+acc += Math.sin(299) + Math.cos(300) * 8;
+acc += Math.sin(300) + Math.cos(301) * 9;
+acc += Math.sin(301) + Math.cos(302) * 10;
+acc += Math.sin(302) + Math.cos(303) * 11;
+acc += Math.sin(303) + Math.cos(304) * 12;
+acc += Math.sin(304) + Math.cos(305) * 13;
+acc += Math.sin(305) + Math.cos(306) * 14;
+acc += Math.sin(306) + Math.cos(307) * 15;
+acc += Math.sin(307) + Math.cos(308) * 16;
+acc += Math.sin(308) + Math.cos(309) * 17;
+acc += Math.sin(309) + Math.cos(310) * 18;
+acc += Math.sin(310) + Math.cos(311) * 19;
+acc += Math.sin(311) + Math.cos(312) * 20;
+acc += Math.sin(312) + Math.cos(313) * 21;
+acc += Math.sin(313) + Math.cos(314) * 22;
+acc += Math.sin(314) + Math.cos(315) * 23;
+acc += Math.sin(315) + Math.cos(316) * 24;
+acc += Math.sin(316) + Math.cos(317) * 25;
+acc += Math.sin(317) + Math.cos(318) * 26;
+acc += Math.sin(318) + Math.cos(319) * 27;
+acc += Math.sin(319) + Math.cos(320) * 28;
+acc += Math.sin(320) + Math.cos(321) * 29;
+acc += Math.sin(321) + Math.cos(322) * 30;
+acc += Math.sin(322) + Math.cos(323) * 31;
+acc += Math.sin(323) + Math.cos(324) * 32;
+acc += Math.sin(324) + Math.cos(325) * 33;
+acc += Math.sin(325) + Math.cos(326) * 34;
+acc += Math.sin(326) + Math.cos(327) * 35;
+acc += Math.sin(327) + Math.cos(328) * 36;
+acc += Math.sin(328) + Math.cos(329) * 37;
+acc += Math.sin(329) + Math.cos(330) * 38;
+acc += Math.sin(330) + Math.cos(331) * 39;
+acc += Math.sin(331) + Math.cos(332) * 40;
+acc += Math.sin(332) + Math.cos(333) * 41;
+acc += Math.sin(333) + Math.cos(334) * 42;
+acc += Math.sin(334) + Math.cos(335) * 43;
+acc += Math.sin(335) + Math.cos(336) * 44;
+acc += Math.sin(336) + Math.cos(337) * 45;
+acc += Math.sin(337) + Math.cos(338) * 46;
+acc += Math.sin(338) + Math.cos(339) * 47;
+acc += Math.sin(339) + Math.cos(340) * 48;
+acc += Math.sin(340) + Math.cos(341) * 49;
+acc += Math.sin(341) + Math.cos(342) * 50;
+acc += Math.sin(342) + Math.cos(343) * 51;
+acc += Math.sin(343) + Math.cos(344) * 52;
+acc += Math.sin(344) + Math.cos(345) * 53;
+acc += Math.sin(345) + Math.cos(346) * 54;
+acc += Math.sin(346) + Math.cos(347) * 55;
+acc += Math.sin(347) + Math.cos(348) * 56;
+acc += Math.sin(348) + Math.cos(349) * 57;
+acc += Math.sin(349) + Math.cos(350) * 58;
+acc += Math.sin(350) + Math.cos(351) * 59;
+acc += Math.sin(351) + Math.cos(352) * 60;
+acc += Math.sin(352) + Math.cos(353) * 61;
+acc += Math.sin(353) + Math.cos(354) * 62;
+acc += Math.sin(354) + Math.cos(355) * 63;
+acc += Math.sin(355) + Math.cos(356) * 64;
+acc += Math.sin(356) + Math.cos(357) * 65;
+acc += Math.sin(357) + Math.cos(358) * 66;
+acc += Math.sin(358) + Math.cos(359) * 67;
+acc += Math.sin(359) + Math.cos(360) * 68;
+acc += Math.sin(360) + Math.cos(361) * 69;
+acc += Math.sin(361) + Math.cos(362) * 70;
+acc += Math.sin(362) + Math.cos(363) * 71;
+acc += Math.sin(363) + Math.cos(364) * 72;
+acc += Math.sin(364) + Math.cos(365) * 73;
+acc += Math.sin(365) + Math.cos(366) * 74;
+acc += Math.sin(366) + Math.cos(367) * 75;
+acc += Math.sin(367) + Math.cos(368) * 76;
+acc += Math.sin(368) + Math.cos(369) * 77;
+acc += Math.sin(369) + Math.cos(370) * 78;
+acc += Math.sin(370) + Math.cos(371) * 79;
+acc += Math.sin(371) + Math.cos(372) * 80;
+acc += Math.sin(372) + Math.cos(373) * 81;
+acc += Math.sin(373) + Math.cos(374) * 82;
+acc += Math.sin(374) + Math.cos(375) * 83;
+acc += Math.sin(375) + Math.cos(376) * 84;
+acc += Math.sin(376) + Math.cos(377) * 85;
+acc += Math.sin(377) + Math.cos(378) * 86;
+acc += Math.sin(378) + Math.cos(379) * 87;
+acc += Math.sin(379) + Math.cos(380) * 88;
+acc += Math.sin(380) + Math.cos(381) * 89;
+acc += Math.sin(381) + Math.cos(382) * 90;
+acc += Math.sin(382) + Math.cos(383) * 91;
+acc += Math.sin(383) + Math.cos(384) * 92;
+acc += Math.sin(384) + Math.cos(385) * 93;
+acc += Math.sin(385) + Math.cos(386) * 94;
+acc += Math.sin(386) + Math.cos(387) * 95;
+acc += Math.sin(387) + Math.cos(388) * 96;
+acc += Math.sin(388) + Math.cos(389) * 0;
+acc += Math.sin(389) + Math.cos(390) * 1;
+acc += Math.sin(390) + Math.cos(391) * 2;
+acc += Math.sin(391) + Math.cos(392) * 3;
+acc += Math.sin(392) + Math.cos(393) * 4;
+acc += Math.sin(393) + Math.cos(394) * 5;
+acc += Math.sin(394) + Math.cos(395) * 6;
+acc += Math.sin(395) + Math.cos(396) * 7;
+acc += Math.sin(396) + Math.cos(397) * 8;
+acc += Math.sin(397) + Math.cos(398) * 9;
+acc += Math.sin(398) + Math.cos(399) * 10;
+acc += Math.sin(399) + Math.cos(400) * 11;
+acc += Math.sin(400) + Math.cos(401) * 12;
+acc += Math.sin(401) + Math.cos(402) * 13;
+acc += Math.sin(402) + Math.cos(403) * 14;
+acc += Math.sin(403) + Math.cos(404) * 15;
+acc += Math.sin(404) + Math.cos(405) * 16;
+acc += Math.sin(405) + Math.cos(406) * 17;
+acc += Math.sin(406) + Math.cos(407) * 18;
+acc += Math.sin(407) + Math.cos(408) * 19;
+acc += Math.sin(408) + Math.cos(409) * 20;
+acc += Math.sin(409) + Math.cos(410) * 21;
+acc += Math.sin(410) + Math.cos(411) * 22;
+acc += Math.sin(411) + Math.cos(412) * 23;
+acc += Math.sin(412) + Math.cos(413) * 24;
+acc += Math.sin(413) + Math.cos(414) * 25;
+acc += Math.sin(414) + Math.cos(415) * 26;
+acc += Math.sin(415) + Math.cos(416) * 27;
+acc += Math.sin(416) + Math.cos(417) * 28;
+acc += Math.sin(417) + Math.cos(418) * 29;
+acc += Math.sin(418) + Math.cos(419) * 30;
+acc += Math.sin(419) + Math.cos(420) * 31;
+acc += Math.sin(420) + Math.cos(421) * 32;
+acc += Math.sin(421) + Math.cos(422) * 33;
+acc += Math.sin(422) + Math.cos(423) * 34;
+acc += Math.sin(423) + Math.cos(424) * 35;
+acc += Math.sin(424) + Math.cos(425) * 36;
+acc += Math.sin(425) + Math.cos(426) * 37;
+acc += Math.sin(426) + Math.cos(427) * 38;
+acc += Math.sin(427) + Math.cos(428) * 39;
+acc += Math.sin(428) + Math.cos(429) * 40;
+acc += Math.sin(429) + Math.cos(430) * 41;
+acc += Math.sin(430) + Math.cos(431) * 42;
+acc += Math.sin(431) + Math.cos(432) * 43;
+acc += Math.sin(432) + Math.cos(433) * 44;
+acc += Math.sin(433) + Math.cos(434) * 45;
+acc += Math.sin(434) + Math.cos(435) * 46;
+acc += Math.sin(435) + Math.cos(436) * 47;
+acc += Math.sin(436) + Math.cos(437) * 48;
+acc += Math.sin(437) + Math.cos(438) * 49;
+acc += Math.sin(438) + Math.cos(439) * 50;
+acc += Math.sin(439) + Math.cos(440) * 51;
+acc += Math.sin(440) + Math.cos(441) * 52;
+acc += Math.sin(441) + Math.cos(442) * 53;
+acc += Math.sin(442) + Math.cos(443) * 54;
+acc += Math.sin(443) + Math.cos(444) * 55;
+acc += Math.sin(444) + Math.cos(445) * 56;
+acc += Math.sin(445) + Math.cos(446) * 57;
+acc += Math.sin(446) + Math.cos(447) * 58;
+acc += Math.sin(447) + Math.cos(448) * 59;
+acc += Math.sin(448) + Math.cos(449) * 60;
+acc += Math.sin(449) + Math.cos(450) * 61;
+acc += Math.sin(450) + Math.cos(451) * 62;
+acc += Math.sin(451) + Math.cos(452) * 63;
+acc += Math.sin(452) + Math.cos(453) * 64;
+acc += Math.sin(453) + Math.cos(454) * 65;
+acc += Math.sin(454) + Math.cos(455) * 66;
+acc += Math.sin(455) + Math.cos(456) * 67;
+acc += Math.sin(456) + Math.cos(457) * 68;
+acc += Math.sin(457) + Math.cos(458) * 69;
+acc += Math.sin(458) + Math.cos(459) * 70;
+acc += Math.sin(459) + Math.cos(460) * 71;
+acc += Math.sin(460) + Math.cos(461) * 72;
+acc += Math.sin(461) + Math.cos(462) * 73;
+acc += Math.sin(462) + Math.cos(463) * 74;
+acc += Math.sin(463) + Math.cos(464) * 75;
+acc += Math.sin(464) + Math.cos(465) * 76;
+acc += Math.sin(465) + Math.cos(466) * 77;
+acc += Math.sin(466) + Math.cos(467) * 78;
+acc += Math.sin(467) + Math.cos(468) * 79;
+acc += Math.sin(468) + Math.cos(469) * 80;
+acc += Math.sin(469) + Math.cos(470) * 81;
+acc += Math.sin(470) + Math.cos(471) * 82;
+acc += Math.sin(471) + Math.cos(472) * 83;
+acc += Math.sin(472) + Math.cos(473) * 84;
+acc += Math.sin(473) + Math.cos(474) * 85;
+acc += Math.sin(474) + Math.cos(475) * 86;
+acc += Math.sin(475) + Math.cos(476) * 87;
+acc += Math.sin(476) + Math.cos(477) * 88;
+acc += Math.sin(477) + Math.cos(478) * 89;
+acc += Math.sin(478) + Math.cos(479) * 90;
+acc += Math.sin(479) + Math.cos(480) * 91;
+acc += Math.sin(480) + Math.cos(481) * 92;
+acc += Math.sin(481) + Math.cos(482) * 93;
+acc += Math.sin(482) + Math.cos(483) * 94;
+acc += Math.sin(483) + Math.cos(484) * 95;
+acc += Math.sin(484) + Math.cos(485) * 96;
+acc += Math.sin(485) + Math.cos(486) * 0;
+acc += Math.sin(486) + Math.cos(487) * 1;
+acc += Math.sin(487) + Math.cos(488) * 2;
+acc += Math.sin(488) + Math.cos(489) * 3;
+acc += Math.sin(489) + Math.cos(490) * 4;
+acc += Math.sin(490) + Math.cos(491) * 5;
+acc += Math.sin(491) + Math.cos(492) * 6;
+acc += Math.sin(492) + Math.cos(493) * 7;
+acc += Math.sin(493) + Math.cos(494) * 8;
+acc += Math.sin(494) + Math.cos(495) * 9;
+acc += Math.sin(495) + Math.cos(496) * 10;
+acc += Math.sin(496) + Math.cos(497) * 11;
+acc += Math.sin(497) + Math.cos(498) * 12;
+acc += Math.sin(498) + Math.cos(499) * 13;
+acc += Math.sin(499) + Math.cos(500) * 14;
+acc += Math.sin(500) + Math.cos(501) * 15;
+acc += Math.sin(501) + Math.cos(502) * 16;
+acc += Math.sin(502) + Math.cos(503) * 17;
+acc += Math.sin(503) + Math.cos(504) * 18;
+acc += Math.sin(504) + Math.cos(505) * 19;
+acc += Math.sin(505) + Math.cos(506) * 20;
+acc += Math.sin(506) + Math.cos(507) * 21;
+acc += Math.sin(507) + Math.cos(508) * 22;
+acc += Math.sin(508) + Math.cos(509) * 23;
+acc += Math.sin(509) + Math.cos(510) * 24;
+acc += Math.sin(510) + Math.cos(511) * 25;
+acc += Math.sin(511) + Math.cos(512) * 26;
+acc += Math.sin(512) + Math.cos(513) * 27;
+acc += Math.sin(513) + Math.cos(514) * 28;
+acc += Math.sin(514) + Math.cos(515) * 29;
+acc += Math.sin(515) + Math.cos(516) * 30;
+acc += Math.sin(516) + Math.cos(517) * 31;
+acc += Math.sin(517) + Math.cos(518) * 32;
+acc += Math.sin(518) + Math.cos(519) * 33;
+acc += Math.sin(519) + Math.cos(520) * 34;
+acc += Math.sin(520) + Math.cos(521) * 35;
+acc += Math.sin(521) + Math.cos(522) * 36;
+acc += Math.sin(522) + Math.cos(523) * 37;
+acc += Math.sin(523) + Math.cos(524) * 38;
+acc += Math.sin(524) + Math.cos(525) * 39;
+acc += Math.sin(525) + Math.cos(526) * 40;
+acc += Math.sin(526) + Math.cos(527) * 41;
+acc += Math.sin(527) + Math.cos(528) * 42;
+acc += Math.sin(528) + Math.cos(529) * 43;
+acc += Math.sin(529) + Math.cos(530) * 44;
+acc += Math.sin(530) + Math.cos(531) * 45;
+acc += Math.sin(531) + Math.cos(532) * 46;
+acc += Math.sin(532) + Math.cos(533) * 47;
+acc += Math.sin(533) + Math.cos(534) * 48;
+acc += Math.sin(534) + Math.cos(535) * 49;
+acc += Math.sin(535) + Math.cos(536) * 50;
+acc += Math.sin(536) + Math.cos(537) * 51;
+acc += Math.sin(537) + Math.cos(538) * 52;
+acc += Math.sin(538) + Math.cos(539) * 53;
+acc += Math.sin(539) + Math.cos(540) * 54;
+acc += Math.sin(540) + Math.cos(541) * 55;
+acc += Math.sin(541) + Math.cos(542) * 56;
+acc += Math.sin(542) + Math.cos(543) * 57;
+acc += Math.sin(543) + Math.cos(544) * 58;
+acc += Math.sin(544) + Math.cos(545) * 59;
+acc += Math.sin(545) + Math.cos(546) * 60;
+acc += Math.sin(546) + Math.cos(547) * 61;
+acc += Math.sin(547) + Math.cos(548) * 62;
+acc += Math.sin(548) + Math.cos(549) * 63;
+acc += Math.sin(549) + Math.cos(550) * 64;
+acc += Math.sin(550) + Math.cos(551) * 65;
+acc += Math.sin(551) + Math.cos(552) * 66;
+acc += Math.sin(552) + Math.cos(553) * 67;
+acc += Math.sin(553) + Math.cos(554) * 68;
+acc += Math.sin(554) + Math.cos(555) * 69;
+acc += Math.sin(555) + Math.cos(556) * 70;
+acc += Math.sin(556) + Math.cos(557) * 71;
+acc += Math.sin(557) + Math.cos(558) * 72;
+acc += Math.sin(558) + Math.cos(559) * 73;
+acc += Math.sin(559) + Math.cos(560) * 74;
+acc += Math.sin(560) + Math.cos(561) * 75;
+acc += Math.sin(561) + Math.cos(562) * 76;
+acc += Math.sin(562) + Math.cos(563) * 77;
+acc += Math.sin(563) + Math.cos(564) * 78;
+acc += Math.sin(564) + Math.cos(565) * 79;
+acc += Math.sin(565) + Math.cos(566) * 80;
+acc += Math.sin(566) + Math.cos(567) * 81;
+acc += Math.sin(567) + Math.cos(568) * 82;
+acc += Math.sin(568) + Math.cos(569) * 83;
+acc += Math.sin(569) + Math.cos(570) * 84;
+acc += Math.sin(570) + Math.cos(571) * 85;
+acc += Math.sin(571) + Math.cos(572) * 86;
+acc += Math.sin(572) + Math.cos(573) * 87;
+acc += Math.sin(573) + Math.cos(574) * 88;
+acc += Math.sin(574) + Math.cos(575) * 89;
+acc += Math.sin(575) + Math.cos(576) * 90;
+acc += Math.sin(576) + Math.cos(577) * 91;
+acc += Math.sin(577) + Math.cos(578) * 92;
+acc += Math.sin(578) + Math.cos(579) * 93;
+acc += Math.sin(579) + Math.cos(580) * 94;
+acc += Math.sin(580) + Math.cos(581) * 95;
+acc += Math.sin(581) + Math.cos(582) * 96;
+acc += Math.sin(582) + Math.cos(583) * 0;
+acc += Math.sin(583) + Math.cos(584) * 1;
+acc += Math.sin(584) + Math.cos(585) * 2;
+acc += Math.sin(585) + Math.cos(586) * 3;
+acc += Math.sin(586) + Math.cos(587) * 4;
+acc += Math.sin(587) + Math.cos(588) * 5;
+acc += Math.sin(588) + Math.cos(589) * 6;
+acc += Math.sin(589) + Math.cos(590) * 7;
+acc += Math.sin(590) + Math.cos(591) * 8;
+acc += Math.sin(591) + Math.cos(592) * 9;
+acc += Math.sin(592) + Math.cos(593) * 10;
+acc += Math.sin(593) + Math.cos(594) * 11;
+acc += Math.sin(594) + Math.cos(595) * 12;
+acc += Math.sin(595) + Math.cos(596) * 13;
+acc += Math.sin(596) + Math.cos(597) * 14;
+acc += Math.sin(597) + Math.cos(598) * 15;
+acc += Math.sin(598) + Math.cos(599) * 16;
+acc += Math.sin(599) + Math.cos(600) * 17;
+acc += Math.sin(600) + Math.cos(601) * 18;
+acc += Math.sin(601) + Math.cos(602) * 19;
+acc += Math.sin(602) + Math.cos(603) * 20;
+acc += Math.sin(603) + Math.cos(604) * 21;
+acc += Math.sin(604) + Math.cos(605) * 22;
+acc += Math.sin(605) + Math.cos(606) * 23;
+acc += Math.sin(606) + Math.cos(607) * 24;
+acc += Math.sin(607) + Math.cos(608) * 25;
+acc += Math.sin(608) + Math.cos(609) * 26;
+acc += Math.sin(609) + Math.cos(610) * 27;
+acc += Math.sin(610) + Math.cos(611) * 28;
+acc += Math.sin(611) + Math.cos(612) * 29;
+acc += Math.sin(612) + Math.cos(613) * 30;
+acc += Math.sin(613) + Math.cos(614) * 31;
+acc += Math.sin(614) + Math.cos(615) * 32;
+acc += Math.sin(615) + Math.cos(616) * 33;
+acc += Math.sin(616) + Math.cos(617) * 34;
+acc += Math.sin(617) + Math.cos(618) * 35;
+acc += Math.sin(618) + Math.cos(619) * 36;
+acc += Math.sin(619) + Math.cos(620) * 37;
+acc += Math.sin(620) + Math.cos(621) * 38;
+acc += Math.sin(621) + Math.cos(622) * 39;
+acc += Math.sin(622) + Math.cos(623) * 40;
+acc += Math.sin(623) + Math.cos(624) * 41;
+acc += Math.sin(624) + Math.cos(625) * 42;
+acc += Math.sin(625) + Math.cos(626) * 43;
+acc += Math.sin(626) + Math.cos(627) * 44;
+acc += Math.sin(627) + Math.cos(628) * 45;
+acc += Math.sin(628) + Math.cos(629) * 46;
+acc += Math.sin(629) + Math.cos(630) * 47;
+acc += Math.sin(630) + Math.cos(631) * 48;
+acc += Math.sin(631) + Math.cos(632) * 49;
+acc += Math.sin(632) + Math.cos(633) * 50;
+acc += Math.sin(633) + Math.cos(634) * 51;
+acc += Math.sin(634) + Math.cos(635) * 52;
+acc += Math.sin(635) + Math.cos(636) * 53;
+acc += Math.sin(636) + Math.cos(637) * 54;
+acc += Math.sin(637) + Math.cos(638) * 55;
+acc += Math.sin(638) + Math.cos(639) * 56;
+acc += Math.sin(639) + Math.cos(640) * 57;
+acc += Math.sin(640) + Math.cos(641) * 58;
+acc += Math.sin(641) + Math.cos(642) * 59;
+acc += Math.sin(642) + Math.cos(643) * 60;
+acc += Math.sin(643) + Math.cos(644) * 61;
+acc += Math.sin(644) + Math.cos(645) * 62;
+acc += Math.sin(645) + Math.cos(646) * 63;
+acc += Math.sin(646) + Math.cos(647) * 64;
+acc += Math.sin(647) + Math.cos(648) * 65;
+acc += Math.sin(648) + Math.cos(649) * 66;
+acc += Math.sin(649) + Math.cos(650) * 67;
+acc += Math.sin(650) + Math.cos(651) * 68;
+acc += Math.sin(651) + Math.cos(652) * 69;
+acc += Math.sin(652) + Math.cos(653) * 70;
+acc += Math.sin(653) + Math.cos(654) * 71;
+acc += Math.sin(654) + Math.cos(655) * 72;
+acc += Math.sin(655) + Math.cos(656) * 73;
+acc += Math.sin(656) + Math.cos(657) * 74;
+acc += Math.sin(657) + Math.cos(658) * 75;
+acc += Math.sin(658) + Math.cos(659) * 76;
+acc += Math.sin(659) + Math.cos(660) * 77;
+acc += Math.sin(660) + Math.cos(661) * 78;
+acc += Math.sin(661) + Math.cos(662) * 79;
+acc += Math.sin(662) + Math.cos(663) * 80;
+acc += Math.sin(663) + Math.cos(664) * 81;
+acc += Math.sin(664) + Math.cos(665) * 82;
+acc += Math.sin(665) + Math.cos(666) * 83;
+acc += Math.sin(666) + Math.cos(667) * 84;
+acc += Math.sin(667) + Math.cos(668) * 85;
+acc += Math.sin(668) + Math.cos(669) * 86;
+acc += Math.sin(669) + Math.cos(670) * 87;
+acc += Math.sin(670) + Math.cos(671) * 88;
+acc += Math.sin(671) + Math.cos(672) * 89;
+acc += Math.sin(672) + Math.cos(673) * 90;
+acc += Math.sin(673) + Math.cos(674) * 91;
+acc += Math.sin(674) + Math.cos(675) * 92;
+acc += Math.sin(675) + Math.cos(676) * 93;
+acc += Math.sin(676) + Math.cos(677) * 94;
+acc += Math.sin(677) + Math.cos(678) * 95;
+acc += Math.sin(678) + Math.cos(679) * 96;
+acc += Math.sin(679) + Math.cos(680) * 0;
+acc += Math.sin(680) + Math.cos(681) * 1;
+acc += Math.sin(681) + Math.cos(682) * 2;
+acc += Math.sin(682) + Math.cos(683) * 3;
+acc += Math.sin(683) + Math.cos(684) * 4;
+acc += Math.sin(684) + Math.cos(685) * 5;
+acc += Math.sin(685) + Math.cos(686) * 6;
+acc += Math.sin(686) + Math.cos(687) * 7;
+acc += Math.sin(687) + Math.cos(688) * 8;
+acc += Math.sin(688) + Math.cos(689) * 9;
+acc += Math.sin(689) + Math.cos(690) * 10;
+acc += Math.sin(690) + Math.cos(691) * 11;
+acc += Math.sin(691) + Math.cos(692) * 12;
+acc += Math.sin(692) + Math.cos(693) * 13;
+acc += Math.sin(693) + Math.cos(694) * 14;
+acc += Math.sin(694) + Math.cos(695) * 15;
+acc += Math.sin(695) + Math.cos(696) * 16;
+acc += Math.sin(696) + Math.cos(697) * 17;
+acc += Math.sin(697) + Math.cos(698) * 18;
+acc += Math.sin(698) + Math.cos(699) * 19;
+acc += Math.sin(699) + Math.cos(700) * 20;
+acc += Math.sin(700) + Math.cos(701) * 21;
+acc += Math.sin(701) + Math.cos(702) * 22;
+acc += Math.sin(702) + Math.cos(703) * 23;
+acc += Math.sin(703) + Math.cos(704) * 24;
+acc += Math.sin(704) + Math.cos(705) * 25;
+acc += Math.sin(705) + Math.cos(706) * 26;
+acc += Math.sin(706) + Math.cos(707) * 27;
+acc += Math.sin(707) + Math.cos(708) * 28;
+acc += Math.sin(708) + Math.cos(709) * 29;
+acc += Math.sin(709) + Math.cos(710) * 30;
+acc += Math.sin(710) + Math.cos(711) * 31;
+acc += Math.sin(711) + Math.cos(712) * 32;
+acc += Math.sin(712) + Math.cos(713) * 33;
+acc += Math.sin(713) + Math.cos(714) * 34;
+acc += Math.sin(714) + Math.cos(715) * 35;
+acc += Math.sin(715) + Math.cos(716) * 36;
+acc += Math.sin(716) + Math.cos(717) * 37;
+acc += Math.sin(717) + Math.cos(718) * 38;
+acc += Math.sin(718) + Math.cos(719) * 39;
+acc += Math.sin(719) + Math.cos(720) * 40;
+acc += Math.sin(720) + Math.cos(721) * 41;
+acc += Math.sin(721) + Math.cos(722) * 42;
+acc += Math.sin(722) + Math.cos(723) * 43;
+acc += Math.sin(723) + Math.cos(724) * 44;
+acc += Math.sin(724) + Math.cos(725) * 45;
+acc += Math.sin(725) + Math.cos(726) * 46;
+acc += Math.sin(726) + Math.cos(727) * 47;
+acc += Math.sin(727) + Math.cos(728) * 48;
+acc += Math.sin(728) + Math.cos(729) * 49;
+acc += Math.sin(729) + Math.cos(730) * 50;
+acc += Math.sin(730) + Math.cos(731) * 51;
+acc += Math.sin(731) + Math.cos(732) * 52;
+acc += Math.sin(732) + Math.cos(733) * 53;
+acc += Math.sin(733) + Math.cos(734) * 54;
+acc += Math.sin(734) + Math.cos(735) * 55;
+acc += Math.sin(735) + Math.cos(736) * 56;
+acc += Math.sin(736) + Math.cos(737) * 57;
+acc += Math.sin(737) + Math.cos(738) * 58;
+acc += Math.sin(738) + Math.cos(739) * 59;
+acc += Math.sin(739) + Math.cos(740) * 60;
+acc += Math.sin(740) + Math.cos(741) * 61;
+acc += Math.sin(741) + Math.cos(742) * 62;
+acc += Math.sin(742) + Math.cos(743) * 63;
+acc += Math.sin(743) + Math.cos(744) * 64;
+acc += Math.sin(744) + Math.cos(745) * 65;
+acc += Math.sin(745) + Math.cos(746) * 66;
+acc += Math.sin(746) + Math.cos(747) * 67;
+acc += Math.sin(747) + Math.cos(748) * 68;
+acc += Math.sin(748) + Math.cos(749) * 69;
+acc += Math.sin(749) + Math.cos(750) * 70;
+acc += Math.sin(750) + Math.cos(751) * 71;
+acc += Math.sin(751) + Math.cos(752) * 72;
+acc += Math.sin(752) + Math.cos(753) * 73;
+acc += Math.sin(753) + Math.cos(754) * 74;
+acc += Math.sin(754) + Math.cos(755) * 75;
+acc += Math.sin(755) + Math.cos(756) * 76;
+acc += Math.sin(756) + Math.cos(757) * 77;
+acc += Math.sin(757) + Math.cos(758) * 78;
+acc += Math.sin(758) + Math.cos(759) * 79;
+acc += Math.sin(759) + Math.cos(760) * 80;
+acc += Math.sin(760) + Math.cos(761) * 81;
+acc += Math.sin(761) + Math.cos(762) * 82;
+acc += Math.sin(762) + Math.cos(763) * 83;
+acc += Math.sin(763) + Math.cos(764) * 84;
+acc += Math.sin(764) + Math.cos(765) * 85;
+acc += Math.sin(765) + Math.cos(766) * 86;
+acc += Math.sin(766) + Math.cos(767) * 87;
+acc += Math.sin(767) + Math.cos(768) * 88;
+acc += Math.sin(768) + Math.cos(769) * 89;
+acc += Math.sin(769) + Math.cos(770) * 90;
+acc += Math.sin(770) + Math.cos(771) * 91;
+acc += Math.sin(771) + Math.cos(772) * 92;
+acc += Math.sin(772) + Math.cos(773) * 93;
+acc += Math.sin(773) + Math.cos(774) * 94;
+acc += Math.sin(774) + Math.cos(775) * 95;
+acc += Math.sin(775) + Math.cos(776) * 96;
+acc += Math.sin(776) + Math.cos(777) * 0;
+acc += Math.sin(777) + Math.cos(778) * 1;
+acc += Math.sin(778) + Math.cos(779) * 2;
+acc += Math.sin(779) + Math.cos(780) * 3;
+acc += Math.sin(780) + Math.cos(781) * 4;
+acc += Math.sin(781) + Math.cos(782) * 5;
+acc += Math.sin(782) + Math.cos(783) * 6;
+acc += Math.sin(783) + Math.cos(784) * 7;
+acc += Math.sin(784) + Math.cos(785) * 8;
+acc += Math.sin(785) + Math.cos(786) * 9;
+acc += Math.sin(786) + Math.cos(787) * 10;
+acc += Math.sin(787) + Math.cos(788) * 11;
+acc += Math.sin(788) + Math.cos(789) * 12;
+acc += Math.sin(789) + Math.cos(790) * 13;
+acc += Math.sin(790) + Math.cos(791) * 14;
+acc += Math.sin(791) + Math.cos(792) * 15;
+acc += Math.sin(792) + Math.cos(793) * 16;
+acc += Math.sin(793) + Math.cos(794) * 17;
+acc += Math.sin(794) + Math.cos(795) * 18;
+acc += Math.sin(795) + Math.cos(796) * 19;
+acc += Math.sin(796) + Math.cos(797) * 20;
+acc += Math.sin(797) + Math.cos(798) * 21;
+acc += Math.sin(798) + Math.cos(799) * 22;
+acc += Math.sin(799) + Math.cos(800) * 23;
+acc += Math.sin(800) + Math.cos(801) * 24;
+acc += Math.sin(801) + Math.cos(802) * 25;
+acc += Math.sin(802) + Math.cos(803) * 26;
+acc += Math.sin(803) + Math.cos(804) * 27;
+acc += Math.sin(804) + Math.cos(805) * 28;
+acc += Math.sin(805) + Math.cos(806) * 29;
+acc += Math.sin(806) + Math.cos(807) * 30;
+acc += Math.sin(807) + Math.cos(808) * 31;
+acc += Math.sin(808) + Math.cos(809) * 32;
+acc += Math.sin(809) + Math.cos(810) * 33;
+acc += Math.sin(810) + Math.cos(811) * 34;
+acc += Math.sin(811) + Math.cos(812) * 35;
+acc += Math.sin(812) + Math.cos(813) * 36;
+acc += Math.sin(813) + Math.cos(814) * 37;
+acc += Math.sin(814) + Math.cos(815) * 38;
+acc += Math.sin(815) + Math.cos(816) * 39;
+acc += Math.sin(816) + Math.cos(817) * 40;
+acc += Math.sin(817) + Math.cos(818) * 41;
+acc += Math.sin(818) + Math.cos(819) * 42;
+acc += Math.sin(819) + Math.cos(820) * 43;
+acc += Math.sin(820) + Math.cos(821) * 44;
+acc += Math.sin(821) + Math.cos(822) * 45;
+acc += Math.sin(822) + Math.cos(823) * 46;
+acc += Math.sin(823) + Math.cos(824) * 47;
+acc += Math.sin(824) + Math.cos(825) * 48;
+acc += Math.sin(825) + Math.cos(826) * 49;
+acc += Math.sin(826) + Math.cos(827) * 50;
+acc += Math.sin(827) + Math.cos(828) * 51;
+acc += Math.sin(828) + Math.cos(829) * 52;
+acc += Math.sin(829) + Math.cos(830) * 53;
+acc += Math.sin(830) + Math.cos(831) * 54;
+acc += Math.sin(831) + Math.cos(832) * 55;
+acc += Math.sin(832) + Math.cos(833) * 56;
+acc += Math.sin(833) + Math.cos(834) * 57;
+acc += Math.sin(834) + Math.cos(835) * 58;
+acc += Math.sin(835) + Math.cos(836) * 59;
+acc += Math.sin(836) + Math.cos(837) * 60;
+acc += Math.sin(837) + Math.cos(838) * 61;
+acc += Math.sin(838) + Math.cos(839) * 62;
+acc += Math.sin(839) + Math.cos(840) * 63;
+acc += Math.sin(840) + Math.cos(841) * 64;
+acc += Math.sin(841) + Math.cos(842) * 65;
+acc += Math.sin(842) + Math.cos(843) * 66;
+acc += Math.sin(843) + Math.cos(844) * 67;
+acc += Math.sin(844) + Math.cos(845) * 68;
+acc += Math.sin(845) + Math.cos(846) * 69;
+acc += Math.sin(846) + Math.cos(847) * 70;
+acc += Math.sin(847) + Math.cos(848) * 71;
+acc += Math.sin(848) + Math.cos(849) * 72;
+acc += Math.sin(849) + Math.cos(850) * 73;
+acc += Math.sin(850) + Math.cos(851) * 74;
+acc += Math.sin(851) + Math.cos(852) * 75;
+acc += Math.sin(852) + Math.cos(853) * 76;
+acc += Math.sin(853) + Math.cos(854) * 77;
+acc += Math.sin(854) + Math.cos(855) * 78;
+acc += Math.sin(855) + Math.cos(856) * 79;
+acc += Math.sin(856) + Math.cos(857) * 80;
+acc += Math.sin(857) + Math.cos(858) * 81;
+acc += Math.sin(858) + Math.cos(859) * 82;
+acc += Math.sin(859) + Math.cos(860) * 83;
+acc += Math.sin(860) + Math.cos(861) * 84;
+acc += Math.sin(861) + Math.cos(862) * 85;
+acc += Math.sin(862) + Math.cos(863) * 86;
+acc += Math.sin(863) + Math.cos(864) * 87;
+acc += Math.sin(864) + Math.cos(865) * 88;
+acc += Math.sin(865) + Math.cos(866) * 89;
+acc += Math.sin(866) + Math.cos(867) * 90;
+acc += Math.sin(867) + Math.cos(868) * 91;
+acc += Math.sin(868) + Math.cos(869) * 92;
+acc += Math.sin(869) + Math.cos(870) * 93;
+acc += Math.sin(870) + Math.cos(871) * 94;
+acc += Math.sin(871) + Math.cos(872) * 95;
+acc += Math.sin(872) + Math.cos(873) * 96;
+acc += Math.sin(873) + Math.cos(874) * 0;
+acc += Math.sin(874) + Math.cos(875) * 1;
+acc += Math.sin(875) + Math.cos(876) * 2;
+acc += Math.sin(876) + Math.cos(877) * 3;
+acc += Math.sin(877) + Math.cos(878) * 4;
+acc += Math.sin(878) + Math.cos(879) * 5;
+acc += Math.sin(879) + Math.cos(880) * 6;
+acc += Math.sin(880) + Math.cos(881) * 7;
+acc += Math.sin(881) + Math.cos(882) * 8;
+acc += Math.sin(882) + Math.cos(883) * 9;
+acc += Math.sin(883) + Math.cos(884) * 10;
+acc += Math.sin(884) + Math.cos(885) * 11;
+acc += Math.sin(885) + Math.cos(886) * 12;
+acc += Math.sin(886) + Math.cos(887) * 13;
+acc += Math.sin(887) + Math.cos(888) * 14;
+acc += Math.sin(888) + Math.cos(889) * 15;
+acc += Math.sin(889) + Math.cos(890) * 16;
+acc += Math.sin(890) + Math.cos(891) * 17;
+acc += Math.sin(891) + Math.cos(892) * 18;
+acc += Math.sin(892) + Math.cos(893) * 19;
+acc += Math.sin(893) + Math.cos(894) * 20;
+acc += Math.sin(894) + Math.cos(895) * 21;
+acc += Math.sin(895) + Math.cos(896) * 22;
+acc += Math.sin(896) + Math.cos(897) * 23;
+acc += Math.sin(897) + Math.cos(898) * 24;
+acc += Math.sin(898) + Math.cos(899) * 25;
+acc += Math.sin(899) + Math.cos(900) * 26;
+acc += Math.sin(900) + Math.cos(901) * 27;
+acc += Math.sin(901) + Math.cos(902) * 28;
+acc += Math.sin(902) + Math.cos(903) * 29;
+acc += Math.sin(903) + Math.cos(904) * 30;
+acc += Math.sin(904) + Math.cos(905) * 31;
+acc += Math.sin(905) + Math.cos(906) * 32;
+acc += Math.sin(906) + Math.cos(907) * 33;
+acc += Math.sin(907) + Math.cos(908) * 34;
+acc += Math.sin(908) + Math.cos(909) * 35;
+acc += Math.sin(909) + Math.cos(910) * 36;
+acc += Math.sin(910) + Math.cos(911) * 37;
+acc += Math.sin(911) + Math.cos(912) * 38;
+acc += Math.sin(912) + Math.cos(913) * 39;
+acc += Math.sin(913) + Math.cos(914) * 40;
+acc += Math.sin(914) + Math.cos(915) * 41;
+acc += Math.sin(915) + Math.cos(916) * 42;
+acc += Math.sin(916) + Math.cos(917) * 43;
+acc += Math.sin(917) + Math.cos(918) * 44;
+acc += Math.sin(918) + Math.cos(919) * 45;
+acc += Math.sin(919) + Math.cos(920) * 46;
+acc += Math.sin(920) + Math.cos(921) * 47;
+acc += Math.sin(921) + Math.cos(922) * 48;
+acc += Math.sin(922) + Math.cos(923) * 49;
+acc += Math.sin(923) + Math.cos(924) * 50;
+acc += Math.sin(924) + Math.cos(925) * 51;
+acc += Math.sin(925) + Math.cos(926) * 52;
+acc += Math.sin(926) + Math.cos(927) * 53;
+acc += Math.sin(927) + Math.cos(928) * 54;
+acc += Math.sin(928) + Math.cos(929) * 55;
+acc += Math.sin(929) + Math.cos(930) * 56;
+acc += Math.sin(930) + Math.cos(931) * 57;
+acc += Math.sin(931) + Math.cos(932) * 58;
+acc += Math.sin(932) + Math.cos(933) * 59;
+acc += Math.sin(933) + Math.cos(934) * 60;
+acc += Math.sin(934) + Math.cos(935) * 61;
+acc += Math.sin(935) + Math.cos(936) * 62;
+acc += Math.sin(936) + Math.cos(937) * 63;
+acc += Math.sin(937) + Math.cos(938) * 64;
+acc += Math.sin(938) + Math.cos(939) * 65;
+acc += Math.sin(939) + Math.cos(940) * 66;
+acc += Math.sin(940) + Math.cos(941) * 67;
+acc += Math.sin(941) + Math.cos(942) * 68;
+acc += Math.sin(942) + Math.cos(943) * 69;
+acc += Math.sin(943) + Math.cos(944) * 70;
+acc += Math.sin(944) + Math.cos(945) * 71;
+acc += Math.sin(945) + Math.cos(946) * 72;
+acc += Math.sin(946) + Math.cos(947) * 73;
+acc += Math.sin(947) + Math.cos(948) * 74;
+acc += Math.sin(948) + Math.cos(949) * 75;
+acc += Math.sin(949) + Math.cos(950) * 76;
+acc += Math.sin(950) + Math.cos(951) * 77;
+acc += Math.sin(951) + Math.cos(952) * 78;
+acc += Math.sin(952) + Math.cos(953) * 79;
+acc += Math.sin(953) + Math.cos(954) * 80;
+acc += Math.sin(954) + Math.cos(955) * 81;
+acc += Math.sin(955) + Math.cos(956) * 82;
+acc += Math.sin(956) + Math.cos(957) * 83;
+acc += Math.sin(957) + Math.cos(958) * 84;
+acc += Math.sin(958) + Math.cos(959) * 85;
+acc += Math.sin(959) + Math.cos(960) * 86;
+acc += Math.sin(960) + Math.cos(961) * 87;
+acc += Math.sin(961) + Math.cos(962) * 88;
+acc += Math.sin(962) + Math.cos(963) * 89;
+acc += Math.sin(963) + Math.cos(964) * 90;
+acc += Math.sin(964) + Math.cos(965) * 91;
+acc += Math.sin(965) + Math.cos(966) * 92;
+acc += Math.sin(966) + Math.cos(967) * 93;
+acc += Math.sin(967) + Math.cos(968) * 94;
+acc += Math.sin(968) + Math.cos(969) * 95;
+acc += Math.sin(969) + Math.cos(970) * 96;
+acc += Math.sin(970) + Math.cos(971) * 0;
+acc += Math.sin(971) + Math.cos(972) * 1;
+acc += Math.sin(972) + Math.cos(973) * 2;
+acc += Math.sin(973) + Math.cos(974) * 3;
+acc += Math.sin(974) + Math.cos(975) * 4;
+acc += Math.sin(975) + Math.cos(976) * 5;
+acc += Math.sin(976) + Math.cos(977) * 6;
+acc += Math.sin(977) + Math.cos(978) * 7;
+acc += Math.sin(978) + Math.cos(979) * 8;
+acc += Math.sin(979) + Math.cos(980) * 9;
+acc += Math.sin(980) + Math.cos(981) * 10;
+acc += Math.sin(981) + Math.cos(982) * 11;
+acc += Math.sin(982) + Math.cos(983) * 12;
+acc += Math.sin(983) + Math.cos(984) * 13;
+acc += Math.sin(984) + Math.cos(985) * 14;
+acc += Math.sin(985) + Math.cos(986) * 15;
+acc += Math.sin(986) + Math.cos(987) * 16;
+acc += Math.sin(987) + Math.cos(988) * 17;
+acc += Math.sin(988) + Math.cos(989) * 18;
+acc += Math.sin(989) + Math.cos(990) * 19;
+acc += Math.sin(990) + Math.cos(991) * 20;
+acc += Math.sin(991) + Math.cos(992) * 21;
+acc += Math.sin(992) + Math.cos(993) * 22;
+acc += Math.sin(993) + Math.cos(994) * 23;
+acc += Math.sin(994) + Math.cos(995) * 24;
+acc += Math.sin(995) + Math.cos(996) * 25;
+acc += Math.sin(996) + Math.cos(997) * 26;
+acc += Math.sin(997) + Math.cos(998) * 27;
+acc += Math.sin(998) + Math.cos(999) * 28;
+acc += Math.sin(999) + Math.cos(1000) * 29;
+acc += Math.sin(1000) + Math.cos(1001) * 30;
+acc += Math.sin(1001) + Math.cos(1002) * 31;
+acc += Math.sin(1002) + Math.cos(1003) * 32;
+acc += Math.sin(1003) + Math.cos(1004) * 33;
+acc += Math.sin(1004) + Math.cos(1005) * 34;
+acc += Math.sin(1005) + Math.cos(1006) * 35;
+acc += Math.sin(1006) + Math.cos(1007) * 36;
+acc += Math.sin(1007) + Math.cos(1008) * 37;
+acc += Math.sin(1008) + Math.cos(1009) * 38;
+acc += Math.sin(1009) + Math.cos(1010) * 39;
+acc += Math.sin(1010) + Math.cos(1011) * 40;
+acc += Math.sin(1011) + Math.cos(1012) * 41;
+acc += Math.sin(1012) + Math.cos(1013) * 42;
+acc += Math.sin(1013) + Math.cos(1014) * 43;
+acc += Math.sin(1014) + Math.cos(1015) * 44;
+acc += Math.sin(1015) + Math.cos(1016) * 45;
+acc += Math.sin(1016) + Math.cos(1017) * 46;
+acc += Math.sin(1017) + Math.cos(1018) * 47;
+acc += Math.sin(1018) + Math.cos(1019) * 48;
+acc += Math.sin(1019) + Math.cos(1020) * 49;
+acc += Math.sin(1020) + Math.cos(1021) * 50;
+acc += Math.sin(1021) + Math.cos(1022) * 51;
+acc += Math.sin(1022) + Math.cos(1023) * 52;
+acc += Math.sin(1023) + Math.cos(1024) * 53;
+acc += Math.sin(1024) + Math.cos(1025) * 54;
+acc += Math.sin(1025) + Math.cos(1026) * 55;
+acc += Math.sin(1026) + Math.cos(1027) * 56;
+acc += Math.sin(1027) + Math.cos(1028) * 57;
+acc += Math.sin(1028) + Math.cos(1029) * 58;
+acc += Math.sin(1029) + Math.cos(1030) * 59;
+acc += Math.sin(1030) + Math.cos(1031) * 60;
+acc += Math.sin(1031) + Math.cos(1032) * 61;
+acc += Math.sin(1032) + Math.cos(1033) * 62;
+acc += Math.sin(1033) + Math.cos(1034) * 63;
+acc += Math.sin(1034) + Math.cos(1035) * 64;
+acc += Math.sin(1035) + Math.cos(1036) * 65;
+acc += Math.sin(1036) + Math.cos(1037) * 66;
+acc += Math.sin(1037) + Math.cos(1038) * 67;
+acc += Math.sin(1038) + Math.cos(1039) * 68;
+acc += Math.sin(1039) + Math.cos(1040) * 69;
+acc += Math.sin(1040) + Math.cos(1041) * 70;
+acc += Math.sin(1041) + Math.cos(1042) * 71;
+acc += Math.sin(1042) + Math.cos(1043) * 72;
+acc += Math.sin(1043) + Math.cos(1044) * 73;
+acc += Math.sin(1044) + Math.cos(1045) * 74;
+acc += Math.sin(1045) + Math.cos(1046) * 75;
+acc += Math.sin(1046) + Math.cos(1047) * 76;
+acc += Math.sin(1047) + Math.cos(1048) * 77;
+acc += Math.sin(1048) + Math.cos(1049) * 78;
+acc += Math.sin(1049) + Math.cos(1050) * 79;
+acc += Math.sin(1050) + Math.cos(1051) * 80;
+acc += Math.sin(1051) + Math.cos(1052) * 81;
+acc += Math.sin(1052) + Math.cos(1053) * 82;
+acc += Math.sin(1053) + Math.cos(1054) * 83;
+acc += Math.sin(1054) + Math.cos(1055) * 84;
+acc += Math.sin(1055) + Math.cos(1056) * 85;
+acc += Math.sin(1056) + Math.cos(1057) * 86;
+acc += Math.sin(1057) + Math.cos(1058) * 87;
+acc += Math.sin(1058) + Math.cos(1059) * 88;
+acc += Math.sin(1059) + Math.cos(1060) * 89;
+acc += Math.sin(1060) + Math.cos(1061) * 90;
+acc += Math.sin(1061) + Math.cos(1062) * 91;
+acc += Math.sin(1062) + Math.cos(1063) * 92;
+acc += Math.sin(1063) + Math.cos(1064) * 93;
+acc += Math.sin(1064) + Math.cos(1065) * 94;
+acc += Math.sin(1065) + Math.cos(1066) * 95;
+acc += Math.sin(1066) + Math.cos(1067) * 96;
+acc += Math.sin(1067) + Math.cos(1068) * 0;
+acc += Math.sin(1068) + Math.cos(1069) * 1;
+acc += Math.sin(1069) + Math.cos(1070) * 2;
+acc += Math.sin(1070) + Math.cos(1071) * 3;
+acc += Math.sin(1071) + Math.cos(1072) * 4;
+acc += Math.sin(1072) + Math.cos(1073) * 5;
+acc += Math.sin(1073) + Math.cos(1074) * 6;
+acc += Math.sin(1074) + Math.cos(1075) * 7;
+acc += Math.sin(1075) + Math.cos(1076) * 8;
+acc += Math.sin(1076) + Math.cos(1077) * 9;
+acc += Math.sin(1077) + Math.cos(1078) * 10;
+acc += Math.sin(1078) + Math.cos(1079) * 11;
+acc += Math.sin(1079) + Math.cos(1080) * 12;
+acc += Math.sin(1080) + Math.cos(1081) * 13;
+acc += Math.sin(1081) + Math.cos(1082) * 14;
+acc += Math.sin(1082) + Math.cos(1083) * 15;
+acc += Math.sin(1083) + Math.cos(1084) * 16;
+acc += Math.sin(1084) + Math.cos(1085) * 17;
+acc += Math.sin(1085) + Math.cos(1086) * 18;
+acc += Math.sin(1086) + Math.cos(1087) * 19;
+acc += Math.sin(1087) + Math.cos(1088) * 20;
+acc += Math.sin(1088) + Math.cos(1089) * 21;
+acc += Math.sin(1089) + Math.cos(1090) * 22;
+acc += Math.sin(1090) + Math.cos(1091) * 23;
+acc += Math.sin(1091) + Math.cos(1092) * 24;
+acc += Math.sin(1092) + Math.cos(1093) * 25;
+acc += Math.sin(1093) + Math.cos(1094) * 26;
+acc += Math.sin(1094) + Math.cos(1095) * 27;
+acc += Math.sin(1095) + Math.cos(1096) * 28;
+acc += Math.sin(1096) + Math.cos(1097) * 29;
+acc += Math.sin(1097) + Math.cos(1098) * 30;
+acc += Math.sin(1098) + Math.cos(1099) * 31;
+acc += Math.sin(1099) + Math.cos(1100) * 32;
+acc += Math.sin(1100) + Math.cos(1101) * 33;
+acc += Math.sin(1101) + Math.cos(1102) * 34;
+acc += Math.sin(1102) + Math.cos(1103) * 35;
+acc += Math.sin(1103) + Math.cos(1104) * 36;
+acc += Math.sin(1104) + Math.cos(1105) * 37;
+acc += Math.sin(1105) + Math.cos(1106) * 38;
+acc += Math.sin(1106) + Math.cos(1107) * 39;
+acc += Math.sin(1107) + Math.cos(1108) * 40;
+acc += Math.sin(1108) + Math.cos(1109) * 41;
+acc += Math.sin(1109) + Math.cos(1110) * 42;
+acc += Math.sin(1110) + Math.cos(1111) * 43;
+acc += Math.sin(1111) + Math.cos(1112) * 44;
+acc += Math.sin(1112) + Math.cos(1113) * 45;
+acc += Math.sin(1113) + Math.cos(1114) * 46;
+acc += Math.sin(1114) + Math.cos(1115) * 47;
+acc += Math.sin(1115) + Math.cos(1116) * 48;
+acc += Math.sin(1116) + Math.cos(1117) * 49;
+acc += Math.sin(1117) + Math.cos(1118) * 50;
+acc += Math.sin(1118) + Math.cos(1119) * 51;
+acc += Math.sin(1119) + Math.cos(1120) * 52;
+acc += Math.sin(1120) + Math.cos(1121) * 53;
+acc += Math.sin(1121) + Math.cos(1122) * 54;
+acc += Math.sin(1122) + Math.cos(1123) * 55;
+acc += Math.sin(1123) + Math.cos(1124) * 56;
+acc += Math.sin(1124) + Math.cos(1125) * 57;
+acc += Math.sin(1125) + Math.cos(1126) * 58;
+acc += Math.sin(1126) + Math.cos(1127) * 59;
+acc += Math.sin(1127) + Math.cos(1128) * 60;
+acc += Math.sin(1128) + Math.cos(1129) * 61;
+acc += Math.sin(1129) + Math.cos(1130) * 62;
+acc += Math.sin(1130) + Math.cos(1131) * 63;
+acc += Math.sin(1131) + Math.cos(1132) * 64;
+acc += Math.sin(1132) + Math.cos(1133) * 65;
+acc += Math.sin(1133) + Math.cos(1134) * 66;
+acc += Math.sin(1134) + Math.cos(1135) * 67;
+acc += Math.sin(1135) + Math.cos(1136) * 68;
+acc += Math.sin(1136) + Math.cos(1137) * 69;
+acc += Math.sin(1137) + Math.cos(1138) * 70;
+acc += Math.sin(1138) + Math.cos(1139) * 71;
+acc += Math.sin(1139) + Math.cos(1140) * 72;
+acc += Math.sin(1140) + Math.cos(1141) * 73;
+acc += Math.sin(1141) + Math.cos(1142) * 74;
+acc += Math.sin(1142) + Math.cos(1143) * 75;
+acc += Math.sin(1143) + Math.cos(1144) * 76;
+acc += Math.sin(1144) + Math.cos(1145) * 77;
+acc += Math.sin(1145) + Math.cos(1146) * 78;
+acc += Math.sin(1146) + Math.cos(1147) * 79;
+acc += Math.sin(1147) + Math.cos(1148) * 80;
+acc += Math.sin(1148) + Math.cos(1149) * 81;
+acc += Math.sin(1149) + Math.cos(1150) * 82;
+acc += Math.sin(1150) + Math.cos(1151) * 83;
+acc += Math.sin(1151) + Math.cos(1152) * 84;
+acc += Math.sin(1152) + Math.cos(1153) * 85;
+acc += Math.sin(1153) + Math.cos(1154) * 86;
+acc += Math.sin(1154) + Math.cos(1155) * 87;
+acc += Math.sin(1155) + Math.cos(1156) * 88;
+acc += Math.sin(1156) + Math.cos(1157) * 89;
+acc += Math.sin(1157) + Math.cos(1158) * 90;
+acc += Math.sin(1158) + Math.cos(1159) * 91;
+acc += Math.sin(1159) + Math.cos(1160) * 92;
+acc += Math.sin(1160) + Math.cos(1161) * 93;
+acc += Math.sin(1161) + Math.cos(1162) * 94;
+acc += Math.sin(1162) + Math.cos(1163) * 95;
+acc += Math.sin(1163) + Math.cos(1164) * 96;
+acc += Math.sin(1164) + Math.cos(1165) * 0;
+acc += Math.sin(1165) + Math.cos(1166) * 1;
+acc += Math.sin(1166) + Math.cos(1167) * 2;
+acc += Math.sin(1167) + Math.cos(1168) * 3;
+acc += Math.sin(1168) + Math.cos(1169) * 4;
+acc += Math.sin(1169) + Math.cos(1170) * 5;
+acc += Math.sin(1170) + Math.cos(1171) * 6;
+acc += Math.sin(1171) + Math.cos(1172) * 7;
+acc += Math.sin(1172) + Math.cos(1173) * 8;
+acc += Math.sin(1173) + Math.cos(1174) * 9;
+acc += Math.sin(1174) + Math.cos(1175) * 10;
+acc += Math.sin(1175) + Math.cos(1176) * 11;
+acc += Math.sin(1176) + Math.cos(1177) * 12;
+acc += Math.sin(1177) + Math.cos(1178) * 13;
+acc += Math.sin(1178) + Math.cos(1179) * 14;
+acc += Math.sin(1179) + Math.cos(1180) * 15;
+acc += Math.sin(1180) + Math.cos(1181) * 16;
+acc += Math.sin(1181) + Math.cos(1182) * 17;
+acc += Math.sin(1182) + Math.cos(1183) * 18;
+acc += Math.sin(1183) + Math.cos(1184) * 19;
+acc += Math.sin(1184) + Math.cos(1185) * 20;
+acc += Math.sin(1185) + Math.cos(1186) * 21;
+acc += Math.sin(1186) + Math.cos(1187) * 22;
+acc += Math.sin(1187) + Math.cos(1188) * 23;
+acc += Math.sin(1188) + Math.cos(1189) * 24;
+acc += Math.sin(1189) + Math.cos(1190) * 25;
+acc += Math.sin(1190) + Math.cos(1191) * 26;
+acc += Math.sin(1191) + Math.cos(1192) * 27;
+acc += Math.sin(1192) + Math.cos(1193) * 28;
+acc += Math.sin(1193) + Math.cos(1194) * 29;
+acc += Math.sin(1194) + Math.cos(1195) * 30;
+acc += Math.sin(1195) + Math.cos(1196) * 31;
+acc += Math.sin(1196) + Math.cos(1197) * 32;
+acc += Math.sin(1197) + Math.cos(1198) * 33;
+acc += Math.sin(1198) + Math.cos(1199) * 34;
+acc += Math.sin(1199) + Math.cos(1200) * 35;
+acc += Math.sin(1200) + Math.cos(1201) * 36;
+acc += Math.sin(1201) + Math.cos(1202) * 37;
+acc += Math.sin(1202) + Math.cos(1203) * 38;
+acc += Math.sin(1203) + Math.cos(1204) * 39;
+acc += Math.sin(1204) + Math.cos(1205) * 40;
+acc += Math.sin(1205) + Math.cos(1206) * 41;
+acc += Math.sin(1206) + Math.cos(1207) * 42;
+acc += Math.sin(1207) + Math.cos(1208) * 43;
+acc += Math.sin(1208) + Math.cos(1209) * 44;
+acc += Math.sin(1209) + Math.cos(1210) * 45;
+acc += Math.sin(1210) + Math.cos(1211) * 46;
+acc += Math.sin(1211) + Math.cos(1212) * 47;
+acc += Math.sin(1212) + Math.cos(1213) * 48;
+acc += Math.sin(1213) + Math.cos(1214) * 49;
+acc += Math.sin(1214) + Math.cos(1215) * 50;
+acc += Math.sin(1215) + Math.cos(1216) * 51;
+acc += Math.sin(1216) + Math.cos(1217) * 52;
+acc += Math.sin(1217) + Math.cos(1218) * 53;
+acc += Math.sin(1218) + Math.cos(1219) * 54;
+acc += Math.sin(1219) + Math.cos(1220) * 55;
+acc += Math.sin(1220) + Math.cos(1221) * 56;
+acc += Math.sin(1221) + Math.cos(1222) * 57;
+acc += Math.sin(1222) + Math.cos(1223) * 58;
+acc += Math.sin(1223) + Math.cos(1224) * 59;
+acc += Math.sin(1224) + Math.cos(1225) * 60;
+acc += Math.sin(1225) + Math.cos(1226) * 61;
+acc += Math.sin(1226) + Math.cos(1227) * 62;
+acc += Math.sin(1227) + Math.cos(1228) * 63;
+acc += Math.sin(1228) + Math.cos(1229) * 64;
+acc += Math.sin(1229) + Math.cos(1230) * 65;
+acc += Math.sin(1230) + Math.cos(1231) * 66;
+acc += Math.sin(1231) + Math.cos(1232) * 67;
+acc += Math.sin(1232) + Math.cos(1233) * 68;
+acc += Math.sin(1233) + Math.cos(1234) * 69;
+acc += Math.sin(1234) + Math.cos(1235) * 70;
+acc += Math.sin(1235) + Math.cos(1236) * 71;
+acc += Math.sin(1236) + Math.cos(1237) * 72;
+acc += Math.sin(1237) + Math.cos(1238) * 73;
+acc += Math.sin(1238) + Math.cos(1239) * 74;
+acc += Math.sin(1239) + Math.cos(1240) * 75;
+acc += Math.sin(1240) + Math.cos(1241) * 76;
+acc += Math.sin(1241) + Math.cos(1242) * 77;
+acc += Math.sin(1242) + Math.cos(1243) * 78;
+acc += Math.sin(1243) + Math.cos(1244) * 79;
+acc += Math.sin(1244) + Math.cos(1245) * 80;
+acc += Math.sin(1245) + Math.cos(1246) * 81;
+acc += Math.sin(1246) + Math.cos(1247) * 82;
+acc += Math.sin(1247) + Math.cos(1248) * 83;
+acc += Math.sin(1248) + Math.cos(1249) * 84;
+acc += Math.sin(1249) + Math.cos(1250) * 85;
+acc += Math.sin(1250) + Math.cos(1251) * 86;
+acc += Math.sin(1251) + Math.cos(1252) * 87;
+acc += Math.sin(1252) + Math.cos(1253) * 88;
+acc += Math.sin(1253) + Math.cos(1254) * 89;
+acc += Math.sin(1254) + Math.cos(1255) * 90;
+acc += Math.sin(1255) + Math.cos(1256) * 91;
+acc += Math.sin(1256) + Math.cos(1257) * 92;
+acc += Math.sin(1257) + Math.cos(1258) * 93;
+acc += Math.sin(1258) + Math.cos(1259) * 94;
+acc += Math.sin(1259) + Math.cos(1260) * 95;
+acc += Math.sin(1260) + Math.cos(1261) * 96;
+acc += Math.sin(1261) + Math.cos(1262) * 0;
+acc += Math.sin(1262) + Math.cos(1263) * 1;
+acc += Math.sin(1263) + Math.cos(1264) * 2;
+acc += Math.sin(1264) + Math.cos(1265) * 3;
+acc += Math.sin(1265) + Math.cos(1266) * 4;
+acc += Math.sin(1266) + Math.cos(1267) * 5;
+acc += Math.sin(1267) + Math.cos(1268) * 6;
+acc += Math.sin(1268) + Math.cos(1269) * 7;
+acc += Math.sin(1269) + Math.cos(1270) * 8;
+acc += Math.sin(1270) + Math.cos(1271) * 9;
+acc += Math.sin(1271) + Math.cos(1272) * 10;
+acc += Math.sin(1272) + Math.cos(1273) * 11;
+acc += Math.sin(1273) + Math.cos(1274) * 12;
+acc += Math.sin(1274) + Math.cos(1275) * 13;
+acc += Math.sin(1275) + Math.cos(1276) * 14;
+acc += Math.sin(1276) + Math.cos(1277) * 15;
+acc += Math.sin(1277) + Math.cos(1278) * 16;
+acc += Math.sin(1278) + Math.cos(1279) * 17;
+acc += Math.sin(1279) + Math.cos(1280) * 18;
+acc += Math.sin(1280) + Math.cos(1281) * 19;
+acc += Math.sin(1281) + Math.cos(1282) * 20;
+acc += Math.sin(1282) + Math.cos(1283) * 21;
+acc += Math.sin(1283) + Math.cos(1284) * 22;
+acc += Math.sin(1284) + Math.cos(1285) * 23;
+acc += Math.sin(1285) + Math.cos(1286) * 24;
+acc += Math.sin(1286) + Math.cos(1287) * 25;
+acc += Math.sin(1287) + Math.cos(1288) * 26;
+acc += Math.sin(1288) + Math.cos(1289) * 27;
+acc += Math.sin(1289) + Math.cos(1290) * 28;
+acc += Math.sin(1290) + Math.cos(1291) * 29;
+acc += Math.sin(1291) + Math.cos(1292) * 30;
+acc += Math.sin(1292) + Math.cos(1293) * 31;
+acc += Math.sin(1293) + Math.cos(1294) * 32;
+acc += Math.sin(1294) + Math.cos(1295) * 33;
+acc += Math.sin(1295) + Math.cos(1296) * 34;
+acc += Math.sin(1296) + Math.cos(1297) * 35;
+acc += Math.sin(1297) + Math.cos(1298) * 36;
+acc += Math.sin(1298) + Math.cos(1299) * 37;
+acc += Math.sin(1299) + Math.cos(1300) * 38;
+acc += Math.sin(1300) + Math.cos(1301) * 39;
+acc += Math.sin(1301) + Math.cos(1302) * 40;
+acc += Math.sin(1302) + Math.cos(1303) * 41;
+acc += Math.sin(1303) + Math.cos(1304) * 42;
+acc += Math.sin(1304) + Math.cos(1305) * 43;
+acc += Math.sin(1305) + Math.cos(1306) * 44;
+acc += Math.sin(1306) + Math.cos(1307) * 45;
+acc += Math.sin(1307) + Math.cos(1308) * 46;
+acc += Math.sin(1308) + Math.cos(1309) * 47;
+acc += Math.sin(1309) + Math.cos(1310) * 48;
+acc += Math.sin(1310) + Math.cos(1311) * 49;
+acc += Math.sin(1311) + Math.cos(1312) * 50;
+acc += Math.sin(1312) + Math.cos(1313) * 51;
+acc += Math.sin(1313) + Math.cos(1314) * 52;
+acc += Math.sin(1314) + Math.cos(1315) * 53;
+acc += Math.sin(1315) + Math.cos(1316) * 54;
+acc += Math.sin(1316) + Math.cos(1317) * 55;
+acc += Math.sin(1317) + Math.cos(1318) * 56;
+acc += Math.sin(1318) + Math.cos(1319) * 57;
+acc += Math.sin(1319) + Math.cos(1320) * 58;
+acc += Math.sin(1320) + Math.cos(1321) * 59;
+acc += Math.sin(1321) + Math.cos(1322) * 60;
+acc += Math.sin(1322) + Math.cos(1323) * 61;
+acc += Math.sin(1323) + Math.cos(1324) * 62;
+acc += Math.sin(1324) + Math.cos(1325) * 63;
+acc += Math.sin(1325) + Math.cos(1326) * 64;
+acc += Math.sin(1326) + Math.cos(1327) * 65;
+acc += Math.sin(1327) + Math.cos(1328) * 66;
+acc += Math.sin(1328) + Math.cos(1329) * 67;
+acc += Math.sin(1329) + Math.cos(1330) * 68;
+acc += Math.sin(1330) + Math.cos(1331) * 69;
+acc += Math.sin(1331) + Math.cos(1332) * 70;
+acc += Math.sin(1332) + Math.cos(1333) * 71;
+acc += Math.sin(1333) + Math.cos(1334) * 72;
+acc += Math.sin(1334) + Math.cos(1335) * 73;
+acc += Math.sin(1335) + Math.cos(1336) * 74;
+acc += Math.sin(1336) + Math.cos(1337) * 75;
+acc += Math.sin(1337) + Math.cos(1338) * 76;
+acc += Math.sin(1338) + Math.cos(1339) * 77;
+acc += Math.sin(1339) + Math.cos(1340) * 78;
+acc += Math.sin(1340) + Math.cos(1341) * 79;
+acc += Math.sin(1341) + Math.cos(1342) * 80;
+acc += Math.sin(1342) + Math.cos(1343) * 81;
+acc += Math.sin(1343) + Math.cos(1344) * 82;
+acc += Math.sin(1344) + Math.cos(1345) * 83;
+acc += Math.sin(1345) + Math.cos(1346) * 84;
+acc += Math.sin(1346) + Math.cos(1347) * 85;
+acc += Math.sin(1347) + Math.cos(1348) * 86;
+acc += Math.sin(1348) + Math.cos(1349) * 87;
+acc += Math.sin(1349) + Math.cos(1350) * 88;
+acc += Math.sin(1350) + Math.cos(1351) * 89;
+acc += Math.sin(1351) + Math.cos(1352) * 90;
+acc += Math.sin(1352) + Math.cos(1353) * 91;
+acc += Math.sin(1353) + Math.cos(1354) * 92;
+acc += Math.sin(1354) + Math.cos(1355) * 93;
+acc += Math.sin(1355) + Math.cos(1356) * 94;
+acc += Math.sin(1356) + Math.cos(1357) * 95;
+acc += Math.sin(1357) + Math.cos(1358) * 96;
+acc += Math.sin(1358) + Math.cos(1359) * 0;
+acc += Math.sin(1359) + Math.cos(1360) * 1;
+acc += Math.sin(1360) + Math.cos(1361) * 2;
+acc += Math.sin(1361) + Math.cos(1362) * 3;
+acc += Math.sin(1362) + Math.cos(1363) * 4;
+acc += Math.sin(1363) + Math.cos(1364) * 5;
+acc += Math.sin(1364) + Math.cos(1365) * 6;
+acc += Math.sin(1365) + Math.cos(1366) * 7;
+acc += Math.sin(1366) + Math.cos(1367) * 8;
+acc += Math.sin(1367) + Math.cos(1368) * 9;
+acc += Math.sin(1368) + Math.cos(1369) * 10;
+acc += Math.sin(1369) + Math.cos(1370) * 11;
+acc += Math.sin(1370) + Math.cos(1371) * 12;
+acc += Math.sin(1371) + Math.cos(1372) * 13;
+acc += Math.sin(1372) + Math.cos(1373) * 14;
+acc += Math.sin(1373) + Math.cos(1374) * 15;
+acc += Math.sin(1374) + Math.cos(1375) * 16;
+acc += Math.sin(1375) + Math.cos(1376) * 17;
+acc += Math.sin(1376) + Math.cos(1377) * 18;
+acc += Math.sin(1377) + Math.cos(1378) * 19;
+acc += Math.sin(1378) + Math.cos(1379) * 20;
+acc += Math.sin(1379) + Math.cos(1380) * 21;
+acc += Math.sin(1380) + Math.cos(1381) * 22;
+acc += Math.sin(1381) + Math.cos(1382) * 23;
+acc += Math.sin(1382) + Math.cos(1383) * 24;
+acc += Math.sin(1383) + Math.cos(1384) * 25;
+acc += Math.sin(1384) + Math.cos(1385) * 26;
+acc += Math.sin(1385) + Math.cos(1386) * 27;
+acc += Math.sin(1386) + Math.cos(1387) * 28;
+acc += Math.sin(1387) + Math.cos(1388) * 29;
+acc += Math.sin(1388) + Math.cos(1389) * 30;
+acc += Math.sin(1389) + Math.cos(1390) * 31;
+acc += Math.sin(1390) + Math.cos(1391) * 32;
+acc += Math.sin(1391) + Math.cos(1392) * 33;
+acc += Math.sin(1392) + Math.cos(1393) * 34;
+acc += Math.sin(1393) + Math.cos(1394) * 35;
+acc += Math.sin(1394) + Math.cos(1395) * 36;
+acc += Math.sin(1395) + Math.cos(1396) * 37;
+acc += Math.sin(1396) + Math.cos(1397) * 38;
+acc += Math.sin(1397) + Math.cos(1398) * 39;
+acc += Math.sin(1398) + Math.cos(1399) * 40;
+acc += Math.sin(1399) + Math.cos(1400) * 41;
+acc += Math.sin(1400) + Math.cos(1401) * 42;
+acc += Math.sin(1401) + Math.cos(1402) * 43;
+acc += Math.sin(1402) + Math.cos(1403) * 44;
+acc += Math.sin(1403) + Math.cos(1404) * 45;
+acc += Math.sin(1404) + Math.cos(1405) * 46;
+acc += Math.sin(1405) + Math.cos(1406) * 47;
+acc += Math.sin(1406) + Math.cos(1407) * 48;
+acc += Math.sin(1407) + Math.cos(1408) * 49;
+acc += Math.sin(1408) + Math.cos(1409) * 50;
+acc += Math.sin(1409) + Math.cos(1410) * 51;
+acc += Math.sin(1410) + Math.cos(1411) * 52;
+acc += Math.sin(1411) + Math.cos(1412) * 53;
+acc += Math.sin(1412) + Math.cos(1413) * 54;
+acc += Math.sin(1413) + Math.cos(1414) * 55;
+acc += Math.sin(1414) + Math.cos(1415) * 56;
+acc += Math.sin(1415) + Math.cos(1416) * 57;
+acc += Math.sin(1416) + Math.cos(1417) * 58;
+acc += Math.sin(1417) + Math.cos(1418) * 59;
+acc += Math.sin(1418) + Math.cos(1419) * 60;
+acc += Math.sin(1419) + Math.cos(1420) * 61;
+acc += Math.sin(1420) + Math.cos(1421) * 62;
+acc += Math.sin(1421) + Math.cos(1422) * 63;
+acc += Math.sin(1422) + Math.cos(1423) * 64;
+acc += Math.sin(1423) + Math.cos(1424) * 65;
+acc += Math.sin(1424) + Math.cos(1425) * 66;
+acc += Math.sin(1425) + Math.cos(1426) * 67;
+acc += Math.sin(1426) + Math.cos(1427) * 68;
+acc += Math.sin(1427) + Math.cos(1428) * 69;
+acc += Math.sin(1428) + Math.cos(1429) * 70;
+acc += Math.sin(1429) + Math.cos(1430) * 71;
+acc += Math.sin(1430) + Math.cos(1431) * 72;
+acc += Math.sin(1431) + Math.cos(1432) * 73;
+acc += Math.sin(1432) + Math.cos(1433) * 74;
+acc += Math.sin(1433) + Math.cos(1434) * 75;
+acc += Math.sin(1434) + Math.cos(1435) * 76;
+acc += Math.sin(1435) + Math.cos(1436) * 77;
+acc += Math.sin(1436) + Math.cos(1437) * 78;
+acc += Math.sin(1437) + Math.cos(1438) * 79;
+acc += Math.sin(1438) + Math.cos(1439) * 80;
+acc += Math.sin(1439) + Math.cos(1440) * 81;
+acc += Math.sin(1440) + Math.cos(1441) * 82;
+acc += Math.sin(1441) + Math.cos(1442) * 83;
+acc += Math.sin(1442) + Math.cos(1443) * 84;
+acc += Math.sin(1443) + Math.cos(1444) * 85;
+acc += Math.sin(1444) + Math.cos(1445) * 86;
+acc += Math.sin(1445) + Math.cos(1446) * 87;
+acc += Math.sin(1446) + Math.cos(1447) * 88;
+acc += Math.sin(1447) + Math.cos(1448) * 89;
+acc += Math.sin(1448) + Math.cos(1449) * 90;
+acc += Math.sin(1449) + Math.cos(1450) * 91;
+acc += Math.sin(1450) + Math.cos(1451) * 92;
+acc += Math.sin(1451) + Math.cos(1452) * 93;
+acc += Math.sin(1452) + Math.cos(1453) * 94;
+acc += Math.sin(1453) + Math.cos(1454) * 95;
+acc += Math.sin(1454) + Math.cos(1455) * 96;
+acc += Math.sin(1455) + Math.cos(1456) * 0;
+acc += Math.sin(1456) + Math.cos(1457) * 1;
+acc += Math.sin(1457) + Math.cos(1458) * 2;
+acc += Math.sin(1458) + Math.cos(1459) * 3;
+acc += Math.sin(1459) + Math.cos(1460) * 4;
+acc += Math.sin(1460) + Math.cos(1461) * 5;
+acc += Math.sin(1461) + Math.cos(1462) * 6;
+acc += Math.sin(1462) + Math.cos(1463) * 7;
+acc += Math.sin(1463) + Math.cos(1464) * 8;
+acc += Math.sin(1464) + Math.cos(1465) * 9;
+acc += Math.sin(1465) + Math.cos(1466) * 10;
+acc += Math.sin(1466) + Math.cos(1467) * 11;
+acc += Math.sin(1467) + Math.cos(1468) * 12;
+acc += Math.sin(1468) + Math.cos(1469) * 13;
+acc += Math.sin(1469) + Math.cos(1470) * 14;
+acc += Math.sin(1470) + Math.cos(1471) * 15;
+acc += Math.sin(1471) + Math.cos(1472) * 16;
+acc += Math.sin(1472) + Math.cos(1473) * 17;
+acc += Math.sin(1473) + Math.cos(1474) * 18;
+acc += Math.sin(1474) + Math.cos(1475) * 19;
+acc += Math.sin(1475) + Math.cos(1476) * 20;
+acc += Math.sin(1476) + Math.cos(1477) * 21;
+acc += Math.sin(1477) + Math.cos(1478) * 22;
+acc += Math.sin(1478) + Math.cos(1479) * 23;
+acc += Math.sin(1479) + Math.cos(1480) * 24;
+acc += Math.sin(1480) + Math.cos(1481) * 25;
+acc += Math.sin(1481) + Math.cos(1482) * 26;
+acc += Math.sin(1482) + Math.cos(1483) * 27;
+acc += Math.sin(1483) + Math.cos(1484) * 28;
+acc += Math.sin(1484) + Math.cos(1485) * 29;
+acc += Math.sin(1485) + Math.cos(1486) * 30;
+acc += Math.sin(1486) + Math.cos(1487) * 31;
+acc += Math.sin(1487) + Math.cos(1488) * 32;
+acc += Math.sin(1488) + Math.cos(1489) * 33;
+acc += Math.sin(1489) + Math.cos(1490) * 34;
+acc += Math.sin(1490) + Math.cos(1491) * 35;
+acc += Math.sin(1491) + Math.cos(1492) * 36;
+acc += Math.sin(1492) + Math.cos(1493) * 37;
+acc += Math.sin(1493) + Math.cos(1494) * 38;
+acc += Math.sin(1494) + Math.cos(1495) * 39;
+acc += Math.sin(1495) + Math.cos(1496) * 40;
+acc += Math.sin(1496) + Math.cos(1497) * 41;
+acc += Math.sin(1497) + Math.cos(1498) * 42;
+acc += Math.sin(1498) + Math.cos(1499) * 43;
+acc += Math.sin(1499) + Math.cos(1500) * 44;
+acc += Math.sin(1500) + Math.cos(1501) * 45;
+acc += Math.sin(1501) + Math.cos(1502) * 46;
+acc += Math.sin(1502) + Math.cos(1503) * 47;
+acc += Math.sin(1503) + Math.cos(1504) * 48;
+acc += Math.sin(1504) + Math.cos(1505) * 49;
+acc += Math.sin(1505) + Math.cos(1506) * 50;
+acc += Math.sin(1506) + Math.cos(1507) * 51;
+acc += Math.sin(1507) + Math.cos(1508) * 52;
+acc += Math.sin(1508) + Math.cos(1509) * 53;
+acc += Math.sin(1509) + Math.cos(1510) * 54;
+acc += Math.sin(1510) + Math.cos(1511) * 55;
+acc += Math.sin(1511) + Math.cos(1512) * 56;
+acc += Math.sin(1512) + Math.cos(1513) * 57;
+acc += Math.sin(1513) + Math.cos(1514) * 58;
+acc += Math.sin(1514) + Math.cos(1515) * 59;
+acc += Math.sin(1515) + Math.cos(1516) * 60;
+acc += Math.sin(1516) + Math.cos(1517) * 61;
+acc += Math.sin(1517) + Math.cos(1518) * 62;
+acc += Math.sin(1518) + Math.cos(1519) * 63;
+acc += Math.sin(1519) + Math.cos(1520) * 64;
+acc += Math.sin(1520) + Math.cos(1521) * 65;
+acc += Math.sin(1521) + Math.cos(1522) * 66;
+acc += Math.sin(1522) + Math.cos(1523) * 67;
+acc += Math.sin(1523) + Math.cos(1524) * 68;
+acc += Math.sin(1524) + Math.cos(1525) * 69;
+acc += Math.sin(1525) + Math.cos(1526) * 70;
+acc += Math.sin(1526) + Math.cos(1527) * 71;
+acc += Math.sin(1527) + Math.cos(1528) * 72;
+acc += Math.sin(1528) + Math.cos(1529) * 73;
+acc += Math.sin(1529) + Math.cos(1530) * 74;
+acc += Math.sin(1530) + Math.cos(1531) * 75;
+acc += Math.sin(1531) + Math.cos(1532) * 76;
+acc += Math.sin(1532) + Math.cos(1533) * 77;
+acc += Math.sin(1533) + Math.cos(1534) * 78;
+acc += Math.sin(1534) + Math.cos(1535) * 79;
+acc += Math.sin(1535) + Math.cos(1536) * 80;
+acc += Math.sin(1536) + Math.cos(1537) * 81;
+acc += Math.sin(1537) + Math.cos(1538) * 82;
+acc += Math.sin(1538) + Math.cos(1539) * 83;
+acc += Math.sin(1539) + Math.cos(1540) * 84;
+acc += Math.sin(1540) + Math.cos(1541) * 85;
+acc += Math.sin(1541) + Math.cos(1542) * 86;
+acc += Math.sin(1542) + Math.cos(1543) * 87;
+acc += Math.sin(1543) + Math.cos(1544) * 88;
+acc += Math.sin(1544) + Math.cos(1545) * 89;
+acc += Math.sin(1545) + Math.cos(1546) * 90;
+acc += Math.sin(1546) + Math.cos(1547) * 91;
+acc += Math.sin(1547) + Math.cos(1548) * 92;
+acc += Math.sin(1548) + Math.cos(1549) * 93;
+acc += Math.sin(1549) + Math.cos(1550) * 94;
+acc += Math.sin(1550) + Math.cos(1551) * 95;
+acc += Math.sin(1551) + Math.cos(1552) * 96;
+acc += Math.sin(1552) + Math.cos(1553) * 0;
+acc += Math.sin(1553) + Math.cos(1554) * 1;
+acc += Math.sin(1554) + Math.cos(1555) * 2;
+acc += Math.sin(1555) + Math.cos(1556) * 3;
+acc += Math.sin(1556) + Math.cos(1557) * 4;
+acc += Math.sin(1557) + Math.cos(1558) * 5;
+acc += Math.sin(1558) + Math.cos(1559) * 6;
+acc += Math.sin(1559) + Math.cos(1560) * 7;
+acc += Math.sin(1560) + Math.cos(1561) * 8;
+acc += Math.sin(1561) + Math.cos(1562) * 9;
+acc += Math.sin(1562) + Math.cos(1563) * 10;
+acc += Math.sin(1563) + Math.cos(1564) * 11;
+acc += Math.sin(1564) + Math.cos(1565) * 12;
+acc += Math.sin(1565) + Math.cos(1566) * 13;
+acc += Math.sin(1566) + Math.cos(1567) * 14;
+acc += Math.sin(1567) + Math.cos(1568) * 15;
+acc += Math.sin(1568) + Math.cos(1569) * 16;
+acc += Math.sin(1569) + Math.cos(1570) * 17;
+acc += Math.sin(1570) + Math.cos(1571) * 18;
+acc += Math.sin(1571) + Math.cos(1572) * 19;
+acc += Math.sin(1572) + Math.cos(1573) * 20;
+acc += Math.sin(1573) + Math.cos(1574) * 21;
+acc += Math.sin(1574) + Math.cos(1575) * 22;
+acc += Math.sin(1575) + Math.cos(1576) * 23;
+acc += Math.sin(1576) + Math.cos(1577) * 24;
+acc += Math.sin(1577) + Math.cos(1578) * 25;
+acc += Math.sin(1578) + Math.cos(1579) * 26;
+acc += Math.sin(1579) + Math.cos(1580) * 27;
+acc += Math.sin(1580) + Math.cos(1581) * 28;
+acc += Math.sin(1581) + Math.cos(1582) * 29;
+acc += Math.sin(1582) + Math.cos(1583) * 30;
+acc += Math.sin(1583) + Math.cos(1584) * 31;
+acc += Math.sin(1584) + Math.cos(1585) * 32;
+acc += Math.sin(1585) + Math.cos(1586) * 33;
+acc += Math.sin(1586) + Math.cos(1587) * 34;
+acc += Math.sin(1587) + Math.cos(1588) * 35;
+acc += Math.sin(1588) + Math.cos(1589) * 36;
+acc += Math.sin(1589) + Math.cos(1590) * 37;
+acc += Math.sin(1590) + Math.cos(1591) * 38;
+acc += Math.sin(1591) + Math.cos(1592) * 39;
+acc += Math.sin(1592) + Math.cos(1593) * 40;
+acc += Math.sin(1593) + Math.cos(1594) * 41;
+acc += Math.sin(1594) + Math.cos(1595) * 42;
+acc += Math.sin(1595) + Math.cos(1596) * 43;
+acc += Math.sin(1596) + Math.cos(1597) * 44;
+acc += Math.sin(1597) + Math.cos(1598) * 45;
+acc += Math.sin(1598) + Math.cos(1599) * 46;
+acc += Math.sin(1599) + Math.cos(1600) * 47;
+acc += Math.sin(1600) + Math.cos(1601) * 48;
+acc += Math.sin(1601) + Math.cos(1602) * 49;
+acc += Math.sin(1602) + Math.cos(1603) * 50;
+acc += Math.sin(1603) + Math.cos(1604) * 51;
+acc += Math.sin(1604) + Math.cos(1605) * 52;
+acc += Math.sin(1605) + Math.cos(1606) * 53;
+acc += Math.sin(1606) + Math.cos(1607) * 54;
+acc += Math.sin(1607) + Math.cos(1608) * 55;
+acc += Math.sin(1608) + Math.cos(1609) * 56;
+acc += Math.sin(1609) + Math.cos(1610) * 57;
+acc += Math.sin(1610) + Math.cos(1611) * 58;
+acc += Math.sin(1611) + Math.cos(1612) * 59;
+acc += Math.sin(1612) + Math.cos(1613) * 60;
+acc += Math.sin(1613) + Math.cos(1614) * 61;
+acc += Math.sin(1614) + Math.cos(1615) * 62;
+acc += Math.sin(1615) + Math.cos(1616) * 63;
+acc += Math.sin(1616) + Math.cos(1617) * 64;
+acc += Math.sin(1617) + Math.cos(1618) * 65;
+acc += Math.sin(1618) + Math.cos(1619) * 66;
+acc += Math.sin(1619) + Math.cos(1620) * 67;
+acc += Math.sin(1620) + Math.cos(1621) * 68;
+acc += Math.sin(1621) + Math.cos(1622) * 69;
+acc += Math.sin(1622) + Math.cos(1623) * 70;
+acc += Math.sin(1623) + Math.cos(1624) * 71;
+acc += Math.sin(1624) + Math.cos(1625) * 72;
+acc += Math.sin(1625) + Math.cos(1626) * 73;
+acc += Math.sin(1626) + Math.cos(1627) * 74;
+acc += Math.sin(1627) + Math.cos(1628) * 75;
+acc += Math.sin(1628) + Math.cos(1629) * 76;
+acc += Math.sin(1629) + Math.cos(1630) * 77;
+acc += Math.sin(1630) + Math.cos(1631) * 78;
+acc += Math.sin(1631) + Math.cos(1632) * 79;
+acc += Math.sin(1632) + Math.cos(1633) * 80;
+acc += Math.sin(1633) + Math.cos(1634) * 81;
+acc += Math.sin(1634) + Math.cos(1635) * 82;
+acc += Math.sin(1635) + Math.cos(1636) * 83;
+acc += Math.sin(1636) + Math.cos(1637) * 84;
+acc += Math.sin(1637) + Math.cos(1638) * 85;
+acc += Math.sin(1638) + Math.cos(1639) * 86;
+acc += Math.sin(1639) + Math.cos(1640) * 87;
+acc += Math.sin(1640) + Math.cos(1641) * 88;
+acc += Math.sin(1641) + Math.cos(1642) * 89;
+acc += Math.sin(1642) + Math.cos(1643) * 90;
+acc += Math.sin(1643) + Math.cos(1644) * 91;
+acc += Math.sin(1644) + Math.cos(1645) * 92;
+acc += Math.sin(1645) + Math.cos(1646) * 93;
+acc += Math.sin(1646) + Math.cos(1647) * 94;
+acc += Math.sin(1647) + Math.cos(1648) * 95;
+acc += Math.sin(1648) + Math.cos(1649) * 96;
+acc += Math.sin(1649) + Math.cos(1650) * 0;
+acc += Math.sin(1650) + Math.cos(1651) * 1;
+acc += Math.sin(1651) + Math.cos(1652) * 2;
+acc += Math.sin(1652) + Math.cos(1653) * 3;
+acc += Math.sin(1653) + Math.cos(1654) * 4;
+acc += Math.sin(1654) + Math.cos(1655) * 5;
+acc += Math.sin(1655) + Math.cos(1656) * 6;
+acc += Math.sin(1656) + Math.cos(1657) * 7;
+acc += Math.sin(1657) + Math.cos(1658) * 8;
+acc += Math.sin(1658) + Math.cos(1659) * 9;
+acc += Math.sin(1659) + Math.cos(1660) * 10;
+acc += Math.sin(1660) + Math.cos(1661) * 11;
+acc += Math.sin(1661) + Math.cos(1662) * 12;
+acc += Math.sin(1662) + Math.cos(1663) * 13;
+acc += Math.sin(1663) + Math.cos(1664) * 14;
+acc += Math.sin(1664) + Math.cos(1665) * 15;
+acc += Math.sin(1665) + Math.cos(1666) * 16;
+acc += Math.sin(1666) + Math.cos(1667) * 17;
+acc += Math.sin(1667) + Math.cos(1668) * 18;
+acc += Math.sin(1668) + Math.cos(1669) * 19;
+acc += Math.sin(1669) + Math.cos(1670) * 20;
+acc += Math.sin(1670) + Math.cos(1671) * 21;
+acc += Math.sin(1671) + Math.cos(1672) * 22;
+acc += Math.sin(1672) + Math.cos(1673) * 23;
+acc += Math.sin(1673) + Math.cos(1674) * 24;
+acc += Math.sin(1674) + Math.cos(1675) * 25;
+acc += Math.sin(1675) + Math.cos(1676) * 26;
+acc += Math.sin(1676) + Math.cos(1677) * 27;
+acc += Math.sin(1677) + Math.cos(1678) * 28;
+acc += Math.sin(1678) + Math.cos(1679) * 29;
+acc += Math.sin(1679) + Math.cos(1680) * 30;
+acc += Math.sin(1680) + Math.cos(1681) * 31;
+acc += Math.sin(1681) + Math.cos(1682) * 32;
+acc += Math.sin(1682) + Math.cos(1683) * 33;
+acc += Math.sin(1683) + Math.cos(1684) * 34;
+acc += Math.sin(1684) + Math.cos(1685) * 35;
+acc += Math.sin(1685) + Math.cos(1686) * 36;
+acc += Math.sin(1686) + Math.cos(1687) * 37;
+acc += Math.sin(1687) + Math.cos(1688) * 38;
+acc += Math.sin(1688) + Math.cos(1689) * 39;
+acc += Math.sin(1689) + Math.cos(1690) * 40;
+acc += Math.sin(1690) + Math.cos(1691) * 41;
+acc += Math.sin(1691) + Math.cos(1692) * 42;
+acc += Math.sin(1692) + Math.cos(1693) * 43;
+acc += Math.sin(1693) + Math.cos(1694) * 44;
+acc += Math.sin(1694) + Math.cos(1695) * 45;
+acc += Math.sin(1695) + Math.cos(1696) * 46;
+acc += Math.sin(1696) + Math.cos(1697) * 47;
+acc += Math.sin(1697) + Math.cos(1698) * 48;
+acc += Math.sin(1698) + Math.cos(1699) * 49;
+acc += Math.sin(1699) + Math.cos(1700) * 50;
+acc += Math.sin(1700) + Math.cos(1701) * 51;
+acc += Math.sin(1701) + Math.cos(1702) * 52;
+acc += Math.sin(1702) + Math.cos(1703) * 53;
+acc += Math.sin(1703) + Math.cos(1704) * 54;
+acc += Math.sin(1704) + Math.cos(1705) * 55;
+acc += Math.sin(1705) + Math.cos(1706) * 56;
+acc += Math.sin(1706) + Math.cos(1707) * 57;
+acc += Math.sin(1707) + Math.cos(1708) * 58;
+acc += Math.sin(1708) + Math.cos(1709) * 59;
+acc += Math.sin(1709) + Math.cos(1710) * 60;
+acc += Math.sin(1710) + Math.cos(1711) * 61;
+acc += Math.sin(1711) + Math.cos(1712) * 62;
+acc += Math.sin(1712) + Math.cos(1713) * 63;
+acc += Math.sin(1713) + Math.cos(1714) * 64;
+acc += Math.sin(1714) + Math.cos(1715) * 65;
+acc += Math.sin(1715) + Math.cos(1716) * 66;
+acc += Math.sin(1716) + Math.cos(1717) * 67;
+acc += Math.sin(1717) + Math.cos(1718) * 68;
+acc += Math.sin(1718) + Math.cos(1719) * 69;
+acc += Math.sin(1719) + Math.cos(1720) * 70;
+acc += Math.sin(1720) + Math.cos(1721) * 71;
+acc += Math.sin(1721) + Math.cos(1722) * 72;
+acc += Math.sin(1722) + Math.cos(1723) * 73;
+acc += Math.sin(1723) + Math.cos(1724) * 74;
+acc += Math.sin(1724) + Math.cos(1725) * 75;
+acc += Math.sin(1725) + Math.cos(1726) * 76;
+acc += Math.sin(1726) + Math.cos(1727) * 77;
+acc += Math.sin(1727) + Math.cos(1728) * 78;
+acc += Math.sin(1728) + Math.cos(1729) * 79;
+acc += Math.sin(1729) + Math.cos(1730) * 80;
+acc += Math.sin(1730) + Math.cos(1731) * 81;
+acc += Math.sin(1731) + Math.cos(1732) * 82;
+acc += Math.sin(1732) + Math.cos(1733) * 83;
+acc += Math.sin(1733) + Math.cos(1734) * 84;
+acc += Math.sin(1734) + Math.cos(1735) * 85;
+acc += Math.sin(1735) + Math.cos(1736) * 86;
+acc += Math.sin(1736) + Math.cos(1737) * 87;
+acc += Math.sin(1737) + Math.cos(1738) * 88;
+acc += Math.sin(1738) + Math.cos(1739) * 89;
+acc += Math.sin(1739) + Math.cos(1740) * 90;
+acc += Math.sin(1740) + Math.cos(1741) * 91;
+acc += Math.sin(1741) + Math.cos(1742) * 92;
+acc += Math.sin(1742) + Math.cos(1743) * 93;
+acc += Math.sin(1743) + Math.cos(1744) * 94;
+acc += Math.sin(1744) + Math.cos(1745) * 95;
+acc += Math.sin(1745) + Math.cos(1746) * 96;
+acc += Math.sin(1746) + Math.cos(1747) * 0;
+acc += Math.sin(1747) + Math.cos(1748) * 1;
+acc += Math.sin(1748) + Math.cos(1749) * 2;
+acc += Math.sin(1749) + Math.cos(1750) * 3;
+acc += Math.sin(1750) + Math.cos(1751) * 4;
+acc += Math.sin(1751) + Math.cos(1752) * 5;
+acc += Math.sin(1752) + Math.cos(1753) * 6;
+acc += Math.sin(1753) + Math.cos(1754) * 7;
+acc += Math.sin(1754) + Math.cos(1755) * 8;
+acc += Math.sin(1755) + Math.cos(1756) * 9;
+acc += Math.sin(1756) + Math.cos(1757) * 10;
+acc += Math.sin(1757) + Math.cos(1758) * 11;
+acc += Math.sin(1758) + Math.cos(1759) * 12;
+acc += Math.sin(1759) + Math.cos(1760) * 13;
+acc += Math.sin(1760) + Math.cos(1761) * 14;
+acc += Math.sin(1761) + Math.cos(1762) * 15;
+acc += Math.sin(1762) + Math.cos(1763) * 16;
+acc += Math.sin(1763) + Math.cos(1764) * 17;
+acc += Math.sin(1764) + Math.cos(1765) * 18;
+acc += Math.sin(1765) + Math.cos(1766) * 19;
+acc += Math.sin(1766) + Math.cos(1767) * 20;
+acc += Math.sin(1767) + Math.cos(1768) * 21;
+acc += Math.sin(1768) + Math.cos(1769) * 22;
+acc += Math.sin(1769) + Math.cos(1770) * 23;
+acc += Math.sin(1770) + Math.cos(1771) * 24;
+acc += Math.sin(1771) + Math.cos(1772) * 25;
+acc += Math.sin(1772) + Math.cos(1773) * 26;
+acc += Math.sin(1773) + Math.cos(1774) * 27;
+acc += Math.sin(1774) + Math.cos(1775) * 28;
+acc += Math.sin(1775) + Math.cos(1776) * 29;
+acc += Math.sin(1776) + Math.cos(1777) * 30;
+acc += Math.sin(1777) + Math.cos(1778) * 31;
+acc += Math.sin(1778) + Math.cos(1779) * 32;
+acc += Math.sin(1779) + Math.cos(1780) * 33;
+acc += Math.sin(1780) + Math.cos(1781) * 34;
+acc += Math.sin(1781) + Math.cos(1782) * 35;
+acc += Math.sin(1782) + Math.cos(1783) * 36;
+acc += Math.sin(1783) + Math.cos(1784) * 37;
+acc += Math.sin(1784) + Math.cos(1785) * 38;
+acc += Math.sin(1785) + Math.cos(1786) * 39;
+acc += Math.sin(1786) + Math.cos(1787) * 40;
+acc += Math.sin(1787) + Math.cos(1788) * 41;
+acc += Math.sin(1788) + Math.cos(1789) * 42;
+acc += Math.sin(1789) + Math.cos(1790) * 43;
+acc += Math.sin(1790) + Math.cos(1791) * 44;
+acc += Math.sin(1791) + Math.cos(1792) * 45;
+acc += Math.sin(1792) + Math.cos(1793) * 46;
+acc += Math.sin(1793) + Math.cos(1794) * 47;
+acc += Math.sin(1794) + Math.cos(1795) * 48;
+acc += Math.sin(1795) + Math.cos(1796) * 49;
+acc += Math.sin(1796) + Math.cos(1797) * 50;
+acc += Math.sin(1797) + Math.cos(1798) * 51;
+acc += Math.sin(1798) + Math.cos(1799) * 52;
+acc += Math.sin(1799) + Math.cos(1800) * 53;
+acc += Math.sin(1800) + Math.cos(1801) * 54;
+acc += Math.sin(1801) + Math.cos(1802) * 55;
+acc += Math.sin(1802) + Math.cos(1803) * 56;
+acc += Math.sin(1803) + Math.cos(1804) * 57;
+acc += Math.sin(1804) + Math.cos(1805) * 58;
+acc += Math.sin(1805) + Math.cos(1806) * 59;
+acc += Math.sin(1806) + Math.cos(1807) * 60;
+acc += Math.sin(1807) + Math.cos(1808) * 61;
+acc += Math.sin(1808) + Math.cos(1809) * 62;
+acc += Math.sin(1809) + Math.cos(1810) * 63;
+acc += Math.sin(1810) + Math.cos(1811) * 64;
+acc += Math.sin(1811) + Math.cos(1812) * 65;
+acc += Math.sin(1812) + Math.cos(1813) * 66;
+acc += Math.sin(1813) + Math.cos(1814) * 67;
+acc += Math.sin(1814) + Math.cos(1815) * 68;
+acc += Math.sin(1815) + Math.cos(1816) * 69;
+acc += Math.sin(1816) + Math.cos(1817) * 70;
+acc += Math.sin(1817) + Math.cos(1818) * 71;
+acc += Math.sin(1818) + Math.cos(1819) * 72;
+acc += Math.sin(1819) + Math.cos(1820) * 73;
+acc += Math.sin(1820) + Math.cos(1821) * 74;
+acc += Math.sin(1821) + Math.cos(1822) * 75;
+acc += Math.sin(1822) + Math.cos(1823) * 76;
+acc += Math.sin(1823) + Math.cos(1824) * 77;
+acc += Math.sin(1824) + Math.cos(1825) * 78;
+acc += Math.sin(1825) + Math.cos(1826) * 79;
+acc += Math.sin(1826) + Math.cos(1827) * 80;
+acc += Math.sin(1827) + Math.cos(1828) * 81;
+acc += Math.sin(1828) + Math.cos(1829) * 82;
+acc += Math.sin(1829) + Math.cos(1830) * 83;
+acc += Math.sin(1830) + Math.cos(1831) * 84;
+acc += Math.sin(1831) + Math.cos(1832) * 85;
+acc += Math.sin(1832) + Math.cos(1833) * 86;
+acc += Math.sin(1833) + Math.cos(1834) * 87;
+acc += Math.sin(1834) + Math.cos(1835) * 88;
+acc += Math.sin(1835) + Math.cos(1836) * 89;
+acc += Math.sin(1836) + Math.cos(1837) * 90;
+acc += Math.sin(1837) + Math.cos(1838) * 91;
+acc += Math.sin(1838) + Math.cos(1839) * 92;
+acc += Math.sin(1839) + Math.cos(1840) * 93;
+acc += Math.sin(1840) + Math.cos(1841) * 94;
+acc += Math.sin(1841) + Math.cos(1842) * 95;
+acc += Math.sin(1842) + Math.cos(1843) * 96;
+acc += Math.sin(1843) + Math.cos(1844) * 0;
+acc += Math.sin(1844) + Math.cos(1845) * 1;
+acc += Math.sin(1845) + Math.cos(1846) * 2;
+acc += Math.sin(1846) + Math.cos(1847) * 3;
+acc += Math.sin(1847) + Math.cos(1848) * 4;
+acc += Math.sin(1848) + Math.cos(1849) * 5;
+acc += Math.sin(1849) + Math.cos(1850) * 6;
+acc += Math.sin(1850) + Math.cos(1851) * 7;
+acc += Math.sin(1851) + Math.cos(1852) * 8;
+acc += Math.sin(1852) + Math.cos(1853) * 9;
+acc += Math.sin(1853) + Math.cos(1854) * 10;
+acc += Math.sin(1854) + Math.cos(1855) * 11;
+acc += Math.sin(1855) + Math.cos(1856) * 12;
+acc += Math.sin(1856) + Math.cos(1857) * 13;
+acc += Math.sin(1857) + Math.cos(1858) * 14;
+acc += Math.sin(1858) + Math.cos(1859) * 15;
+acc += Math.sin(1859) + Math.cos(1860) * 16;
+acc += Math.sin(1860) + Math.cos(1861) * 17;
+acc += Math.sin(1861) + Math.cos(1862) * 18;
+acc += Math.sin(1862) + Math.cos(1863) * 19;
+acc += Math.sin(1863) + Math.cos(1864) * 20;
+acc += Math.sin(1864) + Math.cos(1865) * 21;
+acc += Math.sin(1865) + Math.cos(1866) * 22;
+acc += Math.sin(1866) + Math.cos(1867) * 23;
+acc += Math.sin(1867) + Math.cos(1868) * 24;
+acc += Math.sin(1868) + Math.cos(1869) * 25;
+acc += Math.sin(1869) + Math.cos(1870) * 26;
+acc += Math.sin(1870) + Math.cos(1871) * 27;
+acc += Math.sin(1871) + Math.cos(1872) * 28;
+acc += Math.sin(1872) + Math.cos(1873) * 29;
+acc += Math.sin(1873) + Math.cos(1874) * 30;
+acc += Math.sin(1874) + Math.cos(1875) * 31;
+acc += Math.sin(1875) + Math.cos(1876) * 32;
+acc += Math.sin(1876) + Math.cos(1877) * 33;
+acc += Math.sin(1877) + Math.cos(1878) * 34;
+acc += Math.sin(1878) + Math.cos(1879) * 35;
+acc += Math.sin(1879) + Math.cos(1880) * 36;
+acc += Math.sin(1880) + Math.cos(1881) * 37;
+acc += Math.sin(1881) + Math.cos(1882) * 38;
+acc += Math.sin(1882) + Math.cos(1883) * 39;
+acc += Math.sin(1883) + Math.cos(1884) * 40;
+acc += Math.sin(1884) + Math.cos(1885) * 41;
+acc += Math.sin(1885) + Math.cos(1886) * 42;
+acc += Math.sin(1886) + Math.cos(1887) * 43;
+acc += Math.sin(1887) + Math.cos(1888) * 44;
+acc += Math.sin(1888) + Math.cos(1889) * 45;
+acc += Math.sin(1889) + Math.cos(1890) * 46;
+acc += Math.sin(1890) + Math.cos(1891) * 47;
+acc += Math.sin(1891) + Math.cos(1892) * 48;
+acc += Math.sin(1892) + Math.cos(1893) * 49;
+acc += Math.sin(1893) + Math.cos(1894) * 50;
+acc += Math.sin(1894) + Math.cos(1895) * 51;
+acc += Math.sin(1895) + Math.cos(1896) * 52;
+acc += Math.sin(1896) + Math.cos(1897) * 53;
+acc += Math.sin(1897) + Math.cos(1898) * 54;
+acc += Math.sin(1898) + Math.cos(1899) * 55;
+acc += Math.sin(1899) + Math.cos(1900) * 56;
+acc += Math.sin(1900) + Math.cos(1901) * 57;
+acc += Math.sin(1901) + Math.cos(1902) * 58;
+acc += Math.sin(1902) + Math.cos(1903) * 59;
+acc += Math.sin(1903) + Math.cos(1904) * 60;
+acc += Math.sin(1904) + Math.cos(1905) * 61;
+acc += Math.sin(1905) + Math.cos(1906) * 62;
+acc += Math.sin(1906) + Math.cos(1907) * 63;
+acc += Math.sin(1907) + Math.cos(1908) * 64;
+acc += Math.sin(1908) + Math.cos(1909) * 65;
+acc += Math.sin(1909) + Math.cos(1910) * 66;
+acc += Math.sin(1910) + Math.cos(1911) * 67;
+acc += Math.sin(1911) + Math.cos(1912) * 68;
+acc += Math.sin(1912) + Math.cos(1913) * 69;
+acc += Math.sin(1913) + Math.cos(1914) * 70;
+acc += Math.sin(1914) + Math.cos(1915) * 71;
+acc += Math.sin(1915) + Math.cos(1916) * 72;
+acc += Math.sin(1916) + Math.cos(1917) * 73;
+acc += Math.sin(1917) + Math.cos(1918) * 74;
+acc += Math.sin(1918) + Math.cos(1919) * 75;
+acc += Math.sin(1919) + Math.cos(1920) * 76;
+acc += Math.sin(1920) + Math.cos(1921) * 77;
+acc += Math.sin(1921) + Math.cos(1922) * 78;
+acc += Math.sin(1922) + Math.cos(1923) * 79;
+acc += Math.sin(1923) + Math.cos(1924) * 80;
+acc += Math.sin(1924) + Math.cos(1925) * 81;
+acc += Math.sin(1925) + Math.cos(1926) * 82;
+acc += Math.sin(1926) + Math.cos(1927) * 83;
+acc += Math.sin(1927) + Math.cos(1928) * 84;
+acc += Math.sin(1928) + Math.cos(1929) * 85;
+acc += Math.sin(1929) + Math.cos(1930) * 86;
+acc += Math.sin(1930) + Math.cos(1931) * 87;
+acc += Math.sin(1931) + Math.cos(1932) * 88;
+acc += Math.sin(1932) + Math.cos(1933) * 89;
+acc += Math.sin(1933) + Math.cos(1934) * 90;
+acc += Math.sin(1934) + Math.cos(1935) * 91;
+acc += Math.sin(1935) + Math.cos(1936) * 92;
+acc += Math.sin(1936) + Math.cos(1937) * 93;
+acc += Math.sin(1937) + Math.cos(1938) * 94;
+acc += Math.sin(1938) + Math.cos(1939) * 95;
+acc += Math.sin(1939) + Math.cos(1940) * 96;
+acc += Math.sin(1940) + Math.cos(1941) * 0;
+acc += Math.sin(1941) + Math.cos(1942) * 1;
+acc += Math.sin(1942) + Math.cos(1943) * 2;
+acc += Math.sin(1943) + Math.cos(1944) * 3;
+acc += Math.sin(1944) + Math.cos(1945) * 4;
+acc += Math.sin(1945) + Math.cos(1946) * 5;
+acc += Math.sin(1946) + Math.cos(1947) * 6;
+acc += Math.sin(1947) + Math.cos(1948) * 7;
+acc += Math.sin(1948) + Math.cos(1949) * 8;
+acc += Math.sin(1949) + Math.cos(1950) * 9;
+acc += Math.sin(1950) + Math.cos(1951) * 10;
+acc += Math.sin(1951) + Math.cos(1952) * 11;
+acc += Math.sin(1952) + Math.cos(1953) * 12;
+acc += Math.sin(1953) + Math.cos(1954) * 13;
+acc += Math.sin(1954) + Math.cos(1955) * 14;
+acc += Math.sin(1955) + Math.cos(1956) * 15;
+acc += Math.sin(1956) + Math.cos(1957) * 16;
+acc += Math.sin(1957) + Math.cos(1958) * 17;
+acc += Math.sin(1958) + Math.cos(1959) * 18;
+acc += Math.sin(1959) + Math.cos(1960) * 19;
+acc += Math.sin(1960) + Math.cos(1961) * 20;
+acc += Math.sin(1961) + Math.cos(1962) * 21;
+acc += Math.sin(1962) + Math.cos(1963) * 22;
+acc += Math.sin(1963) + Math.cos(1964) * 23;
+acc += Math.sin(1964) + Math.cos(1965) * 24;
+acc += Math.sin(1965) + Math.cos(1966) * 25;
+acc += Math.sin(1966) + Math.cos(1967) * 26;
+acc += Math.sin(1967) + Math.cos(1968) * 27;
+acc += Math.sin(1968) + Math.cos(1969) * 28;
+acc += Math.sin(1969) + Math.cos(1970) * 29;
+acc += Math.sin(1970) + Math.cos(1971) * 30;
+acc += Math.sin(1971) + Math.cos(1972) * 31;
+acc += Math.sin(1972) + Math.cos(1973) * 32;
+acc += Math.sin(1973) + Math.cos(1974) * 33;
+acc += Math.sin(1974) + Math.cos(1975) * 34;
+acc += Math.sin(1975) + Math.cos(1976) * 35;
+acc += Math.sin(1976) + Math.cos(1977) * 36;
+acc += Math.sin(1977) + Math.cos(1978) * 37;
+acc += Math.sin(1978) + Math.cos(1979) * 38;
+acc += Math.sin(1979) + Math.cos(1980) * 39;
+acc += Math.sin(1980) + Math.cos(1981) * 40;
+acc += Math.sin(1981) + Math.cos(1982) * 41;
+acc += Math.sin(1982) + Math.cos(1983) * 42;
+acc += Math.sin(1983) + Math.cos(1984) * 43;
+acc += Math.sin(1984) + Math.cos(1985) * 44;
+acc += Math.sin(1985) + Math.cos(1986) * 45;
+acc += Math.sin(1986) + Math.cos(1987) * 46;
+acc += Math.sin(1987) + Math.cos(1988) * 47;
+acc += Math.sin(1988) + Math.cos(1989) * 48;
+acc += Math.sin(1989) + Math.cos(1990) * 49;
+acc += Math.sin(1990) + Math.cos(1991) * 50;
+acc += Math.sin(1991) + Math.cos(1992) * 51;
+acc += Math.sin(1992) + Math.cos(1993) * 52;
+acc += Math.sin(1993) + Math.cos(1994) * 53;
+acc += Math.sin(1994) + Math.cos(1995) * 54;
+acc += Math.sin(1995) + Math.cos(1996) * 55;
+acc += Math.sin(1996) + Math.cos(1997) * 56;
+acc += Math.sin(1997) + Math.cos(1998) * 57;
+acc += Math.sin(1998) + Math.cos(1999) * 58;
+acc += Math.sin(1999) + Math.cos(2000) * 59;
+acc += Math.sin(2000) + Math.cos(2001) * 60;
+acc += Math.sin(2001) + Math.cos(2002) * 61;
+acc += Math.sin(2002) + Math.cos(2003) * 62;
+acc += Math.sin(2003) + Math.cos(2004) * 63;
+acc += Math.sin(2004) + Math.cos(2005) * 64;
+acc += Math.sin(2005) + Math.cos(2006) * 65;
+acc += Math.sin(2006) + Math.cos(2007) * 66;
+acc += Math.sin(2007) + Math.cos(2008) * 67;
+acc += Math.sin(2008) + Math.cos(2009) * 68;
+acc += Math.sin(2009) + Math.cos(2010) * 69;
+acc += Math.sin(2010) + Math.cos(2011) * 70;
+acc += Math.sin(2011) + Math.cos(2012) * 71;
+acc += Math.sin(2012) + Math.cos(2013) * 72;
+acc += Math.sin(2013) + Math.cos(2014) * 73;
+acc += Math.sin(2014) + Math.cos(2015) * 74;
+acc += Math.sin(2015) + Math.cos(2016) * 75;
+acc += Math.sin(2016) + Math.cos(2017) * 76;
+acc += Math.sin(2017) + Math.cos(2018) * 77;
+acc += Math.sin(2018) + Math.cos(2019) * 78;
+acc += Math.sin(2019) + Math.cos(2020) * 79;
+acc += Math.sin(2020) + Math.cos(2021) * 80;
+acc += Math.sin(2021) + Math.cos(2022) * 81;
+acc += Math.sin(2022) + Math.cos(2023) * 82;
+acc += Math.sin(2023) + Math.cos(2024) * 83;
+acc += Math.sin(2024) + Math.cos(2025) * 84;
+acc += Math.sin(2025) + Math.cos(2026) * 85;
+acc += Math.sin(2026) + Math.cos(2027) * 86;
+acc += Math.sin(2027) + Math.cos(2028) * 87;
+acc += Math.sin(2028) + Math.cos(2029) * 88;
+acc += Math.sin(2029) + Math.cos(2030) * 89;
+acc += Math.sin(2030) + Math.cos(2031) * 90;
+acc += Math.sin(2031) + Math.cos(2032) * 91;
+acc += Math.sin(2032) + Math.cos(2033) * 92;
+acc += Math.sin(2033) + Math.cos(2034) * 93;
+acc += Math.sin(2034) + Math.cos(2035) * 94;
+acc += Math.sin(2035) + Math.cos(2036) * 95;
+acc += Math.sin(2036) + Math.cos(2037) * 96;
+acc += Math.sin(2037) + Math.cos(2038) * 0;
+acc += Math.sin(2038) + Math.cos(2039) * 1;
+acc += Math.sin(2039) + Math.cos(2040) * 2;
+acc += Math.sin(2040) + Math.cos(2041) * 3;
+acc += Math.sin(2041) + Math.cos(2042) * 4;
+acc += Math.sin(2042) + Math.cos(2043) * 5;
+acc += Math.sin(2043) + Math.cos(2044) * 6;
+acc += Math.sin(2044) + Math.cos(2045) * 7;
+acc += Math.sin(2045) + Math.cos(2046) * 8;
+acc += Math.sin(2046) + Math.cos(2047) * 9;
+acc += Math.sin(2047) + Math.cos(2048) * 10;
+acc += Math.sin(2048) + Math.cos(2049) * 11;
+acc += Math.sin(2049) + Math.cos(2050) * 12;
+acc += Math.sin(2050) + Math.cos(2051) * 13;
+acc += Math.sin(2051) + Math.cos(2052) * 14;
+acc += Math.sin(2052) + Math.cos(2053) * 15;
+acc += Math.sin(2053) + Math.cos(2054) * 16;
+acc += Math.sin(2054) + Math.cos(2055) * 17;
+acc += Math.sin(2055) + Math.cos(2056) * 18;
+acc += Math.sin(2056) + Math.cos(2057) * 19;
+acc += Math.sin(2057) + Math.cos(2058) * 20;
+acc += Math.sin(2058) + Math.cos(2059) * 21;
+acc += Math.sin(2059) + Math.cos(2060) * 22;
+acc += Math.sin(2060) + Math.cos(2061) * 23;
+acc += Math.sin(2061) + Math.cos(2062) * 24;
+acc += Math.sin(2062) + Math.cos(2063) * 25;
+acc += Math.sin(2063) + Math.cos(2064) * 26;
+acc += Math.sin(2064) + Math.cos(2065) * 27;
+acc += Math.sin(2065) + Math.cos(2066) * 28;
+acc += Math.sin(2066) + Math.cos(2067) * 29;
+acc += Math.sin(2067) + Math.cos(2068) * 30;
+acc += Math.sin(2068) + Math.cos(2069) * 31;
+acc += Math.sin(2069) + Math.cos(2070) * 32;
+acc += Math.sin(2070) + Math.cos(2071) * 33;
+acc += Math.sin(2071) + Math.cos(2072) * 34;
+acc += Math.sin(2072) + Math.cos(2073) * 35;
+acc += Math.sin(2073) + Math.cos(2074) * 36;
+acc += Math.sin(2074) + Math.cos(2075) * 37;
+acc += Math.sin(2075) + Math.cos(2076) * 38;
+acc += Math.sin(2076) + Math.cos(2077) * 39;
+acc += Math.sin(2077) + Math.cos(2078) * 40;
+acc += Math.sin(2078) + Math.cos(2079) * 41;
+acc += Math.sin(2079) + Math.cos(2080) * 42;
+acc += Math.sin(2080) + Math.cos(2081) * 43;
+acc += Math.sin(2081) + Math.cos(2082) * 44;
+acc += Math.sin(2082) + Math.cos(2083) * 45;
+acc += Math.sin(2083) + Math.cos(2084) * 46;
+acc += Math.sin(2084) + Math.cos(2085) * 47;
+acc += Math.sin(2085) + Math.cos(2086) * 48;
+acc += Math.sin(2086) + Math.cos(2087) * 49;
+acc += Math.sin(2087) + Math.cos(2088) * 50;
+acc += Math.sin(2088) + Math.cos(2089) * 51;
+acc += Math.sin(2089) + Math.cos(2090) * 52;
+acc += Math.sin(2090) + Math.cos(2091) * 53;
+acc += Math.sin(2091) + Math.cos(2092) * 54;
+acc += Math.sin(2092) + Math.cos(2093) * 55;
+acc += Math.sin(2093) + Math.cos(2094) * 56;
+acc += Math.sin(2094) + Math.cos(2095) * 57;
+acc += Math.sin(2095) + Math.cos(2096) * 58;
+acc += Math.sin(2096) + Math.cos(2097) * 59;
+acc += Math.sin(2097) + Math.cos(2098) * 60;
+acc += Math.sin(2098) + Math.cos(2099) * 61;
+acc += Math.sin(2099) + Math.cos(2100) * 62;
+acc += Math.sin(2100) + Math.cos(2101) * 63;
+acc += Math.sin(2101) + Math.cos(2102) * 64;
+acc += Math.sin(2102) + Math.cos(2103) * 65;
+acc += Math.sin(2103) + Math.cos(2104) * 66;
+acc += Math.sin(2104) + Math.cos(2105) * 67;
+acc += Math.sin(2105) + Math.cos(2106) * 68;
+acc += Math.sin(2106) + Math.cos(2107) * 69;
+acc += Math.sin(2107) + Math.cos(2108) * 70;
+acc += Math.sin(2108) + Math.cos(2109) * 71;
+acc += Math.sin(2109) + Math.cos(2110) * 72;
+acc += Math.sin(2110) + Math.cos(2111) * 73;
+acc += Math.sin(2111) + Math.cos(2112) * 74;
+acc += Math.sin(2112) + Math.cos(2113) * 75;
+acc += Math.sin(2113) + Math.cos(2114) * 76;
+acc += Math.sin(2114) + Math.cos(2115) * 77;
+acc += Math.sin(2115) + Math.cos(2116) * 78;
+acc += Math.sin(2116) + Math.cos(2117) * 79;
+acc += Math.sin(2117) + Math.cos(2118) * 80;
+acc += Math.sin(2118) + Math.cos(2119) * 81;
+acc += Math.sin(2119) + Math.cos(2120) * 82;
+acc += Math.sin(2120) + Math.cos(2121) * 83;
+acc += Math.sin(2121) + Math.cos(2122) * 84;
+acc += Math.sin(2122) + Math.cos(2123) * 85;
+acc += Math.sin(2123) + Math.cos(2124) * 86;
+acc += Math.sin(2124) + Math.cos(2125) * 87;
+acc += Math.sin(2125) + Math.cos(2126) * 88;
+acc += Math.sin(2126) + Math.cos(2127) * 89;
+acc += Math.sin(2127) + Math.cos(2128) * 90;
+acc += Math.sin(2128) + Math.cos(2129) * 91;
+acc += Math.sin(2129) + Math.cos(2130) * 92;
+acc += Math.sin(2130) + Math.cos(2131) * 93;
+acc += Math.sin(2131) + Math.cos(2132) * 94;
+acc += Math.sin(2132) + Math.cos(2133) * 95;
+acc += Math.sin(2133) + Math.cos(2134) * 96;
+acc += Math.sin(2134) + Math.cos(2135) * 0;
+acc += Math.sin(2135) + Math.cos(2136) * 1;
+acc += Math.sin(2136) + Math.cos(2137) * 2;
+acc += Math.sin(2137) + Math.cos(2138) * 3;
+acc += Math.sin(2138) + Math.cos(2139) * 4;
+acc += Math.sin(2139) + Math.cos(2140) * 5;
+acc += Math.sin(2140) + Math.cos(2141) * 6;
+acc += Math.sin(2141) + Math.cos(2142) * 7;
+acc += Math.sin(2142) + Math.cos(2143) * 8;
+acc += Math.sin(2143) + Math.cos(2144) * 9;
+acc += Math.sin(2144) + Math.cos(2145) * 10;
+acc += Math.sin(2145) + Math.cos(2146) * 11;
+acc += Math.sin(2146) + Math.cos(2147) * 12;
+acc += Math.sin(2147) + Math.cos(2148) * 13;
+acc += Math.sin(2148) + Math.cos(2149) * 14;
+acc += Math.sin(2149) + Math.cos(2150) * 15;
+acc += Math.sin(2150) + Math.cos(2151) * 16;
+acc += Math.sin(2151) + Math.cos(2152) * 17;
+acc += Math.sin(2152) + Math.cos(2153) * 18;
+acc += Math.sin(2153) + Math.cos(2154) * 19;
+acc += Math.sin(2154) + Math.cos(2155) * 20;
+acc += Math.sin(2155) + Math.cos(2156) * 21;
+acc += Math.sin(2156) + Math.cos(2157) * 22;
+acc += Math.sin(2157) + Math.cos(2158) * 23;
+acc += Math.sin(2158) + Math.cos(2159) * 24;
+acc += Math.sin(2159) + Math.cos(2160) * 25;
+acc += Math.sin(2160) + Math.cos(2161) * 26;
+acc += Math.sin(2161) + Math.cos(2162) * 27;
+acc += Math.sin(2162) + Math.cos(2163) * 28;
+acc += Math.sin(2163) + Math.cos(2164) * 29;
+acc += Math.sin(2164) + Math.cos(2165) * 30;
+acc += Math.sin(2165) + Math.cos(2166) * 31;
+acc += Math.sin(2166) + Math.cos(2167) * 32;
+acc += Math.sin(2167) + Math.cos(2168) * 33;
+acc += Math.sin(2168) + Math.cos(2169) * 34;
+acc += Math.sin(2169) + Math.cos(2170) * 35;
+acc += Math.sin(2170) + Math.cos(2171) * 36;
+acc += Math.sin(2171) + Math.cos(2172) * 37;
+acc += Math.sin(2172) + Math.cos(2173) * 38;
+acc += Math.sin(2173) + Math.cos(2174) * 39;
+acc += Math.sin(2174) + Math.cos(2175) * 40;
+acc += Math.sin(2175) + Math.cos(2176) * 41;
+acc += Math.sin(2176) + Math.cos(2177) * 42;
+acc += Math.sin(2177) + Math.cos(2178) * 43;
+acc += Math.sin(2178) + Math.cos(2179) * 44;
+acc += Math.sin(2179) + Math.cos(2180) * 45;
+acc += Math.sin(2180) + Math.cos(2181) * 46;
+acc += Math.sin(2181) + Math.cos(2182) * 47;
+acc += Math.sin(2182) + Math.cos(2183) * 48;
+acc += Math.sin(2183) + Math.cos(2184) * 49;
+acc += Math.sin(2184) + Math.cos(2185) * 50;
+acc += Math.sin(2185) + Math.cos(2186) * 51;
+acc += Math.sin(2186) + Math.cos(2187) * 52;
+acc += Math.sin(2187) + Math.cos(2188) * 53;
+acc += Math.sin(2188) + Math.cos(2189) * 54;
+acc += Math.sin(2189) + Math.cos(2190) * 55;
+acc += Math.sin(2190) + Math.cos(2191) * 56;
+acc += Math.sin(2191) + Math.cos(2192) * 57;
+acc += Math.sin(2192) + Math.cos(2193) * 58;
+acc += Math.sin(2193) + Math.cos(2194) * 59;
+acc += Math.sin(2194) + Math.cos(2195) * 60;
+acc += Math.sin(2195) + Math.cos(2196) * 61;
+acc += Math.sin(2196) + Math.cos(2197) * 62;
+acc += Math.sin(2197) + Math.cos(2198) * 63;
+acc += Math.sin(2198) + Math.cos(2199) * 64;
+acc += Math.sin(2199) + Math.cos(2200) * 65;
+acc += Math.sin(2200) + Math.cos(2201) * 66;
+acc += Math.sin(2201) + Math.cos(2202) * 67;
+acc += Math.sin(2202) + Math.cos(2203) * 68;
+acc += Math.sin(2203) + Math.cos(2204) * 69;
+acc += Math.sin(2204) + Math.cos(2205) * 70;
+acc += Math.sin(2205) + Math.cos(2206) * 71;
+acc += Math.sin(2206) + Math.cos(2207) * 72;
+acc += Math.sin(2207) + Math.cos(2208) * 73;
+acc += Math.sin(2208) + Math.cos(2209) * 74;
+acc += Math.sin(2209) + Math.cos(2210) * 75;
+acc += Math.sin(2210) + Math.cos(2211) * 76;
+acc += Math.sin(2211) + Math.cos(2212) * 77;
+acc += Math.sin(2212) + Math.cos(2213) * 78;
+acc += Math.sin(2213) + Math.cos(2214) * 79;
+acc += Math.sin(2214) + Math.cos(2215) * 80;
+acc += Math.sin(2215) + Math.cos(2216) * 81;
+acc += Math.sin(2216) + Math.cos(2217) * 82;
+acc += Math.sin(2217) + Math.cos(2218) * 83;
+acc += Math.sin(2218) + Math.cos(2219) * 84;
+acc += Math.sin(2219) + Math.cos(2220) * 85;
+acc += Math.sin(2220) + Math.cos(2221) * 86;
+acc += Math.sin(2221) + Math.cos(2222) * 87;
+acc += Math.sin(2222) + Math.cos(2223) * 88;
+acc += Math.sin(2223) + Math.cos(2224) * 89;
+acc += Math.sin(2224) + Math.cos(2225) * 90;
+acc += Math.sin(2225) + Math.cos(2226) * 91;
+acc += Math.sin(2226) + Math.cos(2227) * 92;
+acc += Math.sin(2227) + Math.cos(2228) * 93;
+acc += Math.sin(2228) + Math.cos(2229) * 94;
+acc += Math.sin(2229) + Math.cos(2230) * 95;
+acc += Math.sin(2230) + Math.cos(2231) * 96;
+acc += Math.sin(2231) + Math.cos(2232) * 0;
+acc += Math.sin(2232) + Math.cos(2233) * 1;
+acc += Math.sin(2233) + Math.cos(2234) * 2;
+acc += Math.sin(2234) + Math.cos(2235) * 3;
+acc += Math.sin(2235) + Math.cos(2236) * 4;
+acc += Math.sin(2236) + Math.cos(2237) * 5;
+acc += Math.sin(2237) + Math.cos(2238) * 6;
+acc += Math.sin(2238) + Math.cos(2239) * 7;
+acc += Math.sin(2239) + Math.cos(2240) * 8;
+acc += Math.sin(2240) + Math.cos(2241) * 9;
+acc += Math.sin(2241) + Math.cos(2242) * 10;
+acc += Math.sin(2242) + Math.cos(2243) * 11;
+acc += Math.sin(2243) + Math.cos(2244) * 12;
+acc += Math.sin(2244) + Math.cos(2245) * 13;
+acc += Math.sin(2245) + Math.cos(2246) * 14;
+acc += Math.sin(2246) + Math.cos(2247) * 15;
+acc += Math.sin(2247) + Math.cos(2248) * 16;
+acc += Math.sin(2248) + Math.cos(2249) * 17;
+acc += Math.sin(2249) + Math.cos(2250) * 18;
+acc += Math.sin(2250) + Math.cos(2251) * 19;
+acc += Math.sin(2251) + Math.cos(2252) * 20;
+acc += Math.sin(2252) + Math.cos(2253) * 21;
+acc += Math.sin(2253) + Math.cos(2254) * 22;
+acc += Math.sin(2254) + Math.cos(2255) * 23;
+acc += Math.sin(2255) + Math.cos(2256) * 24;
+acc += Math.sin(2256) + Math.cos(2257) * 25;
+acc += Math.sin(2257) + Math.cos(2258) * 26;
+acc += Math.sin(2258) + Math.cos(2259) * 27;
+acc += Math.sin(2259) + Math.cos(2260) * 28;
+acc += Math.sin(2260) + Math.cos(2261) * 29;
+acc += Math.sin(2261) + Math.cos(2262) * 30;
+acc += Math.sin(2262) + Math.cos(2263) * 31;
+acc += Math.sin(2263) + Math.cos(2264) * 32;
+acc += Math.sin(2264) + Math.cos(2265) * 33;
+acc += Math.sin(2265) + Math.cos(2266) * 34;
+acc += Math.sin(2266) + Math.cos(2267) * 35;
+acc += Math.sin(2267) + Math.cos(2268) * 36;
+acc += Math.sin(2268) + Math.cos(2269) * 37;
+acc += Math.sin(2269) + Math.cos(2270) * 38;
+acc += Math.sin(2270) + Math.cos(2271) * 39;
+acc += Math.sin(2271) + Math.cos(2272) * 40;
+acc += Math.sin(2272) + Math.cos(2273) * 41;
+acc += Math.sin(2273) + Math.cos(2274) * 42;
+acc += Math.sin(2274) + Math.cos(2275) * 43;
+acc += Math.sin(2275) + Math.cos(2276) * 44;
+acc += Math.sin(2276) + Math.cos(2277) * 45;
+acc += Math.sin(2277) + Math.cos(2278) * 46;
+acc += Math.sin(2278) + Math.cos(2279) * 47;
+acc += Math.sin(2279) + Math.cos(2280) * 48;
+acc += Math.sin(2280) + Math.cos(2281) * 49;
+acc += Math.sin(2281) + Math.cos(2282) * 50;
+acc += Math.sin(2282) + Math.cos(2283) * 51;
+acc += Math.sin(2283) + Math.cos(2284) * 52;
+acc += Math.sin(2284) + Math.cos(2285) * 53;
+acc += Math.sin(2285) + Math.cos(2286) * 54;
+acc += Math.sin(2286) + Math.cos(2287) * 55;
+acc += Math.sin(2287) + Math.cos(2288) * 56;
+acc += Math.sin(2288) + Math.cos(2289) * 57;
+acc += Math.sin(2289) + Math.cos(2290) * 58;
+acc += Math.sin(2290) + Math.cos(2291) * 59;
+acc += Math.sin(2291) + Math.cos(2292) * 60;
+acc += Math.sin(2292) + Math.cos(2293) * 61;
+acc += Math.sin(2293) + Math.cos(2294) * 62;
+acc += Math.sin(2294) + Math.cos(2295) * 63;
+acc += Math.sin(2295) + Math.cos(2296) * 64;
+acc += Math.sin(2296) + Math.cos(2297) * 65;
+acc += Math.sin(2297) + Math.cos(2298) * 66;
+acc += Math.sin(2298) + Math.cos(2299) * 67;
+acc += Math.sin(2299) + Math.cos(2300) * 68;
+acc += Math.sin(2300) + Math.cos(2301) * 69;
+acc += Math.sin(2301) + Math.cos(2302) * 70;
+acc += Math.sin(2302) + Math.cos(2303) * 71;
+acc += Math.sin(2303) + Math.cos(2304) * 72;
+acc += Math.sin(2304) + Math.cos(2305) * 73;
+acc += Math.sin(2305) + Math.cos(2306) * 74;
+acc += Math.sin(2306) + Math.cos(2307) * 75;
+acc += Math.sin(2307) + Math.cos(2308) * 76;
+acc += Math.sin(2308) + Math.cos(2309) * 77;
+acc += Math.sin(2309) + Math.cos(2310) * 78;
+acc += Math.sin(2310) + Math.cos(2311) * 79;
+acc += Math.sin(2311) + Math.cos(2312) * 80;
+acc += Math.sin(2312) + Math.cos(2313) * 81;
+acc += Math.sin(2313) + Math.cos(2314) * 82;
+acc += Math.sin(2314) + Math.cos(2315) * 83;
+acc += Math.sin(2315) + Math.cos(2316) * 84;
+acc += Math.sin(2316) + Math.cos(2317) * 85;
+acc += Math.sin(2317) + Math.cos(2318) * 86;
+acc += Math.sin(2318) + Math.cos(2319) * 87;
+acc += Math.sin(2319) + Math.cos(2320) * 88;
+acc += Math.sin(2320) + Math.cos(2321) * 89;
+acc += Math.sin(2321) + Math.cos(2322) * 90;
+acc += Math.sin(2322) + Math.cos(2323) * 91;
+acc += Math.sin(2323) + Math.cos(2324) * 92;
+acc += Math.sin(2324) + Math.cos(2325) * 93;
+acc += Math.sin(2325) + Math.cos(2326) * 94;
+acc += Math.sin(2326) + Math.cos(2327) * 95;
+acc += Math.sin(2327) + Math.cos(2328) * 96;
+acc += Math.sin(2328) + Math.cos(2329) * 0;
+acc += Math.sin(2329) + Math.cos(2330) * 1;
+acc += Math.sin(2330) + Math.cos(2331) * 2;
+acc += Math.sin(2331) + Math.cos(2332) * 3;
+acc += Math.sin(2332) + Math.cos(2333) * 4;
+acc += Math.sin(2333) + Math.cos(2334) * 5;
+acc += Math.sin(2334) + Math.cos(2335) * 6;
+acc += Math.sin(2335) + Math.cos(2336) * 7;
+acc += Math.sin(2336) + Math.cos(2337) * 8;
+acc += Math.sin(2337) + Math.cos(2338) * 9;
+acc += Math.sin(2338) + Math.cos(2339) * 10;
+acc += Math.sin(2339) + Math.cos(2340) * 11;
+acc += Math.sin(2340) + Math.cos(2341) * 12;
+acc += Math.sin(2341) + Math.cos(2342) * 13;
+acc += Math.sin(2342) + Math.cos(2343) * 14;
+acc += Math.sin(2343) + Math.cos(2344) * 15;
+acc += Math.sin(2344) + Math.cos(2345) * 16;
+acc += Math.sin(2345) + Math.cos(2346) * 17;
+acc += Math.sin(2346) + Math.cos(2347) * 18;
+acc += Math.sin(2347) + Math.cos(2348) * 19;
+acc += Math.sin(2348) + Math.cos(2349) * 20;
+acc += Math.sin(2349) + Math.cos(2350) * 21;
+acc += Math.sin(2350) + Math.cos(2351) * 22;
+acc += Math.sin(2351) + Math.cos(2352) * 23;
+acc += Math.sin(2352) + Math.cos(2353) * 24;
+acc += Math.sin(2353) + Math.cos(2354) * 25;
+acc += Math.sin(2354) + Math.cos(2355) * 26;
+acc += Math.sin(2355) + Math.cos(2356) * 27;
+acc += Math.sin(2356) + Math.cos(2357) * 28;
+acc += Math.sin(2357) + Math.cos(2358) * 29;
+acc += Math.sin(2358) + Math.cos(2359) * 30;
+acc += Math.sin(2359) + Math.cos(2360) * 31;
+acc += Math.sin(2360) + Math.cos(2361) * 32;
+acc += Math.sin(2361) + Math.cos(2362) * 33;
+acc += Math.sin(2362) + Math.cos(2363) * 34;
+acc += Math.sin(2363) + Math.cos(2364) * 35;
+acc += Math.sin(2364) + Math.cos(2365) * 36;
+acc += Math.sin(2365) + Math.cos(2366) * 37;
+acc += Math.sin(2366) + Math.cos(2367) * 38;
+acc += Math.sin(2367) + Math.cos(2368) * 39;
+acc += Math.sin(2368) + Math.cos(2369) * 40;
+acc += Math.sin(2369) + Math.cos(2370) * 41;
+acc += Math.sin(2370) + Math.cos(2371) * 42;
+acc += Math.sin(2371) + Math.cos(2372) * 43;
+acc += Math.sin(2372) + Math.cos(2373) * 44;
+acc += Math.sin(2373) + Math.cos(2374) * 45;
+acc += Math.sin(2374) + Math.cos(2375) * 46;
+acc += Math.sin(2375) + Math.cos(2376) * 47;
+acc += Math.sin(2376) + Math.cos(2377) * 48;
+acc += Math.sin(2377) + Math.cos(2378) * 49;
+acc += Math.sin(2378) + Math.cos(2379) * 50;
+acc += Math.sin(2379) + Math.cos(2380) * 51;
+acc += Math.sin(2380) + Math.cos(2381) * 52;
+acc += Math.sin(2381) + Math.cos(2382) * 53;
+acc += Math.sin(2382) + Math.cos(2383) * 54;
+acc += Math.sin(2383) + Math.cos(2384) * 55;
+acc += Math.sin(2384) + Math.cos(2385) * 56;
+acc += Math.sin(2385) + Math.cos(2386) * 57;
+acc += Math.sin(2386) + Math.cos(2387) * 58;
+acc += Math.sin(2387) + Math.cos(2388) * 59;
+acc += Math.sin(2388) + Math.cos(2389) * 60;
+acc += Math.sin(2389) + Math.cos(2390) * 61;
+acc += Math.sin(2390) + Math.cos(2391) * 62;
+acc += Math.sin(2391) + Math.cos(2392) * 63;
+acc += Math.sin(2392) + Math.cos(2393) * 64;
+acc += Math.sin(2393) + Math.cos(2394) * 65;
+acc += Math.sin(2394) + Math.cos(2395) * 66;
+acc += Math.sin(2395) + Math.cos(2396) * 67;
+acc += Math.sin(2396) + Math.cos(2397) * 68;
+acc += Math.sin(2397) + Math.cos(2398) * 69;
+acc += Math.sin(2398) + Math.cos(2399) * 70;
+acc += Math.sin(2399) + Math.cos(2400) * 71;
+acc += Math.sin(2400) + Math.cos(2401) * 72;
+acc += Math.sin(2401) + Math.cos(2402) * 73;
+acc += Math.sin(2402) + Math.cos(2403) * 74;
+acc += Math.sin(2403) + Math.cos(2404) * 75;
+acc += Math.sin(2404) + Math.cos(2405) * 76;
+acc += Math.sin(2405) + Math.cos(2406) * 77;
+acc += Math.sin(2406) + Math.cos(2407) * 78;
+acc += Math.sin(2407) + Math.cos(2408) * 79;
+acc += Math.sin(2408) + Math.cos(2409) * 80;
+acc += Math.sin(2409) + Math.cos(2410) * 81;
+acc += Math.sin(2410) + Math.cos(2411) * 82;
+acc += Math.sin(2411) + Math.cos(2412) * 83;
+acc += Math.sin(2412) + Math.cos(2413) * 84;
+acc += Math.sin(2413) + Math.cos(2414) * 85;
+acc += Math.sin(2414) + Math.cos(2415) * 86;
+acc += Math.sin(2415) + Math.cos(2416) * 87;
+acc += Math.sin(2416) + Math.cos(2417) * 88;
+acc += Math.sin(2417) + Math.cos(2418) * 89;
+acc += Math.sin(2418) + Math.cos(2419) * 90;
+acc += Math.sin(2419) + Math.cos(2420) * 91;
+acc += Math.sin(2420) + Math.cos(2421) * 92;
+acc += Math.sin(2421) + Math.cos(2422) * 93;
+acc += Math.sin(2422) + Math.cos(2423) * 94;
+acc += Math.sin(2423) + Math.cos(2424) * 95;
+acc += Math.sin(2424) + Math.cos(2425) * 96;
+acc += Math.sin(2425) + Math.cos(2426) * 0;
+acc += Math.sin(2426) + Math.cos(2427) * 1;
+acc += Math.sin(2427) + Math.cos(2428) * 2;
+acc += Math.sin(2428) + Math.cos(2429) * 3;
+acc += Math.sin(2429) + Math.cos(2430) * 4;
+acc += Math.sin(2430) + Math.cos(2431) * 5;
+acc += Math.sin(2431) + Math.cos(2432) * 6;
+acc += Math.sin(2432) + Math.cos(2433) * 7;
+acc += Math.sin(2433) + Math.cos(2434) * 8;
+acc += Math.sin(2434) + Math.cos(2435) * 9;
+acc += Math.sin(2435) + Math.cos(2436) * 10;
+acc += Math.sin(2436) + Math.cos(2437) * 11;
+acc += Math.sin(2437) + Math.cos(2438) * 12;
+acc += Math.sin(2438) + Math.cos(2439) * 13;
+acc += Math.sin(2439) + Math.cos(2440) * 14;
+acc += Math.sin(2440) + Math.cos(2441) * 15;
+acc += Math.sin(2441) + Math.cos(2442) * 16;
+acc += Math.sin(2442) + Math.cos(2443) * 17;
+acc += Math.sin(2443) + Math.cos(2444) * 18;
+acc += Math.sin(2444) + Math.cos(2445) * 19;
+acc += Math.sin(2445) + Math.cos(2446) * 20;
+acc += Math.sin(2446) + Math.cos(2447) * 21;
+acc += Math.sin(2447) + Math.cos(2448) * 22;
+acc += Math.sin(2448) + Math.cos(2449) * 23;
+acc += Math.sin(2449) + Math.cos(2450) * 24;
+acc += Math.sin(2450) + Math.cos(2451) * 25;
+acc += Math.sin(2451) + Math.cos(2452) * 26;
+acc += Math.sin(2452) + Math.cos(2453) * 27;
+acc += Math.sin(2453) + Math.cos(2454) * 28;
+acc += Math.sin(2454) + Math.cos(2455) * 29;
+acc += Math.sin(2455) + Math.cos(2456) * 30;
+acc += Math.sin(2456) + Math.cos(2457) * 31;
+acc += Math.sin(2457) + Math.cos(2458) * 32;
+acc += Math.sin(2458) + Math.cos(2459) * 33;
+acc += Math.sin(2459) + Math.cos(2460) * 34;
+acc += Math.sin(2460) + Math.cos(2461) * 35;
+acc += Math.sin(2461) + Math.cos(2462) * 36;
+acc += Math.sin(2462) + Math.cos(2463) * 37;
+acc += Math.sin(2463) + Math.cos(2464) * 38;
+acc += Math.sin(2464) + Math.cos(2465) * 39;
+acc += Math.sin(2465) + Math.cos(2466) * 40;
+acc += Math.sin(2466) + Math.cos(2467) * 41;
+acc += Math.sin(2467) + Math.cos(2468) * 42;
+acc += Math.sin(2468) + Math.cos(2469) * 43;
+acc += Math.sin(2469) + Math.cos(2470) * 44;
+acc += Math.sin(2470) + Math.cos(2471) * 45;
+acc += Math.sin(2471) + Math.cos(2472) * 46;
+acc += Math.sin(2472) + Math.cos(2473) * 47;
+acc += Math.sin(2473) + Math.cos(2474) * 48;
+acc += Math.sin(2474) + Math.cos(2475) * 49;
+acc += Math.sin(2475) + Math.cos(2476) * 50;
+acc += Math.sin(2476) + Math.cos(2477) * 51;
+acc += Math.sin(2477) + Math.cos(2478) * 52;
+acc += Math.sin(2478) + Math.cos(2479) * 53;
+acc += Math.sin(2479) + Math.cos(2480) * 54;
+acc += Math.sin(2480) + Math.cos(2481) * 55;
+acc += Math.sin(2481) + Math.cos(2482) * 56;
+acc += Math.sin(2482) + Math.cos(2483) * 57;
+acc += Math.sin(2483) + Math.cos(2484) * 58;
+acc += Math.sin(2484) + Math.cos(2485) * 59;
+acc += Math.sin(2485) + Math.cos(2486) * 60;
+acc += Math.sin(2486) + Math.cos(2487) * 61;
+acc += Math.sin(2487) + Math.cos(2488) * 62;
+acc += Math.sin(2488) + Math.cos(2489) * 63;
+acc += Math.sin(2489) + Math.cos(2490) * 64;
+acc += Math.sin(2490) + Math.cos(2491) * 65;
+acc += Math.sin(2491) + Math.cos(2492) * 66;
+acc += Math.sin(2492) + Math.cos(2493) * 67;
+acc += Math.sin(2493) + Math.cos(2494) * 68;
+acc += Math.sin(2494) + Math.cos(2495) * 69;
+acc += Math.sin(2495) + Math.cos(2496) * 70;
+acc += Math.sin(2496) + Math.cos(2497) * 71;
+acc += Math.sin(2497) + Math.cos(2498) * 72;
+acc += Math.sin(2498) + Math.cos(2499) * 73;
+acc += Math.sin(2499) + Math.cos(2500) * 74;
+acc += Math.sin(2500) + Math.cos(2501) * 75;
+acc += Math.sin(2501) + Math.cos(2502) * 76;
+acc += Math.sin(2502) + Math.cos(2503) * 77;
+acc += Math.sin(2503) + Math.cos(2504) * 78;
+acc += Math.sin(2504) + Math.cos(2505) * 79;
+acc += Math.sin(2505) + Math.cos(2506) * 80;
+acc += Math.sin(2506) + Math.cos(2507) * 81;
+acc += Math.sin(2507) + Math.cos(2508) * 82;
+acc += Math.sin(2508) + Math.cos(2509) * 83;
+acc += Math.sin(2509) + Math.cos(2510) * 84;
+acc += Math.sin(2510) + Math.cos(2511) * 85;
+acc += Math.sin(2511) + Math.cos(2512) * 86;
+acc += Math.sin(2512) + Math.cos(2513) * 87;
+acc += Math.sin(2513) + Math.cos(2514) * 88;
+acc += Math.sin(2514) + Math.cos(2515) * 89;
+acc += Math.sin(2515) + Math.cos(2516) * 90;
+acc += Math.sin(2516) + Math.cos(2517) * 91;
+acc += Math.sin(2517) + Math.cos(2518) * 92;
+acc += Math.sin(2518) + Math.cos(2519) * 93;
+acc += Math.sin(2519) + Math.cos(2520) * 94;
+acc += Math.sin(2520) + Math.cos(2521) * 95;
+acc += Math.sin(2521) + Math.cos(2522) * 96;
+acc += Math.sin(2522) + Math.cos(2523) * 0;
+acc += Math.sin(2523) + Math.cos(2524) * 1;
+acc += Math.sin(2524) + Math.cos(2525) * 2;
+acc += Math.sin(2525) + Math.cos(2526) * 3;
+acc += Math.sin(2526) + Math.cos(2527) * 4;
+acc += Math.sin(2527) + Math.cos(2528) * 5;
+acc += Math.sin(2528) + Math.cos(2529) * 6;
+acc += Math.sin(2529) + Math.cos(2530) * 7;
+acc += Math.sin(2530) + Math.cos(2531) * 8;
+acc += Math.sin(2531) + Math.cos(2532) * 9;
+acc += Math.sin(2532) + Math.cos(2533) * 10;
+acc += Math.sin(2533) + Math.cos(2534) * 11;
+acc += Math.sin(2534) + Math.cos(2535) * 12;
+acc += Math.sin(2535) + Math.cos(2536) * 13;
+acc += Math.sin(2536) + Math.cos(2537) * 14;
+acc += Math.sin(2537) + Math.cos(2538) * 15;
+acc += Math.sin(2538) + Math.cos(2539) * 16;
+acc += Math.sin(2539) + Math.cos(2540) * 17;
+acc += Math.sin(2540) + Math.cos(2541) * 18;
+acc += Math.sin(2541) + Math.cos(2542) * 19;
+acc += Math.sin(2542) + Math.cos(2543) * 20;
+acc += Math.sin(2543) + Math.cos(2544) * 21;
+acc += Math.sin(2544) + Math.cos(2545) * 22;
+acc += Math.sin(2545) + Math.cos(2546) * 23;
+acc += Math.sin(2546) + Math.cos(2547) * 24;
+acc += Math.sin(2547) + Math.cos(2548) * 25;
+acc += Math.sin(2548) + Math.cos(2549) * 26;
+acc += Math.sin(2549) + Math.cos(2550) * 27;
+acc += Math.sin(2550) + Math.cos(2551) * 28;
+acc += Math.sin(2551) + Math.cos(2552) * 29;
+acc += Math.sin(2552) + Math.cos(2553) * 30;
+acc += Math.sin(2553) + Math.cos(2554) * 31;
+acc += Math.sin(2554) + Math.cos(2555) * 32;
+acc += Math.sin(2555) + Math.cos(2556) * 33;
+acc += Math.sin(2556) + Math.cos(2557) * 34;
+acc += Math.sin(2557) + Math.cos(2558) * 35;
+acc += Math.sin(2558) + Math.cos(2559) * 36;
+acc += Math.sin(2559) + Math.cos(2560) * 37;
+acc += Math.sin(2560) + Math.cos(2561) * 38;
+acc += Math.sin(2561) + Math.cos(2562) * 39;
+acc += Math.sin(2562) + Math.cos(2563) * 40;
+acc += Math.sin(2563) + Math.cos(2564) * 41;
+acc += Math.sin(2564) + Math.cos(2565) * 42;
+acc += Math.sin(2565) + Math.cos(2566) * 43;
+acc += Math.sin(2566) + Math.cos(2567) * 44;
+acc += Math.sin(2567) + Math.cos(2568) * 45;
+acc += Math.sin(2568) + Math.cos(2569) * 46;
+acc += Math.sin(2569) + Math.cos(2570) * 47;
+acc += Math.sin(2570) + Math.cos(2571) * 48;
+acc += Math.sin(2571) + Math.cos(2572) * 49;
+acc += Math.sin(2572) + Math.cos(2573) * 50;
+acc += Math.sin(2573) + Math.cos(2574) * 51;
+acc += Math.sin(2574) + Math.cos(2575) * 52;
+acc += Math.sin(2575) + Math.cos(2576) * 53;
+acc += Math.sin(2576) + Math.cos(2577) * 54;
+acc += Math.sin(2577) + Math.cos(2578) * 55;
+acc += Math.sin(2578) + Math.cos(2579) * 56;
+acc += Math.sin(2579) + Math.cos(2580) * 57;
+acc += Math.sin(2580) + Math.cos(2581) * 58;
+acc += Math.sin(2581) + Math.cos(2582) * 59;
+acc += Math.sin(2582) + Math.cos(2583) * 60;
+acc += Math.sin(2583) + Math.cos(2584) * 61;
+acc += Math.sin(2584) + Math.cos(2585) * 62;
+acc += Math.sin(2585) + Math.cos(2586) * 63;
+acc += Math.sin(2586) + Math.cos(2587) * 64;
+acc += Math.sin(2587) + Math.cos(2588) * 65;
+acc += Math.sin(2588) + Math.cos(2589) * 66;
+acc += Math.sin(2589) + Math.cos(2590) * 67;
+acc += Math.sin(2590) + Math.cos(2591) * 68;
+acc += Math.sin(2591) + Math.cos(2592) * 69;
+acc += Math.sin(2592) + Math.cos(2593) * 70;
+acc += Math.sin(2593) + Math.cos(2594) * 71;
+acc += Math.sin(2594) + Math.cos(2595) * 72;
+acc += Math.sin(2595) + Math.cos(2596) * 73;
+acc += Math.sin(2596) + Math.cos(2597) * 74;
+acc += Math.sin(2597) + Math.cos(2598) * 75;
+acc += Math.sin(2598) + Math.cos(2599) * 76;
+acc += Math.sin(2599) + Math.cos(2600) * 77;
+acc += Math.sin(2600) + Math.cos(2601) * 78;
+acc += Math.sin(2601) + Math.cos(2602) * 79;
+acc += Math.sin(2602) + Math.cos(2603) * 80;
+acc += Math.sin(2603) + Math.cos(2604) * 81;
+acc += Math.sin(2604) + Math.cos(2605) * 82;
+acc += Math.sin(2605) + Math.cos(2606) * 83;
+acc += Math.sin(2606) + Math.cos(2607) * 84;
+acc += Math.sin(2607) + Math.cos(2608) * 85;
+acc += Math.sin(2608) + Math.cos(2609) * 86;
+acc += Math.sin(2609) + Math.cos(2610) * 87;
+acc += Math.sin(2610) + Math.cos(2611) * 88;
+acc += Math.sin(2611) + Math.cos(2612) * 89;
+acc += Math.sin(2612) + Math.cos(2613) * 90;
+acc += Math.sin(2613) + Math.cos(2614) * 91;
+acc += Math.sin(2614) + Math.cos(2615) * 92;
+acc += Math.sin(2615) + Math.cos(2616) * 93;
+acc += Math.sin(2616) + Math.cos(2617) * 94;
+acc += Math.sin(2617) + Math.cos(2618) * 95;
+acc += Math.sin(2618) + Math.cos(2619) * 96;
+acc += Math.sin(2619) + Math.cos(2620) * 0;
+acc += Math.sin(2620) + Math.cos(2621) * 1;
+acc += Math.sin(2621) + Math.cos(2622) * 2;
+acc += Math.sin(2622) + Math.cos(2623) * 3;
+acc += Math.sin(2623) + Math.cos(2624) * 4;
+acc += Math.sin(2624) + Math.cos(2625) * 5;
+acc += Math.sin(2625) + Math.cos(2626) * 6;
+acc += Math.sin(2626) + Math.cos(2627) * 7;
+acc += Math.sin(2627) + Math.cos(2628) * 8;
+acc += Math.sin(2628) + Math.cos(2629) * 9;
+acc += Math.sin(2629) + Math.cos(2630) * 10;
+acc += Math.sin(2630) + Math.cos(2631) * 11;
+acc += Math.sin(2631) + Math.cos(2632) * 12;
+acc += Math.sin(2632) + Math.cos(2633) * 13;
+acc += Math.sin(2633) + Math.cos(2634) * 14;
+acc += Math.sin(2634) + Math.cos(2635) * 15;
+acc += Math.sin(2635) + Math.cos(2636) * 16;
+acc += Math.sin(2636) + Math.cos(2637) * 17;
+acc += Math.sin(2637) + Math.cos(2638) * 18;
+acc += Math.sin(2638) + Math.cos(2639) * 19;
+acc += Math.sin(2639) + Math.cos(2640) * 20;
+acc += Math.sin(2640) + Math.cos(2641) * 21;
+acc += Math.sin(2641) + Math.cos(2642) * 22;
+acc += Math.sin(2642) + Math.cos(2643) * 23;
+acc += Math.sin(2643) + Math.cos(2644) * 24;
+acc += Math.sin(2644) + Math.cos(2645) * 25;
+acc += Math.sin(2645) + Math.cos(2646) * 26;
+acc += Math.sin(2646) + Math.cos(2647) * 27;
+acc += Math.sin(2647) + Math.cos(2648) * 28;
+acc += Math.sin(2648) + Math.cos(2649) * 29;
+acc += Math.sin(2649) + Math.cos(2650) * 30;
+acc += Math.sin(2650) + Math.cos(2651) * 31;
+acc += Math.sin(2651) + Math.cos(2652) * 32;
+acc += Math.sin(2652) + Math.cos(2653) * 33;
+acc += Math.sin(2653) + Math.cos(2654) * 34;
+acc += Math.sin(2654) + Math.cos(2655) * 35;
+acc += Math.sin(2655) + Math.cos(2656) * 36;
+acc += Math.sin(2656) + Math.cos(2657) * 37;
+acc += Math.sin(2657) + Math.cos(2658) * 38;
+acc += Math.sin(2658) + Math.cos(2659) * 39;
+acc += Math.sin(2659) + Math.cos(2660) * 40;
+acc += Math.sin(2660) + Math.cos(2661) * 41;
+acc += Math.sin(2661) + Math.cos(2662) * 42;
+acc += Math.sin(2662) + Math.cos(2663) * 43;
+acc += Math.sin(2663) + Math.cos(2664) * 44;
+acc += Math.sin(2664) + Math.cos(2665) * 45;
+acc += Math.sin(2665) + Math.cos(2666) * 46;
+acc += Math.sin(2666) + Math.cos(2667) * 47;
+acc += Math.sin(2667) + Math.cos(2668) * 48;
+acc += Math.sin(2668) + Math.cos(2669) * 49;
+acc += Math.sin(2669) + Math.cos(2670) * 50;
+acc += Math.sin(2670) + Math.cos(2671) * 51;
+acc += Math.sin(2671) + Math.cos(2672) * 52;
+acc += Math.sin(2672) + Math.cos(2673) * 53;
+acc += Math.sin(2673) + Math.cos(2674) * 54;
+acc += Math.sin(2674) + Math.cos(2675) * 55;
+acc += Math.sin(2675) + Math.cos(2676) * 56;
+acc += Math.sin(2676) + Math.cos(2677) * 57;
+acc += Math.sin(2677) + Math.cos(2678) * 58;
+acc += Math.sin(2678) + Math.cos(2679) * 59;
+acc += Math.sin(2679) + Math.cos(2680) * 60;
+acc += Math.sin(2680) + Math.cos(2681) * 61;
+acc += Math.sin(2681) + Math.cos(2682) * 62;
+acc += Math.sin(2682) + Math.cos(2683) * 63;
+acc += Math.sin(2683) + Math.cos(2684) * 64;
+acc += Math.sin(2684) + Math.cos(2685) * 65;
+acc += Math.sin(2685) + Math.cos(2686) * 66;
+acc += Math.sin(2686) + Math.cos(2687) * 67;
+acc += Math.sin(2687) + Math.cos(2688) * 68;
+acc += Math.sin(2688) + Math.cos(2689) * 69;
+acc += Math.sin(2689) + Math.cos(2690) * 70;
+acc += Math.sin(2690) + Math.cos(2691) * 71;
+acc += Math.sin(2691) + Math.cos(2692) * 72;
+acc += Math.sin(2692) + Math.cos(2693) * 73;
+acc += Math.sin(2693) + Math.cos(2694) * 74;
+acc += Math.sin(2694) + Math.cos(2695) * 75;
+acc += Math.sin(2695) + Math.cos(2696) * 76;
+acc += Math.sin(2696) + Math.cos(2697) * 77;
+acc += Math.sin(2697) + Math.cos(2698) * 78;
+acc += Math.sin(2698) + Math.cos(2699) * 79;
+acc += Math.sin(2699) + Math.cos(2700) * 80;
+acc += Math.sin(2700) + Math.cos(2701) * 81;
+acc += Math.sin(2701) + Math.cos(2702) * 82;
+acc += Math.sin(2702) + Math.cos(2703) * 83;
+acc += Math.sin(2703) + Math.cos(2704) * 84;
+acc += Math.sin(2704) + Math.cos(2705) * 85;
+acc += Math.sin(2705) + Math.cos(2706) * 86;
+acc += Math.sin(2706) + Math.cos(2707) * 87;
+acc += Math.sin(2707) + Math.cos(2708) * 88;
+acc += Math.sin(2708) + Math.cos(2709) * 89;
+acc += Math.sin(2709) + Math.cos(2710) * 90;
+acc += Math.sin(2710) + Math.cos(2711) * 91;
+acc += Math.sin(2711) + Math.cos(2712) * 92;
+acc += Math.sin(2712) + Math.cos(2713) * 93;
+acc += Math.sin(2713) + Math.cos(2714) * 94;
+acc += Math.sin(2714) + Math.cos(2715) * 95;
+acc += Math.sin(2715) + Math.cos(2716) * 96;
+acc += Math.sin(2716) + Math.cos(2717) * 0;
+acc += Math.sin(2717) + Math.cos(2718) * 1;
+acc += Math.sin(2718) + Math.cos(2719) * 2;
+acc += Math.sin(2719) + Math.cos(2720) * 3;
+acc += Math.sin(2720) + Math.cos(2721) * 4;
+acc += Math.sin(2721) + Math.cos(2722) * 5;
+acc += Math.sin(2722) + Math.cos(2723) * 6;
+acc += Math.sin(2723) + Math.cos(2724) * 7;
+acc += Math.sin(2724) + Math.cos(2725) * 8;
+acc += Math.sin(2725) + Math.cos(2726) * 9;
+acc += Math.sin(2726) + Math.cos(2727) * 10;
+acc += Math.sin(2727) + Math.cos(2728) * 11;
+acc += Math.sin(2728) + Math.cos(2729) * 12;
+acc += Math.sin(2729) + Math.cos(2730) * 13;
+acc += Math.sin(2730) + Math.cos(2731) * 14;
+acc += Math.sin(2731) + Math.cos(2732) * 15;
+acc += Math.sin(2732) + Math.cos(2733) * 16;
+acc += Math.sin(2733) + Math.cos(2734) * 17;
+acc += Math.sin(2734) + Math.cos(2735) * 18;
+acc += Math.sin(2735) + Math.cos(2736) * 19;
+acc += Math.sin(2736) + Math.cos(2737) * 20;
+acc += Math.sin(2737) + Math.cos(2738) * 21;
+acc += Math.sin(2738) + Math.cos(2739) * 22;
+acc += Math.sin(2739) + Math.cos(2740) * 23;
+acc += Math.sin(2740) + Math.cos(2741) * 24;
+acc += Math.sin(2741) + Math.cos(2742) * 25;
+acc += Math.sin(2742) + Math.cos(2743) * 26;
+acc += Math.sin(2743) + Math.cos(2744) * 27;
+acc += Math.sin(2744) + Math.cos(2745) * 28;
+acc += Math.sin(2745) + Math.cos(2746) * 29;
+acc += Math.sin(2746) + Math.cos(2747) * 30;
+acc += Math.sin(2747) + Math.cos(2748) * 31;
+acc += Math.sin(2748) + Math.cos(2749) * 32;
+acc += Math.sin(2749) + Math.cos(2750) * 33;
+acc += Math.sin(2750) + Math.cos(2751) * 34;
+acc += Math.sin(2751) + Math.cos(2752) * 35;
+acc += Math.sin(2752) + Math.cos(2753) * 36;
+acc += Math.sin(2753) + Math.cos(2754) * 37;
+acc += Math.sin(2754) + Math.cos(2755) * 38;
+acc += Math.sin(2755) + Math.cos(2756) * 39;
+acc += Math.sin(2756) + Math.cos(2757) * 40;
+acc += Math.sin(2757) + Math.cos(2758) * 41;
+acc += Math.sin(2758) + Math.cos(2759) * 42;
+acc += Math.sin(2759) + Math.cos(2760) * 43;
+acc += Math.sin(2760) + Math.cos(2761) * 44;
+acc += Math.sin(2761) + Math.cos(2762) * 45;
+acc += Math.sin(2762) + Math.cos(2763) * 46;
+acc += Math.sin(2763) + Math.cos(2764) * 47;
+acc += Math.sin(2764) + Math.cos(2765) * 48;
+acc += Math.sin(2765) + Math.cos(2766) * 49;
+acc += Math.sin(2766) + Math.cos(2767) * 50;
+acc += Math.sin(2767) + Math.cos(2768) * 51;
+acc += Math.sin(2768) + Math.cos(2769) * 52;
+acc += Math.sin(2769) + Math.cos(2770) * 53;
+acc += Math.sin(2770) + Math.cos(2771) * 54;
+acc += Math.sin(2771) + Math.cos(2772) * 55;
+acc += Math.sin(2772) + Math.cos(2773) * 56;
+acc += Math.sin(2773) + Math.cos(2774) * 57;
+acc += Math.sin(2774) + Math.cos(2775) * 58;
+acc += Math.sin(2775) + Math.cos(2776) * 59;
+acc += Math.sin(2776) + Math.cos(2777) * 60;
+acc += Math.sin(2777) + Math.cos(2778) * 61;
+acc += Math.sin(2778) + Math.cos(2779) * 62;
+acc += Math.sin(2779) + Math.cos(2780) * 63;
+acc += Math.sin(2780) + Math.cos(2781) * 64;
+acc += Math.sin(2781) + Math.cos(2782) * 65;
+acc += Math.sin(2782) + Math.cos(2783) * 66;
+acc += Math.sin(2783) + Math.cos(2784) * 67;
+acc += Math.sin(2784) + Math.cos(2785) * 68;
+acc += Math.sin(2785) + Math.cos(2786) * 69;
+acc += Math.sin(2786) + Math.cos(2787) * 70;
+acc += Math.sin(2787) + Math.cos(2788) * 71;
+acc += Math.sin(2788) + Math.cos(2789) * 72;
+acc += Math.sin(2789) + Math.cos(2790) * 73;
+acc += Math.sin(2790) + Math.cos(2791) * 74;
+acc += Math.sin(2791) + Math.cos(2792) * 75;
+acc += Math.sin(2792) + Math.cos(2793) * 76;
+acc += Math.sin(2793) + Math.cos(2794) * 77;
+acc += Math.sin(2794) + Math.cos(2795) * 78;
+acc += Math.sin(2795) + Math.cos(2796) * 79;
+acc += Math.sin(2796) + Math.cos(2797) * 80;
+acc += Math.sin(2797) + Math.cos(2798) * 81;
+acc += Math.sin(2798) + Math.cos(2799) * 82;
+acc += Math.sin(2799) + Math.cos(2800) * 83;
+acc += Math.sin(2800) + Math.cos(2801) * 84;
+acc += Math.sin(2801) + Math.cos(2802) * 85;
+acc += Math.sin(2802) + Math.cos(2803) * 86;
+acc += Math.sin(2803) + Math.cos(2804) * 87;
+acc += Math.sin(2804) + Math.cos(2805) * 88;
+acc += Math.sin(2805) + Math.cos(2806) * 89;
+acc += Math.sin(2806) + Math.cos(2807) * 90;
+acc += Math.sin(2807) + Math.cos(2808) * 91;
+acc += Math.sin(2808) + Math.cos(2809) * 92;
+acc += Math.sin(2809) + Math.cos(2810) * 93;
+acc += Math.sin(2810) + Math.cos(2811) * 94;
+acc += Math.sin(2811) + Math.cos(2812) * 95;
+acc += Math.sin(2812) + Math.cos(2813) * 96;
+acc += Math.sin(2813) + Math.cos(2814) * 0;
+acc += Math.sin(2814) + Math.cos(2815) * 1;
+acc += Math.sin(2815) + Math.cos(2816) * 2;
+acc += Math.sin(2816) + Math.cos(2817) * 3;
+acc += Math.sin(2817) + Math.cos(2818) * 4;
+acc += Math.sin(2818) + Math.cos(2819) * 5;
+acc += Math.sin(2819) + Math.cos(2820) * 6;
+acc += Math.sin(2820) + Math.cos(2821) * 7;
+acc += Math.sin(2821) + Math.cos(2822) * 8;
+acc += Math.sin(2822) + Math.cos(2823) * 9;
+acc += Math.sin(2823) + Math.cos(2824) * 10;
+acc += Math.sin(2824) + Math.cos(2825) * 11;
+acc += Math.sin(2825) + Math.cos(2826) * 12;
+acc += Math.sin(2826) + Math.cos(2827) * 13;
+acc += Math.sin(2827) + Math.cos(2828) * 14;
+acc += Math.sin(2828) + Math.cos(2829) * 15;
+acc += Math.sin(2829) + Math.cos(2830) * 16;
+acc += Math.sin(2830) + Math.cos(2831) * 17;
+acc += Math.sin(2831) + Math.cos(2832) * 18;
+acc += Math.sin(2832) + Math.cos(2833) * 19;
+acc += Math.sin(2833) + Math.cos(2834) * 20;
+acc += Math.sin(2834) + Math.cos(2835) * 21;
+acc += Math.sin(2835) + Math.cos(2836) * 22;
+acc += Math.sin(2836) + Math.cos(2837) * 23;
+acc += Math.sin(2837) + Math.cos(2838) * 24;
+acc += Math.sin(2838) + Math.cos(2839) * 25;
+acc += Math.sin(2839) + Math.cos(2840) * 26;
+acc += Math.sin(2840) + Math.cos(2841) * 27;
+acc += Math.sin(2841) + Math.cos(2842) * 28;
+acc += Math.sin(2842) + Math.cos(2843) * 29;
+acc += Math.sin(2843) + Math.cos(2844) * 30;
+acc += Math.sin(2844) + Math.cos(2845) * 31;
+acc += Math.sin(2845) + Math.cos(2846) * 32;
+acc += Math.sin(2846) + Math.cos(2847) * 33;
+acc += Math.sin(2847) + Math.cos(2848) * 34;
+acc += Math.sin(2848) + Math.cos(2849) * 35;
+acc += Math.sin(2849) + Math.cos(2850) * 36;
+acc += Math.sin(2850) + Math.cos(2851) * 37;
+acc += Math.sin(2851) + Math.cos(2852) * 38;
+acc += Math.sin(2852) + Math.cos(2853) * 39;
+acc += Math.sin(2853) + Math.cos(2854) * 40;
+acc += Math.sin(2854) + Math.cos(2855) * 41;
+acc += Math.sin(2855) + Math.cos(2856) * 42;
+acc += Math.sin(2856) + Math.cos(2857) * 43;
+acc += Math.sin(2857) + Math.cos(2858) * 44;
+acc += Math.sin(2858) + Math.cos(2859) * 45;
+acc += Math.sin(2859) + Math.cos(2860) * 46;
+acc += Math.sin(2860) + Math.cos(2861) * 47;
+acc += Math.sin(2861) + Math.cos(2862) * 48;
+acc += Math.sin(2862) + Math.cos(2863) * 49;
+acc += Math.sin(2863) + Math.cos(2864) * 50;
+acc += Math.sin(2864) + Math.cos(2865) * 51;
+acc += Math.sin(2865) + Math.cos(2866) * 52;
+acc += Math.sin(2866) + Math.cos(2867) * 53;
+acc += Math.sin(2867) + Math.cos(2868) * 54;
+acc += Math.sin(2868) + Math.cos(2869) * 55;
+acc += Math.sin(2869) + Math.cos(2870) * 56;
+acc += Math.sin(2870) + Math.cos(2871) * 57;
+acc += Math.sin(2871) + Math.cos(2872) * 58;
+acc += Math.sin(2872) + Math.cos(2873) * 59;
+acc += Math.sin(2873) + Math.cos(2874) * 60;
+acc += Math.sin(2874) + Math.cos(2875) * 61;
+acc += Math.sin(2875) + Math.cos(2876) * 62;
+acc += Math.sin(2876) + Math.cos(2877) * 63;
+acc += Math.sin(2877) + Math.cos(2878) * 64;
+acc += Math.sin(2878) + Math.cos(2879) * 65;
+acc += Math.sin(2879) + Math.cos(2880) * 66;
+acc += Math.sin(2880) + Math.cos(2881) * 67;
+acc += Math.sin(2881) + Math.cos(2882) * 68;
+acc += Math.sin(2882) + Math.cos(2883) * 69;
+acc += Math.sin(2883) + Math.cos(2884) * 70;
+acc += Math.sin(2884) + Math.cos(2885) * 71;
+acc += Math.sin(2885) + Math.cos(2886) * 72;
+acc += Math.sin(2886) + Math.cos(2887) * 73;
+acc += Math.sin(2887) + Math.cos(2888) * 74;
+acc += Math.sin(2888) + Math.cos(2889) * 75;
+acc += Math.sin(2889) + Math.cos(2890) * 76;
+acc += Math.sin(2890) + Math.cos(2891) * 77;
+acc += Math.sin(2891) + Math.cos(2892) * 78;
+acc += Math.sin(2892) + Math.cos(2893) * 79;
+acc += Math.sin(2893) + Math.cos(2894) * 80;
+acc += Math.sin(2894) + Math.cos(2895) * 81;
+acc += Math.sin(2895) + Math.cos(2896) * 82;
+acc += Math.sin(2896) + Math.cos(2897) * 83;
+acc += Math.sin(2897) + Math.cos(2898) * 84;
+acc += Math.sin(2898) + Math.cos(2899) * 85;
+acc += Math.sin(2899) + Math.cos(2900) * 86;
+acc += Math.sin(2900) + Math.cos(2901) * 87;
+acc += Math.sin(2901) + Math.cos(2902) * 88;
+acc += Math.sin(2902) + Math.cos(2903) * 89;
+acc += Math.sin(2903) + Math.cos(2904) * 90;
+acc += Math.sin(2904) + Math.cos(2905) * 91;
+acc += Math.sin(2905) + Math.cos(2906) * 92;
+acc += Math.sin(2906) + Math.cos(2907) * 93;
+acc += Math.sin(2907) + Math.cos(2908) * 94;
+acc += Math.sin(2908) + Math.cos(2909) * 95;
+acc += Math.sin(2909) + Math.cos(2910) * 96;
+acc += Math.sin(2910) + Math.cos(2911) * 0;
+acc += Math.sin(2911) + Math.cos(2912) * 1;
+acc += Math.sin(2912) + Math.cos(2913) * 2;
+acc += Math.sin(2913) + Math.cos(2914) * 3;
+acc += Math.sin(2914) + Math.cos(2915) * 4;
+acc += Math.sin(2915) + Math.cos(2916) * 5;
+acc += Math.sin(2916) + Math.cos(2917) * 6;
+acc += Math.sin(2917) + Math.cos(2918) * 7;
+acc += Math.sin(2918) + Math.cos(2919) * 8;
+acc += Math.sin(2919) + Math.cos(2920) * 9;
+acc += Math.sin(2920) + Math.cos(2921) * 10;
+acc += Math.sin(2921) + Math.cos(2922) * 11;
+acc += Math.sin(2922) + Math.cos(2923) * 12;
+acc += Math.sin(2923) + Math.cos(2924) * 13;
+acc += Math.sin(2924) + Math.cos(2925) * 14;
+acc += Math.sin(2925) + Math.cos(2926) * 15;
+acc += Math.sin(2926) + Math.cos(2927) * 16;
+acc += Math.sin(2927) + Math.cos(2928) * 17;
+acc += Math.sin(2928) + Math.cos(2929) * 18;
+acc += Math.sin(2929) + Math.cos(2930) * 19;
+acc += Math.sin(2930) + Math.cos(2931) * 20;
+acc += Math.sin(2931) + Math.cos(2932) * 21;
+acc += Math.sin(2932) + Math.cos(2933) * 22;
+acc += Math.sin(2933) + Math.cos(2934) * 23;
+acc += Math.sin(2934) + Math.cos(2935) * 24;
+acc += Math.sin(2935) + Math.cos(2936) * 25;
+acc += Math.sin(2936) + Math.cos(2937) * 26;
+acc += Math.sin(2937) + Math.cos(2938) * 27;
+acc += Math.sin(2938) + Math.cos(2939) * 28;
+acc += Math.sin(2939) + Math.cos(2940) * 29;
+acc += Math.sin(2940) + Math.cos(2941) * 30;
+acc += Math.sin(2941) + Math.cos(2942) * 31;
+acc += Math.sin(2942) + Math.cos(2943) * 32;
+acc += Math.sin(2943) + Math.cos(2944) * 33;
+acc += Math.sin(2944) + Math.cos(2945) * 34;
+acc += Math.sin(2945) + Math.cos(2946) * 35;
+acc += Math.sin(2946) + Math.cos(2947) * 36;
+acc += Math.sin(2947) + Math.cos(2948) * 37;
+acc += Math.sin(2948) + Math.cos(2949) * 38;
+acc += Math.sin(2949) + Math.cos(2950) * 39;
+acc += Math.sin(2950) + Math.cos(2951) * 40;
+acc += Math.sin(2951) + Math.cos(2952) * 41;
+acc += Math.sin(2952) + Math.cos(2953) * 42;
+acc += Math.sin(2953) + Math.cos(2954) * 43;
+acc += Math.sin(2954) + Math.cos(2955) * 44;
+acc += Math.sin(2955) + Math.cos(2956) * 45;
+acc += Math.sin(2956) + Math.cos(2957) * 46;
+acc += Math.sin(2957) + Math.cos(2958) * 47;
+acc += Math.sin(2958) + Math.cos(2959) * 48;
+acc += Math.sin(2959) + Math.cos(2960) * 49;
+acc += Math.sin(2960) + Math.cos(2961) * 50;
+acc += Math.sin(2961) + Math.cos(2962) * 51;
+acc += Math.sin(2962) + Math.cos(2963) * 52;
+acc += Math.sin(2963) + Math.cos(2964) * 53;
+acc += Math.sin(2964) + Math.cos(2965) * 54;
+acc += Math.sin(2965) + Math.cos(2966) * 55;
+acc += Math.sin(2966) + Math.cos(2967) * 56;
+acc += Math.sin(2967) + Math.cos(2968) * 57;
+acc += Math.sin(2968) + Math.cos(2969) * 58;
+acc += Math.sin(2969) + Math.cos(2970) * 59;
+acc += Math.sin(2970) + Math.cos(2971) * 60;
+acc += Math.sin(2971) + Math.cos(2972) * 61;
+acc += Math.sin(2972) + Math.cos(2973) * 62;
+acc += Math.sin(2973) + Math.cos(2974) * 63;
+acc += Math.sin(2974) + Math.cos(2975) * 64;
+acc += Math.sin(2975) + Math.cos(2976) * 65;
+acc += Math.sin(2976) + Math.cos(2977) * 66;
+acc += Math.sin(2977) + Math.cos(2978) * 67;
+acc += Math.sin(2978) + Math.cos(2979) * 68;
+acc += Math.sin(2979) + Math.cos(2980) * 69;
+acc += Math.sin(2980) + Math.cos(2981) * 70;
+acc += Math.sin(2981) + Math.cos(2982) * 71;
+acc += Math.sin(2982) + Math.cos(2983) * 72;
+acc += Math.sin(2983) + Math.cos(2984) * 73;
+acc += Math.sin(2984) + Math.cos(2985) * 74;
+acc += Math.sin(2985) + Math.cos(2986) * 75;
+acc += Math.sin(2986) + Math.cos(2987) * 76;
+acc += Math.sin(2987) + Math.cos(2988) * 77;
+acc += Math.sin(2988) + Math.cos(2989) * 78;
+acc += Math.sin(2989) + Math.cos(2990) * 79;
+acc += Math.sin(2990) + Math.cos(2991) * 80;
+acc += Math.sin(2991) + Math.cos(2992) * 81;
+acc += Math.sin(2992) + Math.cos(2993) * 82;
+acc += Math.sin(2993) + Math.cos(2994) * 83;
+acc += Math.sin(2994) + Math.cos(2995) * 84;
+acc += Math.sin(2995) + Math.cos(2996) * 85;
+acc += Math.sin(2996) + Math.cos(2997) * 86;
+acc += Math.sin(2997) + Math.cos(2998) * 87;
+acc += Math.sin(2998) + Math.cos(2999) * 88;
+acc += Math.sin(2999) + Math.cos(3000) * 89;
+acc += Math.sin(3000) + Math.cos(3001) * 90;
+acc += Math.sin(3001) + Math.cos(3002) * 91;
+acc += Math.sin(3002) + Math.cos(3003) * 92;
+acc += Math.sin(3003) + Math.cos(3004) * 93;
+acc += Math.sin(3004) + Math.cos(3005) * 94;
+acc += Math.sin(3005) + Math.cos(3006) * 95;
+acc += Math.sin(3006) + Math.cos(3007) * 96;
+acc += Math.sin(3007) + Math.cos(3008) * 0;
+acc += Math.sin(3008) + Math.cos(3009) * 1;
+acc += Math.sin(3009) + Math.cos(3010) * 2;
+acc += Math.sin(3010) + Math.cos(3011) * 3;
+acc += Math.sin(3011) + Math.cos(3012) * 4;
+acc += Math.sin(3012) + Math.cos(3013) * 5;
+acc += Math.sin(3013) + Math.cos(3014) * 6;
+acc += Math.sin(3014) + Math.cos(3015) * 7;
+acc += Math.sin(3015) + Math.cos(3016) * 8;
+acc += Math.sin(3016) + Math.cos(3017) * 9;
+acc += Math.sin(3017) + Math.cos(3018) * 10;
+acc += Math.sin(3018) + Math.cos(3019) * 11;
+acc += Math.sin(3019) + Math.cos(3020) * 12;
+acc += Math.sin(3020) + Math.cos(3021) * 13;
+acc += Math.sin(3021) + Math.cos(3022) * 14;
+acc += Math.sin(3022) + Math.cos(3023) * 15;
+acc += Math.sin(3023) + Math.cos(3024) * 16;
+acc += Math.sin(3024) + Math.cos(3025) * 17;
+acc += Math.sin(3025) + Math.cos(3026) * 18;
+acc += Math.sin(3026) + Math.cos(3027) * 19;
+acc += Math.sin(3027) + Math.cos(3028) * 20;
+acc += Math.sin(3028) + Math.cos(3029) * 21;
+acc += Math.sin(3029) + Math.cos(3030) * 22;
+acc += Math.sin(3030) + Math.cos(3031) * 23;
+acc += Math.sin(3031) + Math.cos(3032) * 24;
+acc += Math.sin(3032) + Math.cos(3033) * 25;
+acc += Math.sin(3033) + Math.cos(3034) * 26;
+acc += Math.sin(3034) + Math.cos(3035) * 27;
+acc += Math.sin(3035) + Math.cos(3036) * 28;
+acc += Math.sin(3036) + Math.cos(3037) * 29;
+acc += Math.sin(3037) + Math.cos(3038) * 30;
+acc += Math.sin(3038) + Math.cos(3039) * 31;
+acc += Math.sin(3039) + Math.cos(3040) * 32;
+acc += Math.sin(3040) + Math.cos(3041) * 33;
+acc += Math.sin(3041) + Math.cos(3042) * 34;
+acc += Math.sin(3042) + Math.cos(3043) * 35;
+acc += Math.sin(3043) + Math.cos(3044) * 36;
+acc += Math.sin(3044) + Math.cos(3045) * 37;
+acc += Math.sin(3045) + Math.cos(3046) * 38;
+acc += Math.sin(3046) + Math.cos(3047) * 39;
+acc += Math.sin(3047) + Math.cos(3048) * 40;
+acc += Math.sin(3048) + Math.cos(3049) * 41;
+acc += Math.sin(3049) + Math.cos(3050) * 42;
+acc += Math.sin(3050) + Math.cos(3051) * 43;
+acc += Math.sin(3051) + Math.cos(3052) * 44;
+acc += Math.sin(3052) + Math.cos(3053) * 45;
+acc += Math.sin(3053) + Math.cos(3054) * 46;
+acc += Math.sin(3054) + Math.cos(3055) * 47;
+acc += Math.sin(3055) + Math.cos(3056) * 48;
+acc += Math.sin(3056) + Math.cos(3057) * 49;
+acc += Math.sin(3057) + Math.cos(3058) * 50;
+acc += Math.sin(3058) + Math.cos(3059) * 51;
+acc += Math.sin(3059) + Math.cos(3060) * 52;
+acc += Math.sin(3060) + Math.cos(3061) * 53;
+acc += Math.sin(3061) + Math.cos(3062) * 54;
+acc += Math.sin(3062) + Math.cos(3063) * 55;
+acc += Math.sin(3063) + Math.cos(3064) * 56;
+acc += Math.sin(3064) + Math.cos(3065) * 57;
+acc += Math.sin(3065) + Math.cos(3066) * 58;
+acc += Math.sin(3066) + Math.cos(3067) * 59;
+acc += Math.sin(3067) + Math.cos(3068) * 60;
+acc += Math.sin(3068) + Math.cos(3069) * 61;
+acc += Math.sin(3069) + Math.cos(3070) * 62;
+acc += Math.sin(3070) + Math.cos(3071) * 63;
+acc += Math.sin(3071) + Math.cos(3072) * 64;
+acc += Math.sin(3072) + Math.cos(3073) * 65;
+acc += Math.sin(3073) + Math.cos(3074) * 66;
+acc += Math.sin(3074) + Math.cos(3075) * 67;
+acc += Math.sin(3075) + Math.cos(3076) * 68;
+acc += Math.sin(3076) + Math.cos(3077) * 69;
+acc += Math.sin(3077) + Math.cos(3078) * 70;
+acc += Math.sin(3078) + Math.cos(3079) * 71;
+acc += Math.sin(3079) + Math.cos(3080) * 72;
+acc += Math.sin(3080) + Math.cos(3081) * 73;
+acc += Math.sin(3081) + Math.cos(3082) * 74;
+acc += Math.sin(3082) + Math.cos(3083) * 75;
+acc += Math.sin(3083) + Math.cos(3084) * 76;
+acc += Math.sin(3084) + Math.cos(3085) * 77;
+acc += Math.sin(3085) + Math.cos(3086) * 78;
+acc += Math.sin(3086) + Math.cos(3087) * 79;
+acc += Math.sin(3087) + Math.cos(3088) * 80;
+acc += Math.sin(3088) + Math.cos(3089) * 81;
+acc += Math.sin(3089) + Math.cos(3090) * 82;
+acc += Math.sin(3090) + Math.cos(3091) * 83;
+acc += Math.sin(3091) + Math.cos(3092) * 84;
+acc += Math.sin(3092) + Math.cos(3093) * 85;
+acc += Math.sin(3093) + Math.cos(3094) * 86;
+acc += Math.sin(3094) + Math.cos(3095) * 87;
+acc += Math.sin(3095) + Math.cos(3096) * 88;
+acc += Math.sin(3096) + Math.cos(3097) * 89;
+acc += Math.sin(3097) + Math.cos(3098) * 90;
+acc += Math.sin(3098) + Math.cos(3099) * 91;
+acc += Math.sin(3099) + Math.cos(3100) * 92;
+acc += Math.sin(3100) + Math.cos(3101) * 93;
+acc += Math.sin(3101) + Math.cos(3102) * 94;
+acc += Math.sin(3102) + Math.cos(3103) * 95;
+acc += Math.sin(3103) + Math.cos(3104) * 96;
+acc += Math.sin(3104) + Math.cos(3105) * 0;
+acc += Math.sin(3105) + Math.cos(3106) * 1;
+acc += Math.sin(3106) + Math.cos(3107) * 2;
+acc += Math.sin(3107) + Math.cos(3108) * 3;
+acc += Math.sin(3108) + Math.cos(3109) * 4;
+acc += Math.sin(3109) + Math.cos(3110) * 5;
+acc += Math.sin(3110) + Math.cos(3111) * 6;
+acc += Math.sin(3111) + Math.cos(3112) * 7;
+acc += Math.sin(3112) + Math.cos(3113) * 8;
+acc += Math.sin(3113) + Math.cos(3114) * 9;
+acc += Math.sin(3114) + Math.cos(3115) * 10;
+acc += Math.sin(3115) + Math.cos(3116) * 11;
+acc += Math.sin(3116) + Math.cos(3117) * 12;
+acc += Math.sin(3117) + Math.cos(3118) * 13;
+acc += Math.sin(3118) + Math.cos(3119) * 14;
+acc += Math.sin(3119) + Math.cos(3120) * 15;
+acc += Math.sin(3120) + Math.cos(3121) * 16;
+acc += Math.sin(3121) + Math.cos(3122) * 17;
+acc += Math.sin(3122) + Math.cos(3123) * 18;
+acc += Math.sin(3123) + Math.cos(3124) * 19;
+acc += Math.sin(3124) + Math.cos(3125) * 20;
+acc += Math.sin(3125) + Math.cos(3126) * 21;
+acc += Math.sin(3126) + Math.cos(3127) * 22;
+acc += Math.sin(3127) + Math.cos(3128) * 23;
+acc += Math.sin(3128) + Math.cos(3129) * 24;
+acc += Math.sin(3129) + Math.cos(3130) * 25;
+acc += Math.sin(3130) + Math.cos(3131) * 26;
+acc += Math.sin(3131) + Math.cos(3132) * 27;
+acc += Math.sin(3132) + Math.cos(3133) * 28;
+acc += Math.sin(3133) + Math.cos(3134) * 29;
+acc += Math.sin(3134) + Math.cos(3135) * 30;
+acc += Math.sin(3135) + Math.cos(3136) * 31;
+acc += Math.sin(3136) + Math.cos(3137) * 32;
+acc += Math.sin(3137) + Math.cos(3138) * 33;
+acc += Math.sin(3138) + Math.cos(3139) * 34;
+acc += Math.sin(3139) + Math.cos(3140) * 35;
+acc += Math.sin(3140) + Math.cos(3141) * 36;
+acc += Math.sin(3141) + Math.cos(3142) * 37;
+acc += Math.sin(3142) + Math.cos(3143) * 38;
+acc += Math.sin(3143) + Math.cos(3144) * 39;
+acc += Math.sin(3144) + Math.cos(3145) * 40;
+acc += Math.sin(3145) + Math.cos(3146) * 41;
+acc += Math.sin(3146) + Math.cos(3147) * 42;
+acc += Math.sin(3147) + Math.cos(3148) * 43;
+acc += Math.sin(3148) + Math.cos(3149) * 44;
+acc += Math.sin(3149) + Math.cos(3150) * 45;
+acc += Math.sin(3150) + Math.cos(3151) * 46;
+acc += Math.sin(3151) + Math.cos(3152) * 47;
+acc += Math.sin(3152) + Math.cos(3153) * 48;
+acc += Math.sin(3153) + Math.cos(3154) * 49;
+acc += Math.sin(3154) + Math.cos(3155) * 50;
+acc += Math.sin(3155) + Math.cos(3156) * 51;
+acc += Math.sin(3156) + Math.cos(3157) * 52;
+acc += Math.sin(3157) + Math.cos(3158) * 53;
+acc += Math.sin(3158) + Math.cos(3159) * 54;
+acc += Math.sin(3159) + Math.cos(3160) * 55;
+acc += Math.sin(3160) + Math.cos(3161) * 56;
+acc += Math.sin(3161) + Math.cos(3162) * 57;
+acc += Math.sin(3162) + Math.cos(3163) * 58;
+acc += Math.sin(3163) + Math.cos(3164) * 59;
+acc += Math.sin(3164) + Math.cos(3165) * 60;
+acc += Math.sin(3165) + Math.cos(3166) * 61;
+acc += Math.sin(3166) + Math.cos(3167) * 62;
+acc += Math.sin(3167) + Math.cos(3168) * 63;
+acc += Math.sin(3168) + Math.cos(3169) * 64;
+acc += Math.sin(3169) + Math.cos(3170) * 65;
+acc += Math.sin(3170) + Math.cos(3171) * 66;
+acc += Math.sin(3171) + Math.cos(3172) * 67;
+acc += Math.sin(3172) + Math.cos(3173) * 68;
+acc += Math.sin(3173) + Math.cos(3174) * 69;
+acc += Math.sin(3174) + Math.cos(3175) * 70;
+acc += Math.sin(3175) + Math.cos(3176) * 71;
+acc += Math.sin(3176) + Math.cos(3177) * 72;
+acc += Math.sin(3177) + Math.cos(3178) * 73;
+acc += Math.sin(3178) + Math.cos(3179) * 74;
+acc += Math.sin(3179) + Math.cos(3180) * 75;
+acc += Math.sin(3180) + Math.cos(3181) * 76;
+acc += Math.sin(3181) + Math.cos(3182) * 77;
+acc += Math.sin(3182) + Math.cos(3183) * 78;
+acc += Math.sin(3183) + Math.cos(3184) * 79;
+acc += Math.sin(3184) + Math.cos(3185) * 80;
+acc += Math.sin(3185) + Math.cos(3186) * 81;
+acc += Math.sin(3186) + Math.cos(3187) * 82;
+acc += Math.sin(3187) + Math.cos(3188) * 83;
+acc += Math.sin(3188) + Math.cos(3189) * 84;
+acc += Math.sin(3189) + Math.cos(3190) * 85;
+acc += Math.sin(3190) + Math.cos(3191) * 86;
+acc += Math.sin(3191) + Math.cos(3192) * 87;
+acc += Math.sin(3192) + Math.cos(3193) * 88;
+acc += Math.sin(3193) + Math.cos(3194) * 89;
+acc += Math.sin(3194) + Math.cos(3195) * 90;
+acc += Math.sin(3195) + Math.cos(3196) * 91;
+acc += Math.sin(3196) + Math.cos(3197) * 92;
+acc += Math.sin(3197) + Math.cos(3198) * 93;
+acc += Math.sin(3198) + Math.cos(3199) * 94;
+acc += Math.sin(3199) + Math.cos(3200) * 95;
+acc += Math.sin(3200) + Math.cos(3201) * 96;
+acc += Math.sin(3201) + Math.cos(3202) * 0;
+acc += Math.sin(3202) + Math.cos(3203) * 1;
+acc += Math.sin(3203) + Math.cos(3204) * 2;
+acc += Math.sin(3204) + Math.cos(3205) * 3;
+acc += Math.sin(3205) + Math.cos(3206) * 4;
+acc += Math.sin(3206) + Math.cos(3207) * 5;
+acc += Math.sin(3207) + Math.cos(3208) * 6;
+acc += Math.sin(3208) + Math.cos(3209) * 7;
+acc += Math.sin(3209) + Math.cos(3210) * 8;
+acc += Math.sin(3210) + Math.cos(3211) * 9;
+acc += Math.sin(3211) + Math.cos(3212) * 10;
+acc += Math.sin(3212) + Math.cos(3213) * 11;
+acc += Math.sin(3213) + Math.cos(3214) * 12;
+acc += Math.sin(3214) + Math.cos(3215) * 13;
+acc += Math.sin(3215) + Math.cos(3216) * 14;
+acc += Math.sin(3216) + Math.cos(3217) * 15;
+acc += Math.sin(3217) + Math.cos(3218) * 16;
+acc += Math.sin(3218) + Math.cos(3219) * 17;
+acc += Math.sin(3219) + Math.cos(3220) * 18;
+acc += Math.sin(3220) + Math.cos(3221) * 19;
+acc += Math.sin(3221) + Math.cos(3222) * 20;
+acc += Math.sin(3222) + Math.cos(3223) * 21;
+acc += Math.sin(3223) + Math.cos(3224) * 22;
+acc += Math.sin(3224) + Math.cos(3225) * 23;
+acc += Math.sin(3225) + Math.cos(3226) * 24;
+acc += Math.sin(3226) + Math.cos(3227) * 25;
+acc += Math.sin(3227) + Math.cos(3228) * 26;
+acc += Math.sin(3228) + Math.cos(3229) * 27;
+acc += Math.sin(3229) + Math.cos(3230) * 28;
+acc += Math.sin(3230) + Math.cos(3231) * 29;
+acc += Math.sin(3231) + Math.cos(3232) * 30;
+acc += Math.sin(3232) + Math.cos(3233) * 31;
+acc += Math.sin(3233) + Math.cos(3234) * 32;
+acc += Math.sin(3234) + Math.cos(3235) * 33;
+acc += Math.sin(3235) + Math.cos(3236) * 34;
+acc += Math.sin(3236) + Math.cos(3237) * 35;
+acc += Math.sin(3237) + Math.cos(3238) * 36;
+acc += Math.sin(3238) + Math.cos(3239) * 37;
+acc += Math.sin(3239) + Math.cos(3240) * 38;
+acc += Math.sin(3240) + Math.cos(3241) * 39;
+acc += Math.sin(3241) + Math.cos(3242) * 40;
+acc += Math.sin(3242) + Math.cos(3243) * 41;
+acc += Math.sin(3243) + Math.cos(3244) * 42;
+acc += Math.sin(3244) + Math.cos(3245) * 43;
+acc += Math.sin(3245) + Math.cos(3246) * 44;
+acc += Math.sin(3246) + Math.cos(3247) * 45;
+acc += Math.sin(3247) + Math.cos(3248) * 46;
+acc += Math.sin(3248) + Math.cos(3249) * 47;
+acc += Math.sin(3249) + Math.cos(3250) * 48;
+acc += Math.sin(3250) + Math.cos(3251) * 49;
+acc += Math.sin(3251) + Math.cos(3252) * 50;
+acc += Math.sin(3252) + Math.cos(3253) * 51;
+acc += Math.sin(3253) + Math.cos(3254) * 52;
+acc += Math.sin(3254) + Math.cos(3255) * 53;
+acc += Math.sin(3255) + Math.cos(3256) * 54;
+acc += Math.sin(3256) + Math.cos(3257) * 55;
+acc += Math.sin(3257) + Math.cos(3258) * 56;
+acc += Math.sin(3258) + Math.cos(3259) * 57;
+acc += Math.sin(3259) + Math.cos(3260) * 58;
+acc += Math.sin(3260) + Math.cos(3261) * 59;
+acc += Math.sin(3261) + Math.cos(3262) * 60;
+acc += Math.sin(3262) + Math.cos(3263) * 61;
+acc += Math.sin(3263) + Math.cos(3264) * 62;
+acc += Math.sin(3264) + Math.cos(3265) * 63;
+acc += Math.sin(3265) + Math.cos(3266) * 64;
+acc += Math.sin(3266) + Math.cos(3267) * 65;
+acc += Math.sin(3267) + Math.cos(3268) * 66;
+acc += Math.sin(3268) + Math.cos(3269) * 67;
+acc += Math.sin(3269) + Math.cos(3270) * 68;
+acc += Math.sin(3270) + Math.cos(3271) * 69;
+acc += Math.sin(3271) + Math.cos(3272) * 70;
+acc += Math.sin(3272) + Math.cos(3273) * 71;
+acc += Math.sin(3273) + Math.cos(3274) * 72;
+acc += Math.sin(3274) + Math.cos(3275) * 73;
+acc += Math.sin(3275) + Math.cos(3276) * 74;
+acc += Math.sin(3276) + Math.cos(3277) * 75;
+acc += Math.sin(3277) + Math.cos(3278) * 76;
+acc += Math.sin(3278) + Math.cos(3279) * 77;
+acc += Math.sin(3279) + Math.cos(3280) * 78;
+acc += Math.sin(3280) + Math.cos(3281) * 79;
+acc += Math.sin(3281) + Math.cos(3282) * 80;
+acc += Math.sin(3282) + Math.cos(3283) * 81;
+acc += Math.sin(3283) + Math.cos(3284) * 82;
+acc += Math.sin(3284) + Math.cos(3285) * 83;
+acc += Math.sin(3285) + Math.cos(3286) * 84;
+acc += Math.sin(3286) + Math.cos(3287) * 85;
+acc += Math.sin(3287) + Math.cos(3288) * 86;
+acc += Math.sin(3288) + Math.cos(3289) * 87;
+acc += Math.sin(3289) + Math.cos(3290) * 88;
+acc += Math.sin(3290) + Math.cos(3291) * 89;
+acc += Math.sin(3291) + Math.cos(3292) * 90;
+acc += Math.sin(3292) + Math.cos(3293) * 91;
+acc += Math.sin(3293) + Math.cos(3294) * 92;
+acc += Math.sin(3294) + Math.cos(3295) * 93;
+acc += Math.sin(3295) + Math.cos(3296) * 94;
+acc += Math.sin(3296) + Math.cos(3297) * 95;
+acc += Math.sin(3297) + Math.cos(3298) * 96;
+acc += Math.sin(3298) + Math.cos(3299) * 0;
+acc += Math.sin(3299) + Math.cos(3300) * 1;
+acc += Math.sin(3300) + Math.cos(3301) * 2;
+acc += Math.sin(3301) + Math.cos(3302) * 3;
+acc += Math.sin(3302) + Math.cos(3303) * 4;
+acc += Math.sin(3303) + Math.cos(3304) * 5;
+acc += Math.sin(3304) + Math.cos(3305) * 6;
+acc += Math.sin(3305) + Math.cos(3306) * 7;
+acc += Math.sin(3306) + Math.cos(3307) * 8;
+acc += Math.sin(3307) + Math.cos(3308) * 9;
+acc += Math.sin(3308) + Math.cos(3309) * 10;
+acc += Math.sin(3309) + Math.cos(3310) * 11;
+acc += Math.sin(3310) + Math.cos(3311) * 12;
+acc += Math.sin(3311) + Math.cos(3312) * 13;
+acc += Math.sin(3312) + Math.cos(3313) * 14;
+acc += Math.sin(3313) + Math.cos(3314) * 15;
+acc += Math.sin(3314) + Math.cos(3315) * 16;
+acc += Math.sin(3315) + Math.cos(3316) * 17;
+acc += Math.sin(3316) + Math.cos(3317) * 18;
+acc += Math.sin(3317) + Math.cos(3318) * 19;
+acc += Math.sin(3318) + Math.cos(3319) * 20;
+acc += Math.sin(3319) + Math.cos(3320) * 21;
+acc += Math.sin(3320) + Math.cos(3321) * 22;
+acc += Math.sin(3321) + Math.cos(3322) * 23;
+acc += Math.sin(3322) + Math.cos(3323) * 24;
+acc += Math.sin(3323) + Math.cos(3324) * 25;
+acc += Math.sin(3324) + Math.cos(3325) * 26;
+acc += Math.sin(3325) + Math.cos(3326) * 27;
+acc += Math.sin(3326) + Math.cos(3327) * 28;
+acc += Math.sin(3327) + Math.cos(3328) * 29;
+acc += Math.sin(3328) + Math.cos(3329) * 30;
+acc += Math.sin(3329) + Math.cos(3330) * 31;
+acc += Math.sin(3330) + Math.cos(3331) * 32;
+acc += Math.sin(3331) + Math.cos(3332) * 33;
+acc += Math.sin(3332) + Math.cos(3333) * 34;
+acc += Math.sin(3333) + Math.cos(3334) * 35;
+acc += Math.sin(3334) + Math.cos(3335) * 36;
+acc += Math.sin(3335) + Math.cos(3336) * 37;
+acc += Math.sin(3336) + Math.cos(3337) * 38;
+acc += Math.sin(3337) + Math.cos(3338) * 39;
+acc += Math.sin(3338) + Math.cos(3339) * 40;
+acc += Math.sin(3339) + Math.cos(3340) * 41;
+acc += Math.sin(3340) + Math.cos(3341) * 42;
+acc += Math.sin(3341) + Math.cos(3342) * 43;
+acc += Math.sin(3342) + Math.cos(3343) * 44;
+acc += Math.sin(3343) + Math.cos(3344) * 45;
+acc += Math.sin(3344) + Math.cos(3345) * 46;
+acc += Math.sin(3345) + Math.cos(3346) * 47;
+acc += Math.sin(3346) + Math.cos(3347) * 48;
+acc += Math.sin(3347) + Math.cos(3348) * 49;
+acc += Math.sin(3348) + Math.cos(3349) * 50;
+acc += Math.sin(3349) + Math.cos(3350) * 51;
+acc += Math.sin(3350) + Math.cos(3351) * 52;
+acc += Math.sin(3351) + Math.cos(3352) * 53;
+acc += Math.sin(3352) + Math.cos(3353) * 54;
+acc += Math.sin(3353) + Math.cos(3354) * 55;
+acc += Math.sin(3354) + Math.cos(3355) * 56;
+acc += Math.sin(3355) + Math.cos(3356) * 57;
+acc += Math.sin(3356) + Math.cos(3357) * 58;
+acc += Math.sin(3357) + Math.cos(3358) * 59;
+acc += Math.sin(3358) + Math.cos(3359) * 60;
+acc += Math.sin(3359) + Math.cos(3360) * 61;
+acc += Math.sin(3360) + Math.cos(3361) * 62;
+acc += Math.sin(3361) + Math.cos(3362) * 63;
+acc += Math.sin(3362) + Math.cos(3363) * 64;
+acc += Math.sin(3363) + Math.cos(3364) * 65;
+acc += Math.sin(3364) + Math.cos(3365) * 66;
+acc += Math.sin(3365) + Math.cos(3366) * 67;
+acc += Math.sin(3366) + Math.cos(3367) * 68;
+acc += Math.sin(3367) + Math.cos(3368) * 69;
+acc += Math.sin(3368) + Math.cos(3369) * 70;
+acc += Math.sin(3369) + Math.cos(3370) * 71;
+acc += Math.sin(3370) + Math.cos(3371) * 72;
+acc += Math.sin(3371) + Math.cos(3372) * 73;
+acc += Math.sin(3372) + Math.cos(3373) * 74;
+acc += Math.sin(3373) + Math.cos(3374) * 75;
+acc += Math.sin(3374) + Math.cos(3375) * 76;
+acc += Math.sin(3375) + Math.cos(3376) * 77;
+acc += Math.sin(3376) + Math.cos(3377) * 78;
+acc += Math.sin(3377) + Math.cos(3378) * 79;
+acc += Math.sin(3378) + Math.cos(3379) * 80;
+acc += Math.sin(3379) + Math.cos(3380) * 81;
+acc += Math.sin(3380) + Math.cos(3381) * 82;
+acc += Math.sin(3381) + Math.cos(3382) * 83;
+acc += Math.sin(3382) + Math.cos(3383) * 84;
+acc += Math.sin(3383) + Math.cos(3384) * 85;
+acc += Math.sin(3384) + Math.cos(3385) * 86;
+acc += Math.sin(3385) + Math.cos(3386) * 87;
+acc += Math.sin(3386) + Math.cos(3387) * 88;
+acc += Math.sin(3387) + Math.cos(3388) * 89;
+acc += Math.sin(3388) + Math.cos(3389) * 90;
+acc += Math.sin(3389) + Math.cos(3390) * 91;
+acc += Math.sin(3390) + Math.cos(3391) * 92;
+acc += Math.sin(3391) + Math.cos(3392) * 93;
+acc += Math.sin(3392) + Math.cos(3393) * 94;
+acc += Math.sin(3393) + Math.cos(3394) * 95;
+acc += Math.sin(3394) + Math.cos(3395) * 96;
+acc += Math.sin(3395) + Math.cos(3396) * 0;
+acc += Math.sin(3396) + Math.cos(3397) * 1;
+acc += Math.sin(3397) + Math.cos(3398) * 2;
+acc += Math.sin(3398) + Math.cos(3399) * 3;
+acc += Math.sin(3399) + Math.cos(3400) * 4;
+acc += Math.sin(3400) + Math.cos(3401) * 5;
+acc += Math.sin(3401) + Math.cos(3402) * 6;
+acc += Math.sin(3402) + Math.cos(3403) * 7;
+acc += Math.sin(3403) + Math.cos(3404) * 8;
+acc += Math.sin(3404) + Math.cos(3405) * 9;
+acc += Math.sin(3405) + Math.cos(3406) * 10;
+acc += Math.sin(3406) + Math.cos(3407) * 11;
+acc += Math.sin(3407) + Math.cos(3408) * 12;
+acc += Math.sin(3408) + Math.cos(3409) * 13;
+acc += Math.sin(3409) + Math.cos(3410) * 14;
+acc += Math.sin(3410) + Math.cos(3411) * 15;
+acc += Math.sin(3411) + Math.cos(3412) * 16;
+acc += Math.sin(3412) + Math.cos(3413) * 17;
+acc += Math.sin(3413) + Math.cos(3414) * 18;
+acc += Math.sin(3414) + Math.cos(3415) * 19;
+acc += Math.sin(3415) + Math.cos(3416) * 20;
+acc += Math.sin(3416) + Math.cos(3417) * 21;
+acc += Math.sin(3417) + Math.cos(3418) * 22;
+acc += Math.sin(3418) + Math.cos(3419) * 23;
+acc += Math.sin(3419) + Math.cos(3420) * 24;
+acc += Math.sin(3420) + Math.cos(3421) * 25;
+acc += Math.sin(3421) + Math.cos(3422) * 26;
+acc += Math.sin(3422) + Math.cos(3423) * 27;
+acc += Math.sin(3423) + Math.cos(3424) * 28;
+acc += Math.sin(3424) + Math.cos(3425) * 29;
+acc += Math.sin(3425) + Math.cos(3426) * 30;
+acc += Math.sin(3426) + Math.cos(3427) * 31;
+acc += Math.sin(3427) + Math.cos(3428) * 32;
+acc += Math.sin(3428) + Math.cos(3429) * 33;
+acc += Math.sin(3429) + Math.cos(3430) * 34;
+acc += Math.sin(3430) + Math.cos(3431) * 35;
+acc += Math.sin(3431) + Math.cos(3432) * 36;
+acc += Math.sin(3432) + Math.cos(3433) * 37;
+acc += Math.sin(3433) + Math.cos(3434) * 38;
+acc += Math.sin(3434) + Math.cos(3435) * 39;
+acc += Math.sin(3435) + Math.cos(3436) * 40;
+acc += Math.sin(3436) + Math.cos(3437) * 41;
+acc += Math.sin(3437) + Math.cos(3438) * 42;
+acc += Math.sin(3438) + Math.cos(3439) * 43;
+acc += Math.sin(3439) + Math.cos(3440) * 44;
+acc += Math.sin(3440) + Math.cos(3441) * 45;
+acc += Math.sin(3441) + Math.cos(3442) * 46;
+acc += Math.sin(3442) + Math.cos(3443) * 47;
+acc += Math.sin(3443) + Math.cos(3444) * 48;
+acc += Math.sin(3444) + Math.cos(3445) * 49;
+acc += Math.sin(3445) + Math.cos(3446) * 50;
+acc += Math.sin(3446) + Math.cos(3447) * 51;
+acc += Math.sin(3447) + Math.cos(3448) * 52;
+acc += Math.sin(3448) + Math.cos(3449) * 53;
+acc += Math.sin(3449) + Math.cos(3450) * 54;
+acc += Math.sin(3450) + Math.cos(3451) * 55;
+acc += Math.sin(3451) + Math.cos(3452) * 56;
+acc += Math.sin(3452) + Math.cos(3453) * 57;
+acc += Math.sin(3453) + Math.cos(3454) * 58;
+acc += Math.sin(3454) + Math.cos(3455) * 59;
+acc += Math.sin(3455) + Math.cos(3456) * 60;
+acc += Math.sin(3456) + Math.cos(3457) * 61;
+acc += Math.sin(3457) + Math.cos(3458) * 62;
+acc += Math.sin(3458) + Math.cos(3459) * 63;
+acc += Math.sin(3459) + Math.cos(3460) * 64;
+acc += Math.sin(3460) + Math.cos(3461) * 65;
+acc += Math.sin(3461) + Math.cos(3462) * 66;
+acc += Math.sin(3462) + Math.cos(3463) * 67;
+acc += Math.sin(3463) + Math.cos(3464) * 68;
+acc += Math.sin(3464) + Math.cos(3465) * 69;
+acc += Math.sin(3465) + Math.cos(3466) * 70;
+acc += Math.sin(3466) + Math.cos(3467) * 71;
+acc += Math.sin(3467) + Math.cos(3468) * 72;
+acc += Math.sin(3468) + Math.cos(3469) * 73;
+acc += Math.sin(3469) + Math.cos(3470) * 74;
+acc += Math.sin(3470) + Math.cos(3471) * 75;
+acc += Math.sin(3471) + Math.cos(3472) * 76;
+acc += Math.sin(3472) + Math.cos(3473) * 77;
+acc += Math.sin(3473) + Math.cos(3474) * 78;
+acc += Math.sin(3474) + Math.cos(3475) * 79;
+acc += Math.sin(3475) + Math.cos(3476) * 80;
+acc += Math.sin(3476) + Math.cos(3477) * 81;
+acc += Math.sin(3477) + Math.cos(3478) * 82;
+acc += Math.sin(3478) + Math.cos(3479) * 83;
+acc += Math.sin(3479) + Math.cos(3480) * 84;
+acc += Math.sin(3480) + Math.cos(3481) * 85;
+acc += Math.sin(3481) + Math.cos(3482) * 86;
+acc += Math.sin(3482) + Math.cos(3483) * 87;
+acc += Math.sin(3483) + Math.cos(3484) * 88;
+acc += Math.sin(3484) + Math.cos(3485) * 89;
+acc += Math.sin(3485) + Math.cos(3486) * 90;
+acc += Math.sin(3486) + Math.cos(3487) * 91;
+acc += Math.sin(3487) + Math.cos(3488) * 92;
+acc += Math.sin(3488) + Math.cos(3489) * 93;
+acc += Math.sin(3489) + Math.cos(3490) * 94;
+acc += Math.sin(3490) + Math.cos(3491) * 95;
+acc += Math.sin(3491) + Math.cos(3492) * 96;
+acc += Math.sin(3492) + Math.cos(3493) * 0;
+acc += Math.sin(3493) + Math.cos(3494) * 1;
+acc += Math.sin(3494) + Math.cos(3495) * 2;
+acc += Math.sin(3495) + Math.cos(3496) * 3;
+acc += Math.sin(3496) + Math.cos(3497) * 4;
+acc += Math.sin(3497) + Math.cos(3498) * 5;
+acc += Math.sin(3498) + Math.cos(3499) * 6;
+acc += Math.sin(3499) + Math.cos(3500) * 7;
+acc += Math.sin(3500) + Math.cos(3501) * 8;
+acc += Math.sin(3501) + Math.cos(3502) * 9;
+acc += Math.sin(3502) + Math.cos(3503) * 10;
+acc += Math.sin(3503) + Math.cos(3504) * 11;
+acc += Math.sin(3504) + Math.cos(3505) * 12;
+acc += Math.sin(3505) + Math.cos(3506) * 13;
+acc += Math.sin(3506) + Math.cos(3507) * 14;
+acc += Math.sin(3507) + Math.cos(3508) * 15;
+acc += Math.sin(3508) + Math.cos(3509) * 16;
+acc += Math.sin(3509) + Math.cos(3510) * 17;
+acc += Math.sin(3510) + Math.cos(3511) * 18;
+acc += Math.sin(3511) + Math.cos(3512) * 19;
+acc += Math.sin(3512) + Math.cos(3513) * 20;
+acc += Math.sin(3513) + Math.cos(3514) * 21;
+acc += Math.sin(3514) + Math.cos(3515) * 22;
+acc += Math.sin(3515) + Math.cos(3516) * 23;
+acc += Math.sin(3516) + Math.cos(3517) * 24;
+acc += Math.sin(3517) + Math.cos(3518) * 25;
+acc += Math.sin(3518) + Math.cos(3519) * 26;
+acc += Math.sin(3519) + Math.cos(3520) * 27;
+acc += Math.sin(3520) + Math.cos(3521) * 28;
+acc += Math.sin(3521) + Math.cos(3522) * 29;
+acc += Math.sin(3522) + Math.cos(3523) * 30;
+acc += Math.sin(3523) + Math.cos(3524) * 31;
+acc += Math.sin(3524) + Math.cos(3525) * 32;
+acc += Math.sin(3525) + Math.cos(3526) * 33;
+acc += Math.sin(3526) + Math.cos(3527) * 34;
+acc += Math.sin(3527) + Math.cos(3528) * 35;
+acc += Math.sin(3528) + Math.cos(3529) * 36;
+acc += Math.sin(3529) + Math.cos(3530) * 37;
+acc += Math.sin(3530) + Math.cos(3531) * 38;
+acc += Math.sin(3531) + Math.cos(3532) * 39;
+acc += Math.sin(3532) + Math.cos(3533) * 40;
+acc += Math.sin(3533) + Math.cos(3534) * 41;
+acc += Math.sin(3534) + Math.cos(3535) * 42;
+acc += Math.sin(3535) + Math.cos(3536) * 43;
+acc += Math.sin(3536) + Math.cos(3537) * 44;
+acc += Math.sin(3537) + Math.cos(3538) * 45;
+acc += Math.sin(3538) + Math.cos(3539) * 46;
+acc += Math.sin(3539) + Math.cos(3540) * 47;
+acc += Math.sin(3540) + Math.cos(3541) * 48;
+acc += Math.sin(3541) + Math.cos(3542) * 49;
+acc += Math.sin(3542) + Math.cos(3543) * 50;
+acc += Math.sin(3543) + Math.cos(3544) * 51;
+acc += Math.sin(3544) + Math.cos(3545) * 52;
+acc += Math.sin(3545) + Math.cos(3546) * 53;
+acc += Math.sin(3546) + Math.cos(3547) * 54;
+acc += Math.sin(3547) + Math.cos(3548) * 55;
+acc += Math.sin(3548) + Math.cos(3549) * 56;
+acc += Math.sin(3549) + Math.cos(3550) * 57;
+acc += Math.sin(3550) + Math.cos(3551) * 58;
+acc += Math.sin(3551) + Math.cos(3552) * 59;
+acc += Math.sin(3552) + Math.cos(3553) * 60;
+acc += Math.sin(3553) + Math.cos(3554) * 61;
+acc += Math.sin(3554) + Math.cos(3555) * 62;
+acc += Math.sin(3555) + Math.cos(3556) * 63;
+acc += Math.sin(3556) + Math.cos(3557) * 64;
+acc += Math.sin(3557) + Math.cos(3558) * 65;
+acc += Math.sin(3558) + Math.cos(3559) * 66;
+acc += Math.sin(3559) + Math.cos(3560) * 67;
+acc += Math.sin(3560) + Math.cos(3561) * 68;
+acc += Math.sin(3561) + Math.cos(3562) * 69;
+acc += Math.sin(3562) + Math.cos(3563) * 70;
+acc += Math.sin(3563) + Math.cos(3564) * 71;
+acc += Math.sin(3564) + Math.cos(3565) * 72;
+acc += Math.sin(3565) + Math.cos(3566) * 73;
+acc += Math.sin(3566) + Math.cos(3567) * 74;
+acc += Math.sin(3567) + Math.cos(3568) * 75;
+acc += Math.sin(3568) + Math.cos(3569) * 76;
+acc += Math.sin(3569) + Math.cos(3570) * 77;
+acc += Math.sin(3570) + Math.cos(3571) * 78;
+acc += Math.sin(3571) + Math.cos(3572) * 79;
+acc += Math.sin(3572) + Math.cos(3573) * 80;
+acc += Math.sin(3573) + Math.cos(3574) * 81;
+acc += Math.sin(3574) + Math.cos(3575) * 82;
+acc += Math.sin(3575) + Math.cos(3576) * 83;
+acc += Math.sin(3576) + Math.cos(3577) * 84;
+acc += Math.sin(3577) + Math.cos(3578) * 85;
+acc += Math.sin(3578) + Math.cos(3579) * 86;
+acc += Math.sin(3579) + Math.cos(3580) * 87;
+acc += Math.sin(3580) + Math.cos(3581) * 88;
+acc += Math.sin(3581) + Math.cos(3582) * 89;
+acc += Math.sin(3582) + Math.cos(3583) * 90;
+acc += Math.sin(3583) + Math.cos(3584) * 91;
+acc += Math.sin(3584) + Math.cos(3585) * 92;
+acc += Math.sin(3585) + Math.cos(3586) * 93;
+acc += Math.sin(3586) + Math.cos(3587) * 94;
+acc += Math.sin(3587) + Math.cos(3588) * 95;
+acc += Math.sin(3588) + Math.cos(3589) * 96;
+acc += Math.sin(3589) + Math.cos(3590) * 0;
+acc += Math.sin(3590) + Math.cos(3591) * 1;
+acc += Math.sin(3591) + Math.cos(3592) * 2;
+acc += Math.sin(3592) + Math.cos(3593) * 3;
+acc += Math.sin(3593) + Math.cos(3594) * 4;
+acc += Math.sin(3594) + Math.cos(3595) * 5;
+acc += Math.sin(3595) + Math.cos(3596) * 6;
+acc += Math.sin(3596) + Math.cos(3597) * 7;
+acc += Math.sin(3597) + Math.cos(3598) * 8;
+acc += Math.sin(3598) + Math.cos(3599) * 9;
+acc += Math.sin(3599) + Math.cos(3600) * 10;
+acc += Math.sin(3600) + Math.cos(3601) * 11;
+acc += Math.sin(3601) + Math.cos(3602) * 12;
+acc += Math.sin(3602) + Math.cos(3603) * 13;
+acc += Math.sin(3603) + Math.cos(3604) * 14;
+acc += Math.sin(3604) + Math.cos(3605) * 15;
+acc += Math.sin(3605) + Math.cos(3606) * 16;
+acc += Math.sin(3606) + Math.cos(3607) * 17;
+acc += Math.sin(3607) + Math.cos(3608) * 18;
+acc += Math.sin(3608) + Math.cos(3609) * 19;
+acc += Math.sin(3609) + Math.cos(3610) * 20;
+acc += Math.sin(3610) + Math.cos(3611) * 21;
+acc += Math.sin(3611) + Math.cos(3612) * 22;
+acc += Math.sin(3612) + Math.cos(3613) * 23;
+acc += Math.sin(3613) + Math.cos(3614) * 24;
+acc += Math.sin(3614) + Math.cos(3615) * 25;
+acc += Math.sin(3615) + Math.cos(3616) * 26;
+acc += Math.sin(3616) + Math.cos(3617) * 27;
+acc += Math.sin(3617) + Math.cos(3618) * 28;
+acc += Math.sin(3618) + Math.cos(3619) * 29;
+acc += Math.sin(3619) + Math.cos(3620) * 30;
+acc += Math.sin(3620) + Math.cos(3621) * 31;
+acc += Math.sin(3621) + Math.cos(3622) * 32;
+acc += Math.sin(3622) + Math.cos(3623) * 33;
+acc += Math.sin(3623) + Math.cos(3624) * 34;
+acc += Math.sin(3624) + Math.cos(3625) * 35;
+acc += Math.sin(3625) + Math.cos(3626) * 36;
+acc += Math.sin(3626) + Math.cos(3627) * 37;
+acc += Math.sin(3627) + Math.cos(3628) * 38;
+acc += Math.sin(3628) + Math.cos(3629) * 39;
+acc += Math.sin(3629) + Math.cos(3630) * 40;
+acc += Math.sin(3630) + Math.cos(3631) * 41;
+acc += Math.sin(3631) + Math.cos(3632) * 42;
+acc += Math.sin(3632) + Math.cos(3633) * 43;
+acc += Math.sin(3633) + Math.cos(3634) * 44;
+acc += Math.sin(3634) + Math.cos(3635) * 45;
+acc += Math.sin(3635) + Math.cos(3636) * 46;
+acc += Math.sin(3636) + Math.cos(3637) * 47;
+acc += Math.sin(3637) + Math.cos(3638) * 48;
+acc += Math.sin(3638) + Math.cos(3639) * 49;
+acc += Math.sin(3639) + Math.cos(3640) * 50;
+acc += Math.sin(3640) + Math.cos(3641) * 51;
+acc += Math.sin(3641) + Math.cos(3642) * 52;
+acc += Math.sin(3642) + Math.cos(3643) * 53;
+acc += Math.sin(3643) + Math.cos(3644) * 54;
+acc += Math.sin(3644) + Math.cos(3645) * 55;
+acc += Math.sin(3645) + Math.cos(3646) * 56;
+acc += Math.sin(3646) + Math.cos(3647) * 57;
+acc += Math.sin(3647) + Math.cos(3648) * 58;
+acc += Math.sin(3648) + Math.cos(3649) * 59;
+acc += Math.sin(3649) + Math.cos(3650) * 60;
+acc += Math.sin(3650) + Math.cos(3651) * 61;
+acc += Math.sin(3651) + Math.cos(3652) * 62;
+acc += Math.sin(3652) + Math.cos(3653) * 63;
+acc += Math.sin(3653) + Math.cos(3654) * 64;
+acc += Math.sin(3654) + Math.cos(3655) * 65;
+acc += Math.sin(3655) + Math.cos(3656) * 66;
+acc += Math.sin(3656) + Math.cos(3657) * 67;
+acc += Math.sin(3657) + Math.cos(3658) * 68;
+acc += Math.sin(3658) + Math.cos(3659) * 69;
+acc += Math.sin(3659) + Math.cos(3660) * 70;
+acc += Math.sin(3660) + Math.cos(3661) * 71;
+acc += Math.sin(3661) + Math.cos(3662) * 72;
+acc += Math.sin(3662) + Math.cos(3663) * 73;
+acc += Math.sin(3663) + Math.cos(3664) * 74;
+acc += Math.sin(3664) + Math.cos(3665) * 75;
+acc += Math.sin(3665) + Math.cos(3666) * 76;
+acc += Math.sin(3666) + Math.cos(3667) * 77;
+acc += Math.sin(3667) + Math.cos(3668) * 78;
+acc += Math.sin(3668) + Math.cos(3669) * 79;
+acc += Math.sin(3669) + Math.cos(3670) * 80;
+acc += Math.sin(3670) + Math.cos(3671) * 81;
+acc += Math.sin(3671) + Math.cos(3672) * 82;
+acc += Math.sin(3672) + Math.cos(3673) * 83;
+acc += Math.sin(3673) + Math.cos(3674) * 84;
+acc += Math.sin(3674) + Math.cos(3675) * 85;
+acc += Math.sin(3675) + Math.cos(3676) * 86;
+acc += Math.sin(3676) + Math.cos(3677) * 87;
+acc += Math.sin(3677) + Math.cos(3678) * 88;
+acc += Math.sin(3678) + Math.cos(3679) * 89;
+acc += Math.sin(3679) + Math.cos(3680) * 90;
+acc += Math.sin(3680) + Math.cos(3681) * 91;
+acc += Math.sin(3681) + Math.cos(3682) * 92;
+acc += Math.sin(3682) + Math.cos(3683) * 93;
+acc += Math.sin(3683) + Math.cos(3684) * 94;
+acc += Math.sin(3684) + Math.cos(3685) * 95;
+acc += Math.sin(3685) + Math.cos(3686) * 96;
+acc += Math.sin(3686) + Math.cos(3687) * 0;
+acc += Math.sin(3687) + Math.cos(3688) * 1;
+acc += Math.sin(3688) + Math.cos(3689) * 2;
+acc += Math.sin(3689) + Math.cos(3690) * 3;
+acc += Math.sin(3690) + Math.cos(3691) * 4;
+acc += Math.sin(3691) + Math.cos(3692) * 5;
+acc += Math.sin(3692) + Math.cos(3693) * 6;
+acc += Math.sin(3693) + Math.cos(3694) * 7;
+acc += Math.sin(3694) + Math.cos(3695) * 8;
+acc += Math.sin(3695) + Math.cos(3696) * 9;
+acc += Math.sin(3696) + Math.cos(3697) * 10;
+acc += Math.sin(3697) + Math.cos(3698) * 11;
+acc += Math.sin(3698) + Math.cos(3699) * 12;
+acc += Math.sin(3699) + Math.cos(3700) * 13;
+acc += Math.sin(3700) + Math.cos(3701) * 14;
+acc += Math.sin(3701) + Math.cos(3702) * 15;
+acc += Math.sin(3702) + Math.cos(3703) * 16;
+acc += Math.sin(3703) + Math.cos(3704) * 17;
+acc += Math.sin(3704) + Math.cos(3705) * 18;
+acc += Math.sin(3705) + Math.cos(3706) * 19;
+acc += Math.sin(3706) + Math.cos(3707) * 20;
+acc += Math.sin(3707) + Math.cos(3708) * 21;
+acc += Math.sin(3708) + Math.cos(3709) * 22;
+acc += Math.sin(3709) + Math.cos(3710) * 23;
+acc += Math.sin(3710) + Math.cos(3711) * 24;
+acc += Math.sin(3711) + Math.cos(3712) * 25;
+acc += Math.sin(3712) + Math.cos(3713) * 26;
+acc += Math.sin(3713) + Math.cos(3714) * 27;
+acc += Math.sin(3714) + Math.cos(3715) * 28;
+acc += Math.sin(3715) + Math.cos(3716) * 29;
+acc += Math.sin(3716) + Math.cos(3717) * 30;
+acc += Math.sin(3717) + Math.cos(3718) * 31;
+acc += Math.sin(3718) + Math.cos(3719) * 32;
+acc += Math.sin(3719) + Math.cos(3720) * 33;
+acc += Math.sin(3720) + Math.cos(3721) * 34;
+acc += Math.sin(3721) + Math.cos(3722) * 35;
+acc += Math.sin(3722) + Math.cos(3723) * 36;
+acc += Math.sin(3723) + Math.cos(3724) * 37;
+acc += Math.sin(3724) + Math.cos(3725) * 38;
+acc += Math.sin(3725) + Math.cos(3726) * 39;
+acc += Math.sin(3726) + Math.cos(3727) * 40;
+acc += Math.sin(3727) + Math.cos(3728) * 41;
+acc += Math.sin(3728) + Math.cos(3729) * 42;
+acc += Math.sin(3729) + Math.cos(3730) * 43;
+acc += Math.sin(3730) + Math.cos(3731) * 44;
+acc += Math.sin(3731) + Math.cos(3732) * 45;
+acc += Math.sin(3732) + Math.cos(3733) * 46;
+acc += Math.sin(3733) + Math.cos(3734) * 47;
+acc += Math.sin(3734) + Math.cos(3735) * 48;
+acc += Math.sin(3735) + Math.cos(3736) * 49;
+acc += Math.sin(3736) + Math.cos(3737) * 50;
+acc += Math.sin(3737) + Math.cos(3738) * 51;
+acc += Math.sin(3738) + Math.cos(3739) * 52;
+acc += Math.sin(3739) + Math.cos(3740) * 53;
+acc += Math.sin(3740) + Math.cos(3741) * 54;
+acc += Math.sin(3741) + Math.cos(3742) * 55;
+acc += Math.sin(3742) + Math.cos(3743) * 56;
+acc += Math.sin(3743) + Math.cos(3744) * 57;
+acc += Math.sin(3744) + Math.cos(3745) * 58;
+acc += Math.sin(3745) + Math.cos(3746) * 59;
+acc += Math.sin(3746) + Math.cos(3747) * 60;
+acc += Math.sin(3747) + Math.cos(3748) * 61;
+acc += Math.sin(3748) + Math.cos(3749) * 62;
+acc += Math.sin(3749) + Math.cos(3750) * 63;
+acc += Math.sin(3750) + Math.cos(3751) * 64;
+acc += Math.sin(3751) + Math.cos(3752) * 65;
+acc += Math.sin(3752) + Math.cos(3753) * 66;
+acc += Math.sin(3753) + Math.cos(3754) * 67;
+acc += Math.sin(3754) + Math.cos(3755) * 68;
+acc += Math.sin(3755) + Math.cos(3756) * 69;
+acc += Math.sin(3756) + Math.cos(3757) * 70;
+acc += Math.sin(3757) + Math.cos(3758) * 71;
+acc += Math.sin(3758) + Math.cos(3759) * 72;
+acc += Math.sin(3759) + Math.cos(3760) * 73;
+acc += Math.sin(3760) + Math.cos(3761) * 74;
+acc += Math.sin(3761) + Math.cos(3762) * 75;
+acc += Math.sin(3762) + Math.cos(3763) * 76;
+acc += Math.sin(3763) + Math.cos(3764) * 77;
+acc += Math.sin(3764) + Math.cos(3765) * 78;
+acc += Math.sin(3765) + Math.cos(3766) * 79;
+acc += Math.sin(3766) + Math.cos(3767) * 80;
+acc += Math.sin(3767) + Math.cos(3768) * 81;
+acc += Math.sin(3768) + Math.cos(3769) * 82;
+acc += Math.sin(3769) + Math.cos(3770) * 83;
+acc += Math.sin(3770) + Math.cos(3771) * 84;
+acc += Math.sin(3771) + Math.cos(3772) * 85;
+acc += Math.sin(3772) + Math.cos(3773) * 86;
+acc += Math.sin(3773) + Math.cos(3774) * 87;
+acc += Math.sin(3774) + Math.cos(3775) * 88;
+acc += Math.sin(3775) + Math.cos(3776) * 89;
+acc += Math.sin(3776) + Math.cos(3777) * 90;
+acc += Math.sin(3777) + Math.cos(3778) * 91;
+acc += Math.sin(3778) + Math.cos(3779) * 92;
+acc += Math.sin(3779) + Math.cos(3780) * 93;
+acc += Math.sin(3780) + Math.cos(3781) * 94;
+acc += Math.sin(3781) + Math.cos(3782) * 95;
+acc += Math.sin(3782) + Math.cos(3783) * 96;
+acc += Math.sin(3783) + Math.cos(3784) * 0;
+acc += Math.sin(3784) + Math.cos(3785) * 1;
+acc += Math.sin(3785) + Math.cos(3786) * 2;
+acc += Math.sin(3786) + Math.cos(3787) * 3;
+acc += Math.sin(3787) + Math.cos(3788) * 4;
+acc += Math.sin(3788) + Math.cos(3789) * 5;
+acc += Math.sin(3789) + Math.cos(3790) * 6;
+acc += Math.sin(3790) + Math.cos(3791) * 7;
+acc += Math.sin(3791) + Math.cos(3792) * 8;
+acc += Math.sin(3792) + Math.cos(3793) * 9;
+acc += Math.sin(3793) + Math.cos(3794) * 10;
+acc += Math.sin(3794) + Math.cos(3795) * 11;
+acc += Math.sin(3795) + Math.cos(3796) * 12;
+acc += Math.sin(3796) + Math.cos(3797) * 13;
+acc += Math.sin(3797) + Math.cos(3798) * 14;
+acc += Math.sin(3798) + Math.cos(3799) * 15;
+acc += Math.sin(3799) + Math.cos(3800) * 16;
+acc += Math.sin(3800) + Math.cos(3801) * 17;
+acc += Math.sin(3801) + Math.cos(3802) * 18;
+acc += Math.sin(3802) + Math.cos(3803) * 19;
+acc += Math.sin(3803) + Math.cos(3804) * 20;
+acc += Math.sin(3804) + Math.cos(3805) * 21;
+acc += Math.sin(3805) + Math.cos(3806) * 22;
+acc += Math.sin(3806) + Math.cos(3807) * 23;
+acc += Math.sin(3807) + Math.cos(3808) * 24;
+acc += Math.sin(3808) + Math.cos(3809) * 25;
+acc += Math.sin(3809) + Math.cos(3810) * 26;
+acc += Math.sin(3810) + Math.cos(3811) * 27;
+acc += Math.sin(3811) + Math.cos(3812) * 28;
+acc += Math.sin(3812) + Math.cos(3813) * 29;
+acc += Math.sin(3813) + Math.cos(3814) * 30;
+acc += Math.sin(3814) + Math.cos(3815) * 31;
+acc += Math.sin(3815) + Math.cos(3816) * 32;
+acc += Math.sin(3816) + Math.cos(3817) * 33;
+acc += Math.sin(3817) + Math.cos(3818) * 34;
+acc += Math.sin(3818) + Math.cos(3819) * 35;
+acc += Math.sin(3819) + Math.cos(3820) * 36;
+acc += Math.sin(3820) + Math.cos(3821) * 37;
+acc += Math.sin(3821) + Math.cos(3822) * 38;
+acc += Math.sin(3822) + Math.cos(3823) * 39;
+acc += Math.sin(3823) + Math.cos(3824) * 40;
+acc += Math.sin(3824) + Math.cos(3825) * 41;
+acc += Math.sin(3825) + Math.cos(3826) * 42;
+acc += Math.sin(3826) + Math.cos(3827) * 43;
+acc += Math.sin(3827) + Math.cos(3828) * 44;
+acc += Math.sin(3828) + Math.cos(3829) * 45;
+acc += Math.sin(3829) + Math.cos(3830) * 46;
+acc += Math.sin(3830) + Math.cos(3831) * 47;
+acc += Math.sin(3831) + Math.cos(3832) * 48;
+acc += Math.sin(3832) + Math.cos(3833) * 49;
+acc += Math.sin(3833) + Math.cos(3834) * 50;
+acc += Math.sin(3834) + Math.cos(3835) * 51;
+acc += Math.sin(3835) + Math.cos(3836) * 52;
+acc += Math.sin(3836) + Math.cos(3837) * 53;
+acc += Math.sin(3837) + Math.cos(3838) * 54;
+acc += Math.sin(3838) + Math.cos(3839) * 55;
+acc += Math.sin(3839) + Math.cos(3840) * 56;
+acc += Math.sin(3840) + Math.cos(3841) * 57;
+acc += Math.sin(3841) + Math.cos(3842) * 58;
+acc += Math.sin(3842) + Math.cos(3843) * 59;
+acc += Math.sin(3843) + Math.cos(3844) * 60;
+acc += Math.sin(3844) + Math.cos(3845) * 61;
+acc += Math.sin(3845) + Math.cos(3846) * 62;
+acc += Math.sin(3846) + Math.cos(3847) * 63;
+acc += Math.sin(3847) + Math.cos(3848) * 64;
+acc += Math.sin(3848) + Math.cos(3849) * 65;
+acc += Math.sin(3849) + Math.cos(3850) * 66;
+acc += Math.sin(3850) + Math.cos(3851) * 67;
+acc += Math.sin(3851) + Math.cos(3852) * 68;
+acc += Math.sin(3852) + Math.cos(3853) * 69;
+acc += Math.sin(3853) + Math.cos(3854) * 70;
+acc += Math.sin(3854) + Math.cos(3855) * 71;
+acc += Math.sin(3855) + Math.cos(3856) * 72;
+acc += Math.sin(3856) + Math.cos(3857) * 73;
+acc += Math.sin(3857) + Math.cos(3858) * 74;
+acc += Math.sin(3858) + Math.cos(3859) * 75;
+acc += Math.sin(3859) + Math.cos(3860) * 76;
+acc += Math.sin(3860) + Math.cos(3861) * 77;
+acc += Math.sin(3861) + Math.cos(3862) * 78;
+acc += Math.sin(3862) + Math.cos(3863) * 79;
+acc += Math.sin(3863) + Math.cos(3864) * 80;
+acc += Math.sin(3864) + Math.cos(3865) * 81;
+acc += Math.sin(3865) + Math.cos(3866) * 82;
+acc += Math.sin(3866) + Math.cos(3867) * 83;
+acc += Math.sin(3867) + Math.cos(3868) * 84;
+acc += Math.sin(3868) + Math.cos(3869) * 85;
+acc += Math.sin(3869) + Math.cos(3870) * 86;
+acc += Math.sin(3870) + Math.cos(3871) * 87;
+acc += Math.sin(3871) + Math.cos(3872) * 88;
+acc += Math.sin(3872) + Math.cos(3873) * 89;
+acc += Math.sin(3873) + Math.cos(3874) * 90;
+acc += Math.sin(3874) + Math.cos(3875) * 91;
+acc += Math.sin(3875) + Math.cos(3876) * 92;
+acc += Math.sin(3876) + Math.cos(3877) * 93;
+acc += Math.sin(3877) + Math.cos(3878) * 94;
+acc += Math.sin(3878) + Math.cos(3879) * 95;
+acc += Math.sin(3879) + Math.cos(3880) * 96;
+acc += Math.sin(3880) + Math.cos(3881) * 0;
+acc += Math.sin(3881) + Math.cos(3882) * 1;
+acc += Math.sin(3882) + Math.cos(3883) * 2;
+acc += Math.sin(3883) + Math.cos(3884) * 3;
+acc += Math.sin(3884) + Math.cos(3885) * 4;
+acc += Math.sin(3885) + Math.cos(3886) * 5;
+acc += Math.sin(3886) + Math.cos(3887) * 6;
+acc += Math.sin(3887) + Math.cos(3888) * 7;
+acc += Math.sin(3888) + Math.cos(3889) * 8;
+acc += Math.sin(3889) + Math.cos(3890) * 9;
+acc += Math.sin(3890) + Math.cos(3891) * 10;
+acc += Math.sin(3891) + Math.cos(3892) * 11;
+acc += Math.sin(3892) + Math.cos(3893) * 12;
+acc += Math.sin(3893) + Math.cos(3894) * 13;
+acc += Math.sin(3894) + Math.cos(3895) * 14;
+acc += Math.sin(3895) + Math.cos(3896) * 15;
+acc += Math.sin(3896) + Math.cos(3897) * 16;
+acc += Math.sin(3897) + Math.cos(3898) * 17;
+acc += Math.sin(3898) + Math.cos(3899) * 18;
+acc += Math.sin(3899) + Math.cos(3900) * 19;
+acc += Math.sin(3900) + Math.cos(3901) * 20;
+acc += Math.sin(3901) + Math.cos(3902) * 21;
+acc += Math.sin(3902) + Math.cos(3903) * 22;
+acc += Math.sin(3903) + Math.cos(3904) * 23;
+acc += Math.sin(3904) + Math.cos(3905) * 24;
+acc += Math.sin(3905) + Math.cos(3906) * 25;
+acc += Math.sin(3906) + Math.cos(3907) * 26;
+acc += Math.sin(3907) + Math.cos(3908) * 27;
+acc += Math.sin(3908) + Math.cos(3909) * 28;
+acc += Math.sin(3909) + Math.cos(3910) * 29;
+acc += Math.sin(3910) + Math.cos(3911) * 30;
+acc += Math.sin(3911) + Math.cos(3912) * 31;
+acc += Math.sin(3912) + Math.cos(3913) * 32;
+acc += Math.sin(3913) + Math.cos(3914) * 33;
+acc += Math.sin(3914) + Math.cos(3915) * 34;
+acc += Math.sin(3915) + Math.cos(3916) * 35;
+acc += Math.sin(3916) + Math.cos(3917) * 36;
+acc += Math.sin(3917) + Math.cos(3918) * 37;
+acc += Math.sin(3918) + Math.cos(3919) * 38;
+acc += Math.sin(3919) + Math.cos(3920) * 39;
+acc += Math.sin(3920) + Math.cos(3921) * 40;
+acc += Math.sin(3921) + Math.cos(3922) * 41;
+acc += Math.sin(3922) + Math.cos(3923) * 42;
+acc += Math.sin(3923) + Math.cos(3924) * 43;
+acc += Math.sin(3924) + Math.cos(3925) * 44;
+acc += Math.sin(3925) + Math.cos(3926) * 45;
+acc += Math.sin(3926) + Math.cos(3927) * 46;
+acc += Math.sin(3927) + Math.cos(3928) * 47;
+acc += Math.sin(3928) + Math.cos(3929) * 48;
+acc += Math.sin(3929) + Math.cos(3930) * 49;
+acc += Math.sin(3930) + Math.cos(3931) * 50;
+acc += Math.sin(3931) + Math.cos(3932) * 51;
+acc += Math.sin(3932) + Math.cos(3933) * 52;
+acc += Math.sin(3933) + Math.cos(3934) * 53;
+acc += Math.sin(3934) + Math.cos(3935) * 54;
+acc += Math.sin(3935) + Math.cos(3936) * 55;
+acc += Math.sin(3936) + Math.cos(3937) * 56;
+acc += Math.sin(3937) + Math.cos(3938) * 57;
+acc += Math.sin(3938) + Math.cos(3939) * 58;
+acc += Math.sin(3939) + Math.cos(3940) * 59;
+acc += Math.sin(3940) + Math.cos(3941) * 60;
+acc += Math.sin(3941) + Math.cos(3942) * 61;
+acc += Math.sin(3942) + Math.cos(3943) * 62;
+acc += Math.sin(3943) + Math.cos(3944) * 63;
+acc += Math.sin(3944) + Math.cos(3945) * 64;
+acc += Math.sin(3945) + Math.cos(3946) * 65;
+acc += Math.sin(3946) + Math.cos(3947) * 66;
+acc += Math.sin(3947) + Math.cos(3948) * 67;
+acc += Math.sin(3948) + Math.cos(3949) * 68;
+acc += Math.sin(3949) + Math.cos(3950) * 69;
+acc += Math.sin(3950) + Math.cos(3951) * 70;
+acc += Math.sin(3951) + Math.cos(3952) * 71;
+acc += Math.sin(3952) + Math.cos(3953) * 72;
+acc += Math.sin(3953) + Math.cos(3954) * 73;
+acc += Math.sin(3954) + Math.cos(3955) * 74;
+acc += Math.sin(3955) + Math.cos(3956) * 75;
+acc += Math.sin(3956) + Math.cos(3957) * 76;
+acc += Math.sin(3957) + Math.cos(3958) * 77;
+acc += Math.sin(3958) + Math.cos(3959) * 78;
+acc += Math.sin(3959) + Math.cos(3960) * 79;
+acc += Math.sin(3960) + Math.cos(3961) * 80;
+acc += Math.sin(3961) + Math.cos(3962) * 81;
+acc += Math.sin(3962) + Math.cos(3963) * 82;
+acc += Math.sin(3963) + Math.cos(3964) * 83;
+acc += Math.sin(3964) + Math.cos(3965) * 84;
+acc += Math.sin(3965) + Math.cos(3966) * 85;
+acc += Math.sin(3966) + Math.cos(3967) * 86;
+acc += Math.sin(3967) + Math.cos(3968) * 87;
+acc += Math.sin(3968) + Math.cos(3969) * 88;
+acc += Math.sin(3969) + Math.cos(3970) * 89;
+acc += Math.sin(3970) + Math.cos(3971) * 90;
+acc += Math.sin(3971) + Math.cos(3972) * 91;
+acc += Math.sin(3972) + Math.cos(3973) * 92;
+acc += Math.sin(3973) + Math.cos(3974) * 93;
+acc += Math.sin(3974) + Math.cos(3975) * 94;
+acc += Math.sin(3975) + Math.cos(3976) * 95;
+acc += Math.sin(3976) + Math.cos(3977) * 96;
+acc += Math.sin(3977) + Math.cos(3978) * 0;
+acc += Math.sin(3978) + Math.cos(3979) * 1;
+acc += Math.sin(3979) + Math.cos(3980) * 2;
+acc += Math.sin(3980) + Math.cos(3981) * 3;
+acc += Math.sin(3981) + Math.cos(3982) * 4;
+acc += Math.sin(3982) + Math.cos(3983) * 5;
+acc += Math.sin(3983) + Math.cos(3984) * 6;
+acc += Math.sin(3984) + Math.cos(3985) * 7;
+acc += Math.sin(3985) + Math.cos(3986) * 8;
+acc += Math.sin(3986) + Math.cos(3987) * 9;
+acc += Math.sin(3987) + Math.cos(3988) * 10;
+acc += Math.sin(3988) + Math.cos(3989) * 11;
+acc += Math.sin(3989) + Math.cos(3990) * 12;
+acc += Math.sin(3990) + Math.cos(3991) * 13;
+acc += Math.sin(3991) + Math.cos(3992) * 14;
+acc += Math.sin(3992) + Math.cos(3993) * 15;
+acc += Math.sin(3993) + Math.cos(3994) * 16;
+acc += Math.sin(3994) + Math.cos(3995) * 17;
+acc += Math.sin(3995) + Math.cos(3996) * 18;
+acc += Math.sin(3996) + Math.cos(3997) * 19;
+acc += Math.sin(3997) + Math.cos(3998) * 20;
+acc += Math.sin(3998) + Math.cos(3999) * 21;
+acc += Math.sin(3999) + Math.cos(4000) * 22;
+acc += Math.sin(4000) + Math.cos(4001) * 23;
+acc += Math.sin(4001) + Math.cos(4002) * 24;
+acc += Math.sin(4002) + Math.cos(4003) * 25;
+acc += Math.sin(4003) + Math.cos(4004) * 26;
+acc += Math.sin(4004) + Math.cos(4005) * 27;
+acc += Math.sin(4005) + Math.cos(4006) * 28;
+acc += Math.sin(4006) + Math.cos(4007) * 29;
+acc += Math.sin(4007) + Math.cos(4008) * 30;
+acc += Math.sin(4008) + Math.cos(4009) * 31;
+acc += Math.sin(4009) + Math.cos(4010) * 32;
+acc += Math.sin(4010) + Math.cos(4011) * 33;
+acc += Math.sin(4011) + Math.cos(4012) * 34;
+acc += Math.sin(4012) + Math.cos(4013) * 35;
+acc += Math.sin(4013) + Math.cos(4014) * 36;
+acc += Math.sin(4014) + Math.cos(4015) * 37;
+acc += Math.sin(4015) + Math.cos(4016) * 38;
+acc += Math.sin(4016) + Math.cos(4017) * 39;
+acc += Math.sin(4017) + Math.cos(4018) * 40;
+acc += Math.sin(4018) + Math.cos(4019) * 41;
+acc += Math.sin(4019) + Math.cos(4020) * 42;
+acc += Math.sin(4020) + Math.cos(4021) * 43;
+acc += Math.sin(4021) + Math.cos(4022) * 44;
+acc += Math.sin(4022) + Math.cos(4023) * 45;
+acc += Math.sin(4023) + Math.cos(4024) * 46;
+acc += Math.sin(4024) + Math.cos(4025) * 47;
+acc += Math.sin(4025) + Math.cos(4026) * 48;
+acc += Math.sin(4026) + Math.cos(4027) * 49;
+acc += Math.sin(4027) + Math.cos(4028) * 50;
+acc += Math.sin(4028) + Math.cos(4029) * 51;
+acc += Math.sin(4029) + Math.cos(4030) * 52;
+acc += Math.sin(4030) + Math.cos(4031) * 53;
+acc += Math.sin(4031) + Math.cos(4032) * 54;
+acc += Math.sin(4032) + Math.cos(4033) * 55;
+acc += Math.sin(4033) + Math.cos(4034) * 56;
+acc += Math.sin(4034) + Math.cos(4035) * 57;
+acc += Math.sin(4035) + Math.cos(4036) * 58;
+acc += Math.sin(4036) + Math.cos(4037) * 59;
+acc += Math.sin(4037) + Math.cos(4038) * 60;
+acc += Math.sin(4038) + Math.cos(4039) * 61;
+acc += Math.sin(4039) + Math.cos(4040) * 62;
+acc += Math.sin(4040) + Math.cos(4041) * 63;
+acc += Math.sin(4041) + Math.cos(4042) * 64;
+acc += Math.sin(4042) + Math.cos(4043) * 65;
+acc += Math.sin(4043) + Math.cos(4044) * 66;
+acc += Math.sin(4044) + Math.cos(4045) * 67;
+acc += Math.sin(4045) + Math.cos(4046) * 68;
+acc += Math.sin(4046) + Math.cos(4047) * 69;
+acc += Math.sin(4047) + Math.cos(4048) * 70;
+acc += Math.sin(4048) + Math.cos(4049) * 71;
+acc += Math.sin(4049) + Math.cos(4050) * 72;
+acc += Math.sin(4050) + Math.cos(4051) * 73;
+acc += Math.sin(4051) + Math.cos(4052) * 74;
+acc += Math.sin(4052) + Math.cos(4053) * 75;
+acc += Math.sin(4053) + Math.cos(4054) * 76;
+acc += Math.sin(4054) + Math.cos(4055) * 77;
+acc += Math.sin(4055) + Math.cos(4056) * 78;
+acc += Math.sin(4056) + Math.cos(4057) * 79;
+acc += Math.sin(4057) + Math.cos(4058) * 80;
+acc += Math.sin(4058) + Math.cos(4059) * 81;
+acc += Math.sin(4059) + Math.cos(4060) * 82;
+acc += Math.sin(4060) + Math.cos(4061) * 83;
+acc += Math.sin(4061) + Math.cos(4062) * 84;
+acc += Math.sin(4062) + Math.cos(4063) * 85;
+acc += Math.sin(4063) + Math.cos(4064) * 86;
+acc += Math.sin(4064) + Math.cos(4065) * 87;
+acc += Math.sin(4065) + Math.cos(4066) * 88;
+acc += Math.sin(4066) + Math.cos(4067) * 89;
+acc += Math.sin(4067) + Math.cos(4068) * 90;
+acc += Math.sin(4068) + Math.cos(4069) * 91;
+acc += Math.sin(4069) + Math.cos(4070) * 92;
+acc += Math.sin(4070) + Math.cos(4071) * 93;
+acc += Math.sin(4071) + Math.cos(4072) * 94;
+acc += Math.sin(4072) + Math.cos(4073) * 95;
+acc += Math.sin(4073) + Math.cos(4074) * 96;
+acc += Math.sin(4074) + Math.cos(4075) * 0;
+acc += Math.sin(4075) + Math.cos(4076) * 1;
+acc += Math.sin(4076) + Math.cos(4077) * 2;
+acc += Math.sin(4077) + Math.cos(4078) * 3;
+acc += Math.sin(4078) + Math.cos(4079) * 4;
+acc += Math.sin(4079) + Math.cos(4080) * 5;
+acc += Math.sin(4080) + Math.cos(4081) * 6;
+acc += Math.sin(4081) + Math.cos(4082) * 7;
+acc += Math.sin(4082) + Math.cos(4083) * 8;
+acc += Math.sin(4083) + Math.cos(4084) * 9;
+acc += Math.sin(4084) + Math.cos(4085) * 10;
+acc += Math.sin(4085) + Math.cos(4086) * 11;
+acc += Math.sin(4086) + Math.cos(4087) * 12;
+acc += Math.sin(4087) + Math.cos(4088) * 13;
+acc += Math.sin(4088) + Math.cos(4089) * 14;
+acc += Math.sin(4089) + Math.cos(4090) * 15;
+acc += Math.sin(4090) + Math.cos(4091) * 16;
+acc += Math.sin(4091) + Math.cos(4092) * 17;
+acc += Math.sin(4092) + Math.cos(4093) * 18;
+acc += Math.sin(4093) + Math.cos(4094) * 19;
+acc += Math.sin(4094) + Math.cos(4095) * 20;
+acc += Math.sin(4095) + Math.cos(4096) * 21;
+acc += Math.sin(4096) + Math.cos(4097) * 22;
+acc += Math.sin(4097) + Math.cos(4098) * 23;
+acc += Math.sin(4098) + Math.cos(4099) * 24;
+acc += Math.sin(4099) + Math.cos(4100) * 25;
+acc += Math.sin(4100) + Math.cos(4101) * 26;
+acc += Math.sin(4101) + Math.cos(4102) * 27;
+acc += Math.sin(4102) + Math.cos(4103) * 28;
+acc += Math.sin(4103) + Math.cos(4104) * 29;
+acc += Math.sin(4104) + Math.cos(4105) * 30;
+acc += Math.sin(4105) + Math.cos(4106) * 31;
+acc += Math.sin(4106) + Math.cos(4107) * 32;
+acc += Math.sin(4107) + Math.cos(4108) * 33;
+acc += Math.sin(4108) + Math.cos(4109) * 34;
+acc += Math.sin(4109) + Math.cos(4110) * 35;
+acc += Math.sin(4110) + Math.cos(4111) * 36;
+acc += Math.sin(4111) + Math.cos(4112) * 37;
+acc += Math.sin(4112) + Math.cos(4113) * 38;
+acc += Math.sin(4113) + Math.cos(4114) * 39;
+acc += Math.sin(4114) + Math.cos(4115) * 40;
+acc += Math.sin(4115) + Math.cos(4116) * 41;
+acc += Math.sin(4116) + Math.cos(4117) * 42;
+acc += Math.sin(4117) + Math.cos(4118) * 43;
+acc += Math.sin(4118) + Math.cos(4119) * 44;
+acc += Math.sin(4119) + Math.cos(4120) * 45;
+acc += Math.sin(4120) + Math.cos(4121) * 46;
+acc += Math.sin(4121) + Math.cos(4122) * 47;
+acc += Math.sin(4122) + Math.cos(4123) * 48;
+acc += Math.sin(4123) + Math.cos(4124) * 49;
+acc += Math.sin(4124) + Math.cos(4125) * 50;
+acc += Math.sin(4125) + Math.cos(4126) * 51;
+acc += Math.sin(4126) + Math.cos(4127) * 52;
+acc += Math.sin(4127) + Math.cos(4128) * 53;
+acc += Math.sin(4128) + Math.cos(4129) * 54;
+acc += Math.sin(4129) + Math.cos(4130) * 55;
+acc += Math.sin(4130) + Math.cos(4131) * 56;
+acc += Math.sin(4131) + Math.cos(4132) * 57;
+acc += Math.sin(4132) + Math.cos(4133) * 58;
+acc += Math.sin(4133) + Math.cos(4134) * 59;
+acc += Math.sin(4134) + Math.cos(4135) * 60;
+acc += Math.sin(4135) + Math.cos(4136) * 61;
+acc += Math.sin(4136) + Math.cos(4137) * 62;
+acc += Math.sin(4137) + Math.cos(4138) * 63;
+acc += Math.sin(4138) + Math.cos(4139) * 64;
+acc += Math.sin(4139) + Math.cos(4140) * 65;
+acc += Math.sin(4140) + Math.cos(4141) * 66;
+acc += Math.sin(4141) + Math.cos(4142) * 67;
+acc += Math.sin(4142) + Math.cos(4143) * 68;
+acc += Math.sin(4143) + Math.cos(4144) * 69;
+acc += Math.sin(4144) + Math.cos(4145) * 70;
+acc += Math.sin(4145) + Math.cos(4146) * 71;
+acc += Math.sin(4146) + Math.cos(4147) * 72;
+acc += Math.sin(4147) + Math.cos(4148) * 73;
+acc += Math.sin(4148) + Math.cos(4149) * 74;
+acc += Math.sin(4149) + Math.cos(4150) * 75;
+acc += Math.sin(4150) + Math.cos(4151) * 76;
+acc += Math.sin(4151) + Math.cos(4152) * 77;
+acc += Math.sin(4152) + Math.cos(4153) * 78;
+acc += Math.sin(4153) + Math.cos(4154) * 79;
+acc += Math.sin(4154) + Math.cos(4155) * 80;
+acc += Math.sin(4155) + Math.cos(4156) * 81;
+acc += Math.sin(4156) + Math.cos(4157) * 82;
+acc += Math.sin(4157) + Math.cos(4158) * 83;
+acc += Math.sin(4158) + Math.cos(4159) * 84;
+acc += Math.sin(4159) + Math.cos(4160) * 85;
+acc += Math.sin(4160) + Math.cos(4161) * 86;
+acc += Math.sin(4161) + Math.cos(4162) * 87;
+acc += Math.sin(4162) + Math.cos(4163) * 88;
+acc += Math.sin(4163) + Math.cos(4164) * 89;
+acc += Math.sin(4164) + Math.cos(4165) * 90;
+acc += Math.sin(4165) + Math.cos(4166) * 91;
+acc += Math.sin(4166) + Math.cos(4167) * 92;
+acc += Math.sin(4167) + Math.cos(4168) * 93;
+acc += Math.sin(4168) + Math.cos(4169) * 94;
+acc += Math.sin(4169) + Math.cos(4170) * 95;
+acc += Math.sin(4170) + Math.cos(4171) * 96;
+acc += Math.sin(4171) + Math.cos(4172) * 0;
+acc += Math.sin(4172) + Math.cos(4173) * 1;
+acc += Math.sin(4173) + Math.cos(4174) * 2;
+acc += Math.sin(4174) + Math.cos(4175) * 3;
+acc += Math.sin(4175) + Math.cos(4176) * 4;
+acc += Math.sin(4176) + Math.cos(4177) * 5;
+acc += Math.sin(4177) + Math.cos(4178) * 6;
+acc += Math.sin(4178) + Math.cos(4179) * 7;
+acc += Math.sin(4179) + Math.cos(4180) * 8;
+acc += Math.sin(4180) + Math.cos(4181) * 9;
+acc += Math.sin(4181) + Math.cos(4182) * 10;
+acc += Math.sin(4182) + Math.cos(4183) * 11;
+acc += Math.sin(4183) + Math.cos(4184) * 12;
+acc += Math.sin(4184) + Math.cos(4185) * 13;
+acc += Math.sin(4185) + Math.cos(4186) * 14;
+acc += Math.sin(4186) + Math.cos(4187) * 15;
+acc += Math.sin(4187) + Math.cos(4188) * 16;
+acc += Math.sin(4188) + Math.cos(4189) * 17;
+acc += Math.sin(4189) + Math.cos(4190) * 18;
+acc += Math.sin(4190) + Math.cos(4191) * 19;
+acc += Math.sin(4191) + Math.cos(4192) * 20;
+acc += Math.sin(4192) + Math.cos(4193) * 21;
+acc += Math.sin(4193) + Math.cos(4194) * 22;
+acc += Math.sin(4194) + Math.cos(4195) * 23;
+acc += Math.sin(4195) + Math.cos(4196) * 24;
+acc += Math.sin(4196) + Math.cos(4197) * 25;
+acc += Math.sin(4197) + Math.cos(4198) * 26;
+acc += Math.sin(4198) + Math.cos(4199) * 27;
+acc += Math.sin(4199) + Math.cos(4200) * 28;
+acc += Math.sin(4200) + Math.cos(4201) * 29;
+acc += Math.sin(4201) + Math.cos(4202) * 30;
+acc += Math.sin(4202) + Math.cos(4203) * 31;
+acc += Math.sin(4203) + Math.cos(4204) * 32;
+acc += Math.sin(4204) + Math.cos(4205) * 33;
+acc += Math.sin(4205) + Math.cos(4206) * 34;
+acc += Math.sin(4206) + Math.cos(4207) * 35;
+acc += Math.sin(4207) + Math.cos(4208) * 36;
+acc += Math.sin(4208) + Math.cos(4209) * 37;
+acc += Math.sin(4209) + Math.cos(4210) * 38;
+acc += Math.sin(4210) + Math.cos(4211) * 39;
+acc += Math.sin(4211) + Math.cos(4212) * 40;
+acc += Math.sin(4212) + Math.cos(4213) * 41;
+acc += Math.sin(4213) + Math.cos(4214) * 42;
+acc += Math.sin(4214) + Math.cos(4215) * 43;
+acc += Math.sin(4215) + Math.cos(4216) * 44;
+acc += Math.sin(4216) + Math.cos(4217) * 45;
+acc += Math.sin(4217) + Math.cos(4218) * 46;
+acc += Math.sin(4218) + Math.cos(4219) * 47;
+acc += Math.sin(4219) + Math.cos(4220) * 48;
+acc += Math.sin(4220) + Math.cos(4221) * 49;
+acc += Math.sin(4221) + Math.cos(4222) * 50;
+acc += Math.sin(4222) + Math.cos(4223) * 51;
+acc += Math.sin(4223) + Math.cos(4224) * 52;
+acc += Math.sin(4224) + Math.cos(4225) * 53;
+acc += Math.sin(4225) + Math.cos(4226) * 54;
+acc += Math.sin(4226) + Math.cos(4227) * 55;
+acc += Math.sin(4227) + Math.cos(4228) * 56;
+acc += Math.sin(4228) + Math.cos(4229) * 57;
+acc += Math.sin(4229) + Math.cos(4230) * 58;
+acc += Math.sin(4230) + Math.cos(4231) * 59;
+acc += Math.sin(4231) + Math.cos(4232) * 60;
+acc += Math.sin(4232) + Math.cos(4233) * 61;
+acc += Math.sin(4233) + Math.cos(4234) * 62;
+acc += Math.sin(4234) + Math.cos(4235) * 63;
+acc += Math.sin(4235) + Math.cos(4236) * 64;
+acc += Math.sin(4236) + Math.cos(4237) * 65;
+acc += Math.sin(4237) + Math.cos(4238) * 66;
+acc += Math.sin(4238) + Math.cos(4239) * 67;
+acc += Math.sin(4239) + Math.cos(4240) * 68;
+acc += Math.sin(4240) + Math.cos(4241) * 69;
+acc += Math.sin(4241) + Math.cos(4242) * 70;
+acc += Math.sin(4242) + Math.cos(4243) * 71;
+acc += Math.sin(4243) + Math.cos(4244) * 72;
+acc += Math.sin(4244) + Math.cos(4245) * 73;
+acc += Math.sin(4245) + Math.cos(4246) * 74;
+acc += Math.sin(4246) + Math.cos(4247) * 75;
+acc += Math.sin(4247) + Math.cos(4248) * 76;
+acc += Math.sin(4248) + Math.cos(4249) * 77;
+acc += Math.sin(4249) + Math.cos(4250) * 78;
+acc += Math.sin(4250) + Math.cos(4251) * 79;
+acc += Math.sin(4251) + Math.cos(4252) * 80;
+acc += Math.sin(4252) + Math.cos(4253) * 81;
+acc += Math.sin(4253) + Math.cos(4254) * 82;
+acc += Math.sin(4254) + Math.cos(4255) * 83;
+acc += Math.sin(4255) + Math.cos(4256) * 84;
+acc += Math.sin(4256) + Math.cos(4257) * 85;
+acc += Math.sin(4257) + Math.cos(4258) * 86;
+acc += Math.sin(4258) + Math.cos(4259) * 87;
+acc += Math.sin(4259) + Math.cos(4260) * 88;
+acc += Math.sin(4260) + Math.cos(4261) * 89;
+acc += Math.sin(4261) + Math.cos(4262) * 90;
+acc += Math.sin(4262) + Math.cos(4263) * 91;
+acc += Math.sin(4263) + Math.cos(4264) * 92;
+acc += Math.sin(4264) + Math.cos(4265) * 93;
+acc += Math.sin(4265) + Math.cos(4266) * 94;
+acc += Math.sin(4266) + Math.cos(4267) * 95;
+acc += Math.sin(4267) + Math.cos(4268) * 96;
+acc += Math.sin(4268) + Math.cos(4269) * 0;
+acc += Math.sin(4269) + Math.cos(4270) * 1;
+acc += Math.sin(4270) + Math.cos(4271) * 2;
+acc += Math.sin(4271) + Math.cos(4272) * 3;
+acc += Math.sin(4272) + Math.cos(4273) * 4;
+acc += Math.sin(4273) + Math.cos(4274) * 5;
+acc += Math.sin(4274) + Math.cos(4275) * 6;
+acc += Math.sin(4275) + Math.cos(4276) * 7;
+acc += Math.sin(4276) + Math.cos(4277) * 8;
+acc += Math.sin(4277) + Math.cos(4278) * 9;
+acc += Math.sin(4278) + Math.cos(4279) * 10;
+acc += Math.sin(4279) + Math.cos(4280) * 11;
+acc += Math.sin(4280) + Math.cos(4281) * 12;
+acc += Math.sin(4281) + Math.cos(4282) * 13;
+acc += Math.sin(4282) + Math.cos(4283) * 14;
+acc += Math.sin(4283) + Math.cos(4284) * 15;
+acc += Math.sin(4284) + Math.cos(4285) * 16;
+acc += Math.sin(4285) + Math.cos(4286) * 17;
+acc += Math.sin(4286) + Math.cos(4287) * 18;
+acc += Math.sin(4287) + Math.cos(4288) * 19;
+acc += Math.sin(4288) + Math.cos(4289) * 20;
+acc += Math.sin(4289) + Math.cos(4290) * 21;
+acc += Math.sin(4290) + Math.cos(4291) * 22;
+acc += Math.sin(4291) + Math.cos(4292) * 23;
+acc += Math.sin(4292) + Math.cos(4293) * 24;
+acc += Math.sin(4293) + Math.cos(4294) * 25;
+acc += Math.sin(4294) + Math.cos(4295) * 26;
+acc += Math.sin(4295) + Math.cos(4296) * 27;
+acc += Math.sin(4296) + Math.cos(4297) * 28;
+acc += Math.sin(4297) + Math.cos(4298) * 29;
+acc += Math.sin(4298) + Math.cos(4299) * 30;
+acc += Math.sin(4299) + Math.cos(4300) * 31;
+acc += Math.sin(4300) + Math.cos(4301) * 32;
+acc += Math.sin(4301) + Math.cos(4302) * 33;
+acc += Math.sin(4302) + Math.cos(4303) * 34;
+acc += Math.sin(4303) + Math.cos(4304) * 35;
+acc += Math.sin(4304) + Math.cos(4305) * 36;
+acc += Math.sin(4305) + Math.cos(4306) * 37;
+acc += Math.sin(4306) + Math.cos(4307) * 38;
+acc += Math.sin(4307) + Math.cos(4308) * 39;
+acc += Math.sin(4308) + Math.cos(4309) * 40;
+acc += Math.sin(4309) + Math.cos(4310) * 41;
+acc += Math.sin(4310) + Math.cos(4311) * 42;
+acc += Math.sin(4311) + Math.cos(4312) * 43;
+acc += Math.sin(4312) + Math.cos(4313) * 44;
+acc += Math.sin(4313) + Math.cos(4314) * 45;
+acc += Math.sin(4314) + Math.cos(4315) * 46;
+acc += Math.sin(4315) + Math.cos(4316) * 47;
+acc += Math.sin(4316) + Math.cos(4317) * 48;
+acc += Math.sin(4317) + Math.cos(4318) * 49;
+acc += Math.sin(4318) + Math.cos(4319) * 50;
+acc += Math.sin(4319) + Math.cos(4320) * 51;
+acc += Math.sin(4320) + Math.cos(4321) * 52;
+acc += Math.sin(4321) + Math.cos(4322) * 53;
+acc += Math.sin(4322) + Math.cos(4323) * 54;
+acc += Math.sin(4323) + Math.cos(4324) * 55;
+acc += Math.sin(4324) + Math.cos(4325) * 56;
+acc += Math.sin(4325) + Math.cos(4326) * 57;
+acc += Math.sin(4326) + Math.cos(4327) * 58;
+acc += Math.sin(4327) + Math.cos(4328) * 59;
+acc += Math.sin(4328) + Math.cos(4329) * 60;
+acc += Math.sin(4329) + Math.cos(4330) * 61;
+acc += Math.sin(4330) + Math.cos(4331) * 62;
+acc += Math.sin(4331) + Math.cos(4332) * 63;
+acc += Math.sin(4332) + Math.cos(4333) * 64;
+acc += Math.sin(4333) + Math.cos(4334) * 65;
+acc += Math.sin(4334) + Math.cos(4335) * 66;
+acc += Math.sin(4335) + Math.cos(4336) * 67;
+acc += Math.sin(4336) + Math.cos(4337) * 68;
+acc += Math.sin(4337) + Math.cos(4338) * 69;
+acc += Math.sin(4338) + Math.cos(4339) * 70;
+acc += Math.sin(4339) + Math.cos(4340) * 71;
+acc += Math.sin(4340) + Math.cos(4341) * 72;
+acc += Math.sin(4341) + Math.cos(4342) * 73;
+acc += Math.sin(4342) + Math.cos(4343) * 74;
+acc += Math.sin(4343) + Math.cos(4344) * 75;
+acc += Math.sin(4344) + Math.cos(4345) * 76;
+acc += Math.sin(4345) + Math.cos(4346) * 77;
+acc += Math.sin(4346) + Math.cos(4347) * 78;
+acc += Math.sin(4347) + Math.cos(4348) * 79;
+acc += Math.sin(4348) + Math.cos(4349) * 80;
+acc += Math.sin(4349) + Math.cos(4350) * 81;
+acc += Math.sin(4350) + Math.cos(4351) * 82;
+acc += Math.sin(4351) + Math.cos(4352) * 83;
+acc += Math.sin(4352) + Math.cos(4353) * 84;
+acc += Math.sin(4353) + Math.cos(4354) * 85;
+acc += Math.sin(4354) + Math.cos(4355) * 86;
+acc += Math.sin(4355) + Math.cos(4356) * 87;
+acc += Math.sin(4356) + Math.cos(4357) * 88;
+acc += Math.sin(4357) + Math.cos(4358) * 89;
+acc += Math.sin(4358) + Math.cos(4359) * 90;
+acc += Math.sin(4359) + Math.cos(4360) * 91;
+acc += Math.sin(4360) + Math.cos(4361) * 92;
+acc += Math.sin(4361) + Math.cos(4362) * 93;
+acc += Math.sin(4362) + Math.cos(4363) * 94;
+acc += Math.sin(4363) + Math.cos(4364) * 95;
+acc += Math.sin(4364) + Math.cos(4365) * 96;
+acc += Math.sin(4365) + Math.cos(4366) * 0;
+acc += Math.sin(4366) + Math.cos(4367) * 1;
+acc += Math.sin(4367) + Math.cos(4368) * 2;
+acc += Math.sin(4368) + Math.cos(4369) * 3;
+acc += Math.sin(4369) + Math.cos(4370) * 4;
+acc += Math.sin(4370) + Math.cos(4371) * 5;
+acc += Math.sin(4371) + Math.cos(4372) * 6;
+acc += Math.sin(4372) + Math.cos(4373) * 7;
+acc += Math.sin(4373) + Math.cos(4374) * 8;
+acc += Math.sin(4374) + Math.cos(4375) * 9;
+acc += Math.sin(4375) + Math.cos(4376) * 10;
+acc += Math.sin(4376) + Math.cos(4377) * 11;
+acc += Math.sin(4377) + Math.cos(4378) * 12;
+acc += Math.sin(4378) + Math.cos(4379) * 13;
+acc += Math.sin(4379) + Math.cos(4380) * 14;
+acc += Math.sin(4380) + Math.cos(4381) * 15;
+acc += Math.sin(4381) + Math.cos(4382) * 16;
+acc += Math.sin(4382) + Math.cos(4383) * 17;
+acc += Math.sin(4383) + Math.cos(4384) * 18;
+acc += Math.sin(4384) + Math.cos(4385) * 19;
+acc += Math.sin(4385) + Math.cos(4386) * 20;
+acc += Math.sin(4386) + Math.cos(4387) * 21;
+acc += Math.sin(4387) + Math.cos(4388) * 22;
+acc += Math.sin(4388) + Math.cos(4389) * 23;
+acc += Math.sin(4389) + Math.cos(4390) * 24;
+acc += Math.sin(4390) + Math.cos(4391) * 25;
+acc += Math.sin(4391) + Math.cos(4392) * 26;
+acc += Math.sin(4392) + Math.cos(4393) * 27;
+acc += Math.sin(4393) + Math.cos(4394) * 28;
+acc += Math.sin(4394) + Math.cos(4395) * 29;
+acc += Math.sin(4395) + Math.cos(4396) * 30;
+acc += Math.sin(4396) + Math.cos(4397) * 31;
+acc += Math.sin(4397) + Math.cos(4398) * 32;
+acc += Math.sin(4398) + Math.cos(4399) * 33;
+acc += Math.sin(4399) + Math.cos(4400) * 34;
+acc += Math.sin(4400) + Math.cos(4401) * 35;
+acc += Math.sin(4401) + Math.cos(4402) * 36;
+acc += Math.sin(4402) + Math.cos(4403) * 37;
+acc += Math.sin(4403) + Math.cos(4404) * 38;
+acc += Math.sin(4404) + Math.cos(4405) * 39;
+acc += Math.sin(4405) + Math.cos(4406) * 40;
+acc += Math.sin(4406) + Math.cos(4407) * 41;
+acc += Math.sin(4407) + Math.cos(4408) * 42;
+acc += Math.sin(4408) + Math.cos(4409) * 43;
+acc += Math.sin(4409) + Math.cos(4410) * 44;
+acc += Math.sin(4410) + Math.cos(4411) * 45;
+acc += Math.sin(4411) + Math.cos(4412) * 46;
+acc += Math.sin(4412) + Math.cos(4413) * 47;
+acc += Math.sin(4413) + Math.cos(4414) * 48;
+acc += Math.sin(4414) + Math.cos(4415) * 49;
+acc += Math.sin(4415) + Math.cos(4416) * 50;
+acc += Math.sin(4416) + Math.cos(4417) * 51;
+acc += Math.sin(4417) + Math.cos(4418) * 52;
+acc += Math.sin(4418) + Math.cos(4419) * 53;
+acc += Math.sin(4419) + Math.cos(4420) * 54;
+acc += Math.sin(4420) + Math.cos(4421) * 55;
+acc += Math.sin(4421) + Math.cos(4422) * 56;
+acc += Math.sin(4422) + Math.cos(4423) * 57;
+acc += Math.sin(4423) + Math.cos(4424) * 58;
+acc += Math.sin(4424) + Math.cos(4425) * 59;
+acc += Math.sin(4425) + Math.cos(4426) * 60;
+acc += Math.sin(4426) + Math.cos(4427) * 61;
+acc += Math.sin(4427) + Math.cos(4428) * 62;
+acc += Math.sin(4428) + Math.cos(4429) * 63;
+acc += Math.sin(4429) + Math.cos(4430) * 64;
+acc += Math.sin(4430) + Math.cos(4431) * 65;
+acc += Math.sin(4431) + Math.cos(4432) * 66;
+acc += Math.sin(4432) + Math.cos(4433) * 67;
+acc += Math.sin(4433) + Math.cos(4434) * 68;
+acc += Math.sin(4434) + Math.cos(4435) * 69;
+acc += Math.sin(4435) + Math.cos(4436) * 70;
+acc += Math.sin(4436) + Math.cos(4437) * 71;
+acc += Math.sin(4437) + Math.cos(4438) * 72;
+acc += Math.sin(4438) + Math.cos(4439) * 73;
+acc += Math.sin(4439) + Math.cos(4440) * 74;
+acc += Math.sin(4440) + Math.cos(4441) * 75;
+acc += Math.sin(4441) + Math.cos(4442) * 76;
+acc += Math.sin(4442) + Math.cos(4443) * 77;
+acc += Math.sin(4443) + Math.cos(4444) * 78;
+acc += Math.sin(4444) + Math.cos(4445) * 79;
+acc += Math.sin(4445) + Math.cos(4446) * 80;
+acc += Math.sin(4446) + Math.cos(4447) * 81;
+acc += Math.sin(4447) + Math.cos(4448) * 82;
+acc += Math.sin(4448) + Math.cos(4449) * 83;
+acc += Math.sin(4449) + Math.cos(4450) * 84;
+acc += Math.sin(4450) + Math.cos(4451) * 85;
+acc += Math.sin(4451) + Math.cos(4452) * 86;
+acc += Math.sin(4452) + Math.cos(4453) * 87;
+acc += Math.sin(4453) + Math.cos(4454) * 88;
+acc += Math.sin(4454) + Math.cos(4455) * 89;
+acc += Math.sin(4455) + Math.cos(4456) * 90;
+acc += Math.sin(4456) + Math.cos(4457) * 91;
+acc += Math.sin(4457) + Math.cos(4458) * 92;
+acc += Math.sin(4458) + Math.cos(4459) * 93;
+acc += Math.sin(4459) + Math.cos(4460) * 94;
+acc += Math.sin(4460) + Math.cos(4461) * 95;
+acc += Math.sin(4461) + Math.cos(4462) * 96;
+acc += Math.sin(4462) + Math.cos(4463) * 0;
+acc += Math.sin(4463) + Math.cos(4464) * 1;
+acc += Math.sin(4464) + Math.cos(4465) * 2;
+acc += Math.sin(4465) + Math.cos(4466) * 3;
+acc += Math.sin(4466) + Math.cos(4467) * 4;
+acc += Math.sin(4467) + Math.cos(4468) * 5;
+acc += Math.sin(4468) + Math.cos(4469) * 6;
+acc += Math.sin(4469) + Math.cos(4470) * 7;
+acc += Math.sin(4470) + Math.cos(4471) * 8;
+acc += Math.sin(4471) + Math.cos(4472) * 9;
+acc += Math.sin(4472) + Math.cos(4473) * 10;
+acc += Math.sin(4473) + Math.cos(4474) * 11;
+acc += Math.sin(4474) + Math.cos(4475) * 12;
+acc += Math.sin(4475) + Math.cos(4476) * 13;
+acc += Math.sin(4476) + Math.cos(4477) * 14;
+acc += Math.sin(4477) + Math.cos(4478) * 15;
+acc += Math.sin(4478) + Math.cos(4479) * 16;
+acc += Math.sin(4479) + Math.cos(4480) * 17;
+acc += Math.sin(4480) + Math.cos(4481) * 18;
+acc += Math.sin(4481) + Math.cos(4482) * 19;
+acc += Math.sin(4482) + Math.cos(4483) * 20;
+acc += Math.sin(4483) + Math.cos(4484) * 21;
+acc += Math.sin(4484) + Math.cos(4485) * 22;
+acc += Math.sin(4485) + Math.cos(4486) * 23;
+acc += Math.sin(4486) + Math.cos(4487) * 24;
+acc += Math.sin(4487) + Math.cos(4488) * 25;
+acc += Math.sin(4488) + Math.cos(4489) * 26;
+acc += Math.sin(4489) + Math.cos(4490) * 27;
+acc += Math.sin(4490) + Math.cos(4491) * 28;
+acc += Math.sin(4491) + Math.cos(4492) * 29;
+acc += Math.sin(4492) + Math.cos(4493) * 30;
+acc += Math.sin(4493) + Math.cos(4494) * 31;
+acc += Math.sin(4494) + Math.cos(4495) * 32;
+acc += Math.sin(4495) + Math.cos(4496) * 33;
+acc += Math.sin(4496) + Math.cos(4497) * 34;
+acc += Math.sin(4497) + Math.cos(4498) * 35;
+acc += Math.sin(4498) + Math.cos(4499) * 36;
+acc += Math.sin(4499) + Math.cos(4500) * 37;
+acc += Math.sin(4500) + Math.cos(4501) * 38;
+acc += Math.sin(4501) + Math.cos(4502) * 39;
+acc += Math.sin(4502) + Math.cos(4503) * 40;
+acc += Math.sin(4503) + Math.cos(4504) * 41;
+acc += Math.sin(4504) + Math.cos(4505) * 42;
+acc += Math.sin(4505) + Math.cos(4506) * 43;
+acc += Math.sin(4506) + Math.cos(4507) * 44;
+acc += Math.sin(4507) + Math.cos(4508) * 45;
+acc += Math.sin(4508) + Math.cos(4509) * 46;
+acc += Math.sin(4509) + Math.cos(4510) * 47;
+acc += Math.sin(4510) + Math.cos(4511) * 48;
+acc += Math.sin(4511) + Math.cos(4512) * 49;
+acc += Math.sin(4512) + Math.cos(4513) * 50;
+acc += Math.sin(4513) + Math.cos(4514) * 51;
+acc += Math.sin(4514) + Math.cos(4515) * 52;
+acc += Math.sin(4515) + Math.cos(4516) * 53;
+acc += Math.sin(4516) + Math.cos(4517) * 54;
+acc += Math.sin(4517) + Math.cos(4518) * 55;
+acc += Math.sin(4518) + Math.cos(4519) * 56;
+acc += Math.sin(4519) + Math.cos(4520) * 57;
+acc += Math.sin(4520) + Math.cos(4521) * 58;
+acc += Math.sin(4521) + Math.cos(4522) * 59;
+acc += Math.sin(4522) + Math.cos(4523) * 60;
+acc += Math.sin(4523) + Math.cos(4524) * 61;
+acc += Math.sin(4524) + Math.cos(4525) * 62;
+acc += Math.sin(4525) + Math.cos(4526) * 63;
+acc += Math.sin(4526) + Math.cos(4527) * 64;
+acc += Math.sin(4527) + Math.cos(4528) * 65;
+acc += Math.sin(4528) + Math.cos(4529) * 66;
+acc += Math.sin(4529) + Math.cos(4530) * 67;
+acc += Math.sin(4530) + Math.cos(4531) * 68;
+acc += Math.sin(4531) + Math.cos(4532) * 69;
+acc += Math.sin(4532) + Math.cos(4533) * 70;
+acc += Math.sin(4533) + Math.cos(4534) * 71;
+acc += Math.sin(4534) + Math.cos(4535) * 72;
+acc += Math.sin(4535) + Math.cos(4536) * 73;
+acc += Math.sin(4536) + Math.cos(4537) * 74;
+acc += Math.sin(4537) + Math.cos(4538) * 75;
+acc += Math.sin(4538) + Math.cos(4539) * 76;
+acc += Math.sin(4539) + Math.cos(4540) * 77;
+acc += Math.sin(4540) + Math.cos(4541) * 78;
+acc += Math.sin(4541) + Math.cos(4542) * 79;
+acc += Math.sin(4542) + Math.cos(4543) * 80;
+acc += Math.sin(4543) + Math.cos(4544) * 81;
+acc += Math.sin(4544) + Math.cos(4545) * 82;
+acc += Math.sin(4545) + Math.cos(4546) * 83;
+acc += Math.sin(4546) + Math.cos(4547) * 84;
+acc += Math.sin(4547) + Math.cos(4548) * 85;
+acc += Math.sin(4548) + Math.cos(4549) * 86;
+acc += Math.sin(4549) + Math.cos(4550) * 87;
+acc += Math.sin(4550) + Math.cos(4551) * 88;
+acc += Math.sin(4551) + Math.cos(4552) * 89;
+acc += Math.sin(4552) + Math.cos(4553) * 90;
+acc += Math.sin(4553) + Math.cos(4554) * 91;
+acc += Math.sin(4554) + Math.cos(4555) * 92;
+acc += Math.sin(4555) + Math.cos(4556) * 93;
+acc += Math.sin(4556) + Math.cos(4557) * 94;
+acc += Math.sin(4557) + Math.cos(4558) * 95;
+acc += Math.sin(4558) + Math.cos(4559) * 96;
+acc += Math.sin(4559) + Math.cos(4560) * 0;
+acc += Math.sin(4560) + Math.cos(4561) * 1;
+acc += Math.sin(4561) + Math.cos(4562) * 2;
+acc += Math.sin(4562) + Math.cos(4563) * 3;
+acc += Math.sin(4563) + Math.cos(4564) * 4;
+acc += Math.sin(4564) + Math.cos(4565) * 5;
+acc += Math.sin(4565) + Math.cos(4566) * 6;
+acc += Math.sin(4566) + Math.cos(4567) * 7;
+acc += Math.sin(4567) + Math.cos(4568) * 8;
+acc += Math.sin(4568) + Math.cos(4569) * 9;
+acc += Math.sin(4569) + Math.cos(4570) * 10;
+acc += Math.sin(4570) + Math.cos(4571) * 11;
+acc += Math.sin(4571) + Math.cos(4572) * 12;
+acc += Math.sin(4572) + Math.cos(4573) * 13;
+acc += Math.sin(4573) + Math.cos(4574) * 14;
+acc += Math.sin(4574) + Math.cos(4575) * 15;
+acc += Math.sin(4575) + Math.cos(4576) * 16;
+acc += Math.sin(4576) + Math.cos(4577) * 17;
+acc += Math.sin(4577) + Math.cos(4578) * 18;
+acc += Math.sin(4578) + Math.cos(4579) * 19;
+acc += Math.sin(4579) + Math.cos(4580) * 20;
+acc += Math.sin(4580) + Math.cos(4581) * 21;
+acc += Math.sin(4581) + Math.cos(4582) * 22;
+acc += Math.sin(4582) + Math.cos(4583) * 23;
+acc += Math.sin(4583) + Math.cos(4584) * 24;
+acc += Math.sin(4584) + Math.cos(4585) * 25;
+acc += Math.sin(4585) + Math.cos(4586) * 26;
+acc += Math.sin(4586) + Math.cos(4587) * 27;
+acc += Math.sin(4587) + Math.cos(4588) * 28;
+acc += Math.sin(4588) + Math.cos(4589) * 29;
+acc += Math.sin(4589) + Math.cos(4590) * 30;
+acc += Math.sin(4590) + Math.cos(4591) * 31;
+acc += Math.sin(4591) + Math.cos(4592) * 32;
+acc += Math.sin(4592) + Math.cos(4593) * 33;
+acc += Math.sin(4593) + Math.cos(4594) * 34;
+acc += Math.sin(4594) + Math.cos(4595) * 35;
+acc += Math.sin(4595) + Math.cos(4596) * 36;
+acc += Math.sin(4596) + Math.cos(4597) * 37;
+acc += Math.sin(4597) + Math.cos(4598) * 38;
+acc += Math.sin(4598) + Math.cos(4599) * 39;
+acc += Math.sin(4599) + Math.cos(4600) * 40;
+acc += Math.sin(4600) + Math.cos(4601) * 41;
+acc += Math.sin(4601) + Math.cos(4602) * 42;
+acc += Math.sin(4602) + Math.cos(4603) * 43;
+acc += Math.sin(4603) + Math.cos(4604) * 44;
+acc += Math.sin(4604) + Math.cos(4605) * 45;
+acc += Math.sin(4605) + Math.cos(4606) * 46;
+acc += Math.sin(4606) + Math.cos(4607) * 47;
+acc += Math.sin(4607) + Math.cos(4608) * 48;
+acc += Math.sin(4608) + Math.cos(4609) * 49;
+acc += Math.sin(4609) + Math.cos(4610) * 50;
+acc += Math.sin(4610) + Math.cos(4611) * 51;
+acc += Math.sin(4611) + Math.cos(4612) * 52;
+acc += Math.sin(4612) + Math.cos(4613) * 53;
+acc += Math.sin(4613) + Math.cos(4614) * 54;
+acc += Math.sin(4614) + Math.cos(4615) * 55;
+acc += Math.sin(4615) + Math.cos(4616) * 56;
+acc += Math.sin(4616) + Math.cos(4617) * 57;
+acc += Math.sin(4617) + Math.cos(4618) * 58;
+acc += Math.sin(4618) + Math.cos(4619) * 59;
+acc += Math.sin(4619) + Math.cos(4620) * 60;
+acc += Math.sin(4620) + Math.cos(4621) * 61;
+acc += Math.sin(4621) + Math.cos(4622) * 62;
+acc += Math.sin(4622) + Math.cos(4623) * 63;
+acc += Math.sin(4623) + Math.cos(4624) * 64;
+acc += Math.sin(4624) + Math.cos(4625) * 65;
+acc += Math.sin(4625) + Math.cos(4626) * 66;
+acc += Math.sin(4626) + Math.cos(4627) * 67;
+acc += Math.sin(4627) + Math.cos(4628) * 68;
+acc += Math.sin(4628) + Math.cos(4629) * 69;
+acc += Math.sin(4629) + Math.cos(4630) * 70;
+acc += Math.sin(4630) + Math.cos(4631) * 71;
+acc += Math.sin(4631) + Math.cos(4632) * 72;
+acc += Math.sin(4632) + Math.cos(4633) * 73;
+acc += Math.sin(4633) + Math.cos(4634) * 74;
+acc += Math.sin(4634) + Math.cos(4635) * 75;
+acc += Math.sin(4635) + Math.cos(4636) * 76;
+acc += Math.sin(4636) + Math.cos(4637) * 77;
+acc += Math.sin(4637) + Math.cos(4638) * 78;
+acc += Math.sin(4638) + Math.cos(4639) * 79;
+acc += Math.sin(4639) + Math.cos(4640) * 80;
+acc += Math.sin(4640) + Math.cos(4641) * 81;
+acc += Math.sin(4641) + Math.cos(4642) * 82;
+acc += Math.sin(4642) + Math.cos(4643) * 83;
+acc += Math.sin(4643) + Math.cos(4644) * 84;
+acc += Math.sin(4644) + Math.cos(4645) * 85;
+acc += Math.sin(4645) + Math.cos(4646) * 86;
+acc += Math.sin(4646) + Math.cos(4647) * 87;
+acc += Math.sin(4647) + Math.cos(4648) * 88;
+acc += Math.sin(4648) + Math.cos(4649) * 89;
+acc += Math.sin(4649) + Math.cos(4650) * 90;
+acc += Math.sin(4650) + Math.cos(4651) * 91;
+acc += Math.sin(4651) + Math.cos(4652) * 92;
+acc += Math.sin(4652) + Math.cos(4653) * 93;
+acc += Math.sin(4653) + Math.cos(4654) * 94;
+acc += Math.sin(4654) + Math.cos(4655) * 95;
+acc += Math.sin(4655) + Math.cos(4656) * 96;
+acc += Math.sin(4656) + Math.cos(4657) * 0;
+acc += Math.sin(4657) + Math.cos(4658) * 1;
+acc += Math.sin(4658) + Math.cos(4659) * 2;
+acc += Math.sin(4659) + Math.cos(4660) * 3;
+acc += Math.sin(4660) + Math.cos(4661) * 4;
+acc += Math.sin(4661) + Math.cos(4662) * 5;
+acc += Math.sin(4662) + Math.cos(4663) * 6;
+acc += Math.sin(4663) + Math.cos(4664) * 7;
+acc += Math.sin(4664) + Math.cos(4665) * 8;
+acc += Math.sin(4665) + Math.cos(4666) * 9;
+acc += Math.sin(4666) + Math.cos(4667) * 10;
+acc += Math.sin(4667) + Math.cos(4668) * 11;
+acc += Math.sin(4668) + Math.cos(4669) * 12;
+acc += Math.sin(4669) + Math.cos(4670) * 13;
+acc += Math.sin(4670) + Math.cos(4671) * 14;
+acc += Math.sin(4671) + Math.cos(4672) * 15;
+acc += Math.sin(4672) + Math.cos(4673) * 16;
+acc += Math.sin(4673) + Math.cos(4674) * 17;
+acc += Math.sin(4674) + Math.cos(4675) * 18;
+acc += Math.sin(4675) + Math.cos(4676) * 19;
+acc += Math.sin(4676) + Math.cos(4677) * 20;
+acc += Math.sin(4677) + Math.cos(4678) * 21;
+acc += Math.sin(4678) + Math.cos(4679) * 22;
+acc += Math.sin(4679) + Math.cos(4680) * 23;
+acc += Math.sin(4680) + Math.cos(4681) * 24;
+acc += Math.sin(4681) + Math.cos(4682) * 25;
+acc += Math.sin(4682) + Math.cos(4683) * 26;
+acc += Math.sin(4683) + Math.cos(4684) * 27;
+acc += Math.sin(4684) + Math.cos(4685) * 28;
+acc += Math.sin(4685) + Math.cos(4686) * 29;
+acc += Math.sin(4686) + Math.cos(4687) * 30;
+acc += Math.sin(4687) + Math.cos(4688) * 31;
+acc += Math.sin(4688) + Math.cos(4689) * 32;
+acc += Math.sin(4689) + Math.cos(4690) * 33;
+acc += Math.sin(4690) + Math.cos(4691) * 34;
+acc += Math.sin(4691) + Math.cos(4692) * 35;
+acc += Math.sin(4692) + Math.cos(4693) * 36;
+acc += Math.sin(4693) + Math.cos(4694) * 37;
+acc += Math.sin(4694) + Math.cos(4695) * 38;
+acc += Math.sin(4695) + Math.cos(4696) * 39;
+acc += Math.sin(4696) + Math.cos(4697) * 40;
+acc += Math.sin(4697) + Math.cos(4698) * 41;
+acc += Math.sin(4698) + Math.cos(4699) * 42;
+acc += Math.sin(4699) + Math.cos(4700) * 43;
+acc += Math.sin(4700) + Math.cos(4701) * 44;
+acc += Math.sin(4701) + Math.cos(4702) * 45;
+acc += Math.sin(4702) + Math.cos(4703) * 46;
+acc += Math.sin(4703) + Math.cos(4704) * 47;
+acc += Math.sin(4704) + Math.cos(4705) * 48;
+acc += Math.sin(4705) + Math.cos(4706) * 49;
+acc += Math.sin(4706) + Math.cos(4707) * 50;
+acc += Math.sin(4707) + Math.cos(4708) * 51;
+acc += Math.sin(4708) + Math.cos(4709) * 52;
+acc += Math.sin(4709) + Math.cos(4710) * 53;
+acc += Math.sin(4710) + Math.cos(4711) * 54;
+acc += Math.sin(4711) + Math.cos(4712) * 55;
+acc += Math.sin(4712) + Math.cos(4713) * 56;
+acc += Math.sin(4713) + Math.cos(4714) * 57;
+acc += Math.sin(4714) + Math.cos(4715) * 58;
+acc += Math.sin(4715) + Math.cos(4716) * 59;
+acc += Math.sin(4716) + Math.cos(4717) * 60;
+acc += Math.sin(4717) + Math.cos(4718) * 61;
+acc += Math.sin(4718) + Math.cos(4719) * 62;
+acc += Math.sin(4719) + Math.cos(4720) * 63;
+acc += Math.sin(4720) + Math.cos(4721) * 64;
+acc += Math.sin(4721) + Math.cos(4722) * 65;
+acc += Math.sin(4722) + Math.cos(4723) * 66;
+acc += Math.sin(4723) + Math.cos(4724) * 67;
+acc += Math.sin(4724) + Math.cos(4725) * 68;
+acc += Math.sin(4725) + Math.cos(4726) * 69;
+acc += Math.sin(4726) + Math.cos(4727) * 70;
+acc += Math.sin(4727) + Math.cos(4728) * 71;
+acc += Math.sin(4728) + Math.cos(4729) * 72;
+acc += Math.sin(4729) + Math.cos(4730) * 73;
+acc += Math.sin(4730) + Math.cos(4731) * 74;
+acc += Math.sin(4731) + Math.cos(4732) * 75;
+acc += Math.sin(4732) + Math.cos(4733) * 76;
+acc += Math.sin(4733) + Math.cos(4734) * 77;
+acc += Math.sin(4734) + Math.cos(4735) * 78;
+acc += Math.sin(4735) + Math.cos(4736) * 79;
+acc += Math.sin(4736) + Math.cos(4737) * 80;
+acc += Math.sin(4737) + Math.cos(4738) * 81;
+acc += Math.sin(4738) + Math.cos(4739) * 82;
+acc += Math.sin(4739) + Math.cos(4740) * 83;
+acc += Math.sin(4740) + Math.cos(4741) * 84;
+acc += Math.sin(4741) + Math.cos(4742) * 85;
+acc += Math.sin(4742) + Math.cos(4743) * 86;
+acc += Math.sin(4743) + Math.cos(4744) * 87;
+acc += Math.sin(4744) + Math.cos(4745) * 88;
+acc += Math.sin(4745) + Math.cos(4746) * 89;
+acc += Math.sin(4746) + Math.cos(4747) * 90;
+acc += Math.sin(4747) + Math.cos(4748) * 91;
+acc += Math.sin(4748) + Math.cos(4749) * 92;
+acc += Math.sin(4749) + Math.cos(4750) * 93;
+acc += Math.sin(4750) + Math.cos(4751) * 94;
+acc += Math.sin(4751) + Math.cos(4752) * 95;
+acc += Math.sin(4752) + Math.cos(4753) * 96;
+acc += Math.sin(4753) + Math.cos(4754) * 0;
+acc += Math.sin(4754) + Math.cos(4755) * 1;
+acc += Math.sin(4755) + Math.cos(4756) * 2;
+acc += Math.sin(4756) + Math.cos(4757) * 3;
+acc += Math.sin(4757) + Math.cos(4758) * 4;
+acc += Math.sin(4758) + Math.cos(4759) * 5;
+acc += Math.sin(4759) + Math.cos(4760) * 6;
+acc += Math.sin(4760) + Math.cos(4761) * 7;
+acc += Math.sin(4761) + Math.cos(4762) * 8;
+acc += Math.sin(4762) + Math.cos(4763) * 9;
+acc += Math.sin(4763) + Math.cos(4764) * 10;
+acc += Math.sin(4764) + Math.cos(4765) * 11;
+acc += Math.sin(4765) + Math.cos(4766) * 12;
+acc += Math.sin(4766) + Math.cos(4767) * 13;
+acc += Math.sin(4767) + Math.cos(4768) * 14;
+acc += Math.sin(4768) + Math.cos(4769) * 15;
+acc += Math.sin(4769) + Math.cos(4770) * 16;
+acc += Math.sin(4770) + Math.cos(4771) * 17;
+acc += Math.sin(4771) + Math.cos(4772) * 18;
+acc += Math.sin(4772) + Math.cos(4773) * 19;
+acc += Math.sin(4773) + Math.cos(4774) * 20;
+acc += Math.sin(4774) + Math.cos(4775) * 21;
+acc += Math.sin(4775) + Math.cos(4776) * 22;
+acc += Math.sin(4776) + Math.cos(4777) * 23;
+acc += Math.sin(4777) + Math.cos(4778) * 24;
+acc += Math.sin(4778) + Math.cos(4779) * 25;
+acc += Math.sin(4779) + Math.cos(4780) * 26;
+acc += Math.sin(4780) + Math.cos(4781) * 27;
+acc += Math.sin(4781) + Math.cos(4782) * 28;
+acc += Math.sin(4782) + Math.cos(4783) * 29;
+acc += Math.sin(4783) + Math.cos(4784) * 30;
+acc += Math.sin(4784) + Math.cos(4785) * 31;
+acc += Math.sin(4785) + Math.cos(4786) * 32;
+acc += Math.sin(4786) + Math.cos(4787) * 33;
+acc += Math.sin(4787) + Math.cos(4788) * 34;
+acc += Math.sin(4788) + Math.cos(4789) * 35;
+acc += Math.sin(4789) + Math.cos(4790) * 36;
+acc += Math.sin(4790) + Math.cos(4791) * 37;
+acc += Math.sin(4791) + Math.cos(4792) * 38;
+acc += Math.sin(4792) + Math.cos(4793) * 39;
+acc += Math.sin(4793) + Math.cos(4794) * 40;
+acc += Math.sin(4794) + Math.cos(4795) * 41;
+acc += Math.sin(4795) + Math.cos(4796) * 42;
+acc += Math.sin(4796) + Math.cos(4797) * 43;
+acc += Math.sin(4797) + Math.cos(4798) * 44;
+acc += Math.sin(4798) + Math.cos(4799) * 45;
+acc += Math.sin(4799) + Math.cos(4800) * 46;
+acc += Math.sin(4800) + Math.cos(4801) * 47;
+acc += Math.sin(4801) + Math.cos(4802) * 48;
+acc += Math.sin(4802) + Math.cos(4803) * 49;
+acc += Math.sin(4803) + Math.cos(4804) * 50;
+acc += Math.sin(4804) + Math.cos(4805) * 51;
+acc += Math.sin(4805) + Math.cos(4806) * 52;
+acc += Math.sin(4806) + Math.cos(4807) * 53;
+acc += Math.sin(4807) + Math.cos(4808) * 54;
+acc += Math.sin(4808) + Math.cos(4809) * 55;
+acc += Math.sin(4809) + Math.cos(4810) * 56;
+acc += Math.sin(4810) + Math.cos(4811) * 57;
+acc += Math.sin(4811) + Math.cos(4812) * 58;
+acc += Math.sin(4812) + Math.cos(4813) * 59;
+acc += Math.sin(4813) + Math.cos(4814) * 60;
+acc += Math.sin(4814) + Math.cos(4815) * 61;
+acc += Math.sin(4815) + Math.cos(4816) * 62;
+acc += Math.sin(4816) + Math.cos(4817) * 63;
+acc += Math.sin(4817) + Math.cos(4818) * 64;
+acc += Math.sin(4818) + Math.cos(4819) * 65;
+acc += Math.sin(4819) + Math.cos(4820) * 66;
+acc += Math.sin(4820) + Math.cos(4821) * 67;
+acc += Math.sin(4821) + Math.cos(4822) * 68;
+acc += Math.sin(4822) + Math.cos(4823) * 69;
+acc += Math.sin(4823) + Math.cos(4824) * 70;
+acc += Math.sin(4824) + Math.cos(4825) * 71;
+acc += Math.sin(4825) + Math.cos(4826) * 72;
+acc += Math.sin(4826) + Math.cos(4827) * 73;
+acc += Math.sin(4827) + Math.cos(4828) * 74;
+acc += Math.sin(4828) + Math.cos(4829) * 75;
+acc += Math.sin(4829) + Math.cos(4830) * 76;
+acc += Math.sin(4830) + Math.cos(4831) * 77;
+acc += Math.sin(4831) + Math.cos(4832) * 78;
+acc += Math.sin(4832) + Math.cos(4833) * 79;
+acc += Math.sin(4833) + Math.cos(4834) * 80;
+acc += Math.sin(4834) + Math.cos(4835) * 81;
+acc += Math.sin(4835) + Math.cos(4836) * 82;
+acc += Math.sin(4836) + Math.cos(4837) * 83;
+acc += Math.sin(4837) + Math.cos(4838) * 84;
+acc += Math.sin(4838) + Math.cos(4839) * 85;
+acc += Math.sin(4839) + Math.cos(4840) * 86;
+acc += Math.sin(4840) + Math.cos(4841) * 87;
+acc += Math.sin(4841) + Math.cos(4842) * 88;
+acc += Math.sin(4842) + Math.cos(4843) * 89;
+acc += Math.sin(4843) + Math.cos(4844) * 90;
+acc += Math.sin(4844) + Math.cos(4845) * 91;
+acc += Math.sin(4845) + Math.cos(4846) * 92;
+acc += Math.sin(4846) + Math.cos(4847) * 93;
+acc += Math.sin(4847) + Math.cos(4848) * 94;
+acc += Math.sin(4848) + Math.cos(4849) * 95;
+acc += Math.sin(4849) + Math.cos(4850) * 96;
+acc += Math.sin(4850) + Math.cos(4851) * 0;
+acc += Math.sin(4851) + Math.cos(4852) * 1;
+acc += Math.sin(4852) + Math.cos(4853) * 2;
+acc += Math.sin(4853) + Math.cos(4854) * 3;
+acc += Math.sin(4854) + Math.cos(4855) * 4;
+acc += Math.sin(4855) + Math.cos(4856) * 5;
+acc += Math.sin(4856) + Math.cos(4857) * 6;
+acc += Math.sin(4857) + Math.cos(4858) * 7;
+acc += Math.sin(4858) + Math.cos(4859) * 8;
+acc += Math.sin(4859) + Math.cos(4860) * 9;
+acc += Math.sin(4860) + Math.cos(4861) * 10;
+acc += Math.sin(4861) + Math.cos(4862) * 11;
+acc += Math.sin(4862) + Math.cos(4863) * 12;
+acc += Math.sin(4863) + Math.cos(4864) * 13;
+acc += Math.sin(4864) + Math.cos(4865) * 14;
+acc += Math.sin(4865) + Math.cos(4866) * 15;
+acc += Math.sin(4866) + Math.cos(4867) * 16;
+acc += Math.sin(4867) + Math.cos(4868) * 17;
+acc += Math.sin(4868) + Math.cos(4869) * 18;
+acc += Math.sin(4869) + Math.cos(4870) * 19;
+acc += Math.sin(4870) + Math.cos(4871) * 20;
+acc += Math.sin(4871) + Math.cos(4872) * 21;
+acc += Math.sin(4872) + Math.cos(4873) * 22;
+acc += Math.sin(4873) + Math.cos(4874) * 23;
+acc += Math.sin(4874) + Math.cos(4875) * 24;
+acc += Math.sin(4875) + Math.cos(4876) * 25;
+acc += Math.sin(4876) + Math.cos(4877) * 26;
+acc += Math.sin(4877) + Math.cos(4878) * 27;
+acc += Math.sin(4878) + Math.cos(4879) * 28;
+acc += Math.sin(4879) + Math.cos(4880) * 29;
+acc += Math.sin(4880) + Math.cos(4881) * 30;
+acc += Math.sin(4881) + Math.cos(4882) * 31;
+acc += Math.sin(4882) + Math.cos(4883) * 32;
+acc += Math.sin(4883) + Math.cos(4884) * 33;
+acc += Math.sin(4884) + Math.cos(4885) * 34;
+acc += Math.sin(4885) + Math.cos(4886) * 35;
+acc += Math.sin(4886) + Math.cos(4887) * 36;
+acc += Math.sin(4887) + Math.cos(4888) * 37;
+acc += Math.sin(4888) + Math.cos(4889) * 38;
+acc += Math.sin(4889) + Math.cos(4890) * 39;
+acc += Math.sin(4890) + Math.cos(4891) * 40;
+acc += Math.sin(4891) + Math.cos(4892) * 41;
+acc += Math.sin(4892) + Math.cos(4893) * 42;
+acc += Math.sin(4893) + Math.cos(4894) * 43;
+acc += Math.sin(4894) + Math.cos(4895) * 44;
+acc += Math.sin(4895) + Math.cos(4896) * 45;
+acc += Math.sin(4896) + Math.cos(4897) * 46;
+acc += Math.sin(4897) + Math.cos(4898) * 47;
+acc += Math.sin(4898) + Math.cos(4899) * 48;
+acc += Math.sin(4899) + Math.cos(4900) * 49;
+acc += Math.sin(4900) + Math.cos(4901) * 50;
+acc += Math.sin(4901) + Math.cos(4902) * 51;
+acc += Math.sin(4902) + Math.cos(4903) * 52;
+acc += Math.sin(4903) + Math.cos(4904) * 53;
+acc += Math.sin(4904) + Math.cos(4905) * 54;
+acc += Math.sin(4905) + Math.cos(4906) * 55;
+acc += Math.sin(4906) + Math.cos(4907) * 56;
+acc += Math.sin(4907) + Math.cos(4908) * 57;
+acc += Math.sin(4908) + Math.cos(4909) * 58;
+acc += Math.sin(4909) + Math.cos(4910) * 59;
+acc += Math.sin(4910) + Math.cos(4911) * 60;
+acc += Math.sin(4911) + Math.cos(4912) * 61;
+acc += Math.sin(4912) + Math.cos(4913) * 62;
+acc += Math.sin(4913) + Math.cos(4914) * 63;
+acc += Math.sin(4914) + Math.cos(4915) * 64;
+acc += Math.sin(4915) + Math.cos(4916) * 65;
+acc += Math.sin(4916) + Math.cos(4917) * 66;
+acc += Math.sin(4917) + Math.cos(4918) * 67;
+acc += Math.sin(4918) + Math.cos(4919) * 68;
+acc += Math.sin(4919) + Math.cos(4920) * 69;
+acc += Math.sin(4920) + Math.cos(4921) * 70;
+acc += Math.sin(4921) + Math.cos(4922) * 71;
+acc += Math.sin(4922) + Math.cos(4923) * 72;
+acc += Math.sin(4923) + Math.cos(4924) * 73;
+acc += Math.sin(4924) + Math.cos(4925) * 74;
+acc += Math.sin(4925) + Math.cos(4926) * 75;
+acc += Math.sin(4926) + Math.cos(4927) * 76;
+acc += Math.sin(4927) + Math.cos(4928) * 77;
+acc += Math.sin(4928) + Math.cos(4929) * 78;
+acc += Math.sin(4929) + Math.cos(4930) * 79;
+acc += Math.sin(4930) + Math.cos(4931) * 80;
+acc += Math.sin(4931) + Math.cos(4932) * 81;
+acc += Math.sin(4932) + Math.cos(4933) * 82;
+acc += Math.sin(4933) + Math.cos(4934) * 83;
+acc += Math.sin(4934) + Math.cos(4935) * 84;
+acc += Math.sin(4935) + Math.cos(4936) * 85;
+acc += Math.sin(4936) + Math.cos(4937) * 86;
+acc += Math.sin(4937) + Math.cos(4938) * 87;
+acc += Math.sin(4938) + Math.cos(4939) * 88;
+acc += Math.sin(4939) + Math.cos(4940) * 89;
+acc += Math.sin(4940) + Math.cos(4941) * 90;
+acc += Math.sin(4941) + Math.cos(4942) * 91;
+acc += Math.sin(4942) + Math.cos(4943) * 92;
+acc += Math.sin(4943) + Math.cos(4944) * 93;
+acc += Math.sin(4944) + Math.cos(4945) * 94;
+acc += Math.sin(4945) + Math.cos(4946) * 95;
+acc += Math.sin(4946) + Math.cos(4947) * 96;
+acc += Math.sin(4947) + Math.cos(4948) * 0;
+acc += Math.sin(4948) + Math.cos(4949) * 1;
+acc += Math.sin(4949) + Math.cos(4950) * 2;
+acc += Math.sin(4950) + Math.cos(4951) * 3;
+acc += Math.sin(4951) + Math.cos(4952) * 4;
+acc += Math.sin(4952) + Math.cos(4953) * 5;
+acc += Math.sin(4953) + Math.cos(4954) * 6;
+acc += Math.sin(4954) + Math.cos(4955) * 7;
+acc += Math.sin(4955) + Math.cos(4956) * 8;
+acc += Math.sin(4956) + Math.cos(4957) * 9;
+acc += Math.sin(4957) + Math.cos(4958) * 10;
+acc += Math.sin(4958) + Math.cos(4959) * 11;
+acc += Math.sin(4959) + Math.cos(4960) * 12;
+acc += Math.sin(4960) + Math.cos(4961) * 13;
+acc += Math.sin(4961) + Math.cos(4962) * 14;
+acc += Math.sin(4962) + Math.cos(4963) * 15;
+acc += Math.sin(4963) + Math.cos(4964) * 16;
+acc += Math.sin(4964) + Math.cos(4965) * 17;
+acc += Math.sin(4965) + Math.cos(4966) * 18;
+acc += Math.sin(4966) + Math.cos(4967) * 19;
+acc += Math.sin(4967) + Math.cos(4968) * 20;
+acc += Math.sin(4968) + Math.cos(4969) * 21;
+acc += Math.sin(4969) + Math.cos(4970) * 22;
+acc += Math.sin(4970) + Math.cos(4971) * 23;
+acc += Math.sin(4971) + Math.cos(4972) * 24;
+acc += Math.sin(4972) + Math.cos(4973) * 25;
+acc += Math.sin(4973) + Math.cos(4974) * 26;
+acc += Math.sin(4974) + Math.cos(4975) * 27;
+acc += Math.sin(4975) + Math.cos(4976) * 28;
+acc += Math.sin(4976) + Math.cos(4977) * 29;
+acc += Math.sin(4977) + Math.cos(4978) * 30;
+acc += Math.sin(4978) + Math.cos(4979) * 31;
+acc += Math.sin(4979) + Math.cos(4980) * 32;
+acc += Math.sin(4980) + Math.cos(4981) * 33;
+acc += Math.sin(4981) + Math.cos(4982) * 34;
+acc += Math.sin(4982) + Math.cos(4983) * 35;
+acc += Math.sin(4983) + Math.cos(4984) * 36;
+acc += Math.sin(4984) + Math.cos(4985) * 37;
+acc += Math.sin(4985) + Math.cos(4986) * 38;
+acc += Math.sin(4986) + Math.cos(4987) * 39;
+acc += Math.sin(4987) + Math.cos(4988) * 40;
+acc += Math.sin(4988) + Math.cos(4989) * 41;
+acc += Math.sin(4989) + Math.cos(4990) * 42;
+acc += Math.sin(4990) + Math.cos(4991) * 43;
+acc += Math.sin(4991) + Math.cos(4992) * 44;
+acc += Math.sin(4992) + Math.cos(4993) * 45;
+acc += Math.sin(4993) + Math.cos(4994) * 46;
+acc += Math.sin(4994) + Math.cos(4995) * 47;
+acc += Math.sin(4995) + Math.cos(4996) * 48;
+acc += Math.sin(4996) + Math.cos(4997) * 49;
+acc += Math.sin(4997) + Math.cos(4998) * 50;
+acc += Math.sin(4998) + Math.cos(4999) * 51;
+acc += Math.sin(4999) + Math.cos(5000) * 52;
+acc += Math.sin(5000) + Math.cos(5001) * 53;
+acc += Math.sin(5001) + Math.cos(5002) * 54;
+acc += Math.sin(5002) + Math.cos(5003) * 55;
+acc += Math.sin(5003) + Math.cos(5004) * 56;
+acc += Math.sin(5004) + Math.cos(5005) * 57;
+acc += Math.sin(5005) + Math.cos(5006) * 58;
+acc += Math.sin(5006) + Math.cos(5007) * 59;
+acc += Math.sin(5007) + Math.cos(5008) * 60;
+acc += Math.sin(5008) + Math.cos(5009) * 61;
+acc += Math.sin(5009) + Math.cos(5010) * 62;
+acc += Math.sin(5010) + Math.cos(5011) * 63;
+acc += Math.sin(5011) + Math.cos(5012) * 64;
+acc += Math.sin(5012) + Math.cos(5013) * 65;
+acc += Math.sin(5013) + Math.cos(5014) * 66;
+acc += Math.sin(5014) + Math.cos(5015) * 67;
+acc += Math.sin(5015) + Math.cos(5016) * 68;
+acc += Math.sin(5016) + Math.cos(5017) * 69;
+acc += Math.sin(5017) + Math.cos(5018) * 70;
+acc += Math.sin(5018) + Math.cos(5019) * 71;
+acc += Math.sin(5019) + Math.cos(5020) * 72;
+acc += Math.sin(5020) + Math.cos(5021) * 73;
+acc += Math.sin(5021) + Math.cos(5022) * 74;
+acc += Math.sin(5022) + Math.cos(5023) * 75;
+acc += Math.sin(5023) + Math.cos(5024) * 76;
+acc += Math.sin(5024) + Math.cos(5025) * 77;
+acc += Math.sin(5025) + Math.cos(5026) * 78;
+acc += Math.sin(5026) + Math.cos(5027) * 79;
+acc += Math.sin(5027) + Math.cos(5028) * 80;
+acc += Math.sin(5028) + Math.cos(5029) * 81;
+acc += Math.sin(5029) + Math.cos(5030) * 82;
+acc += Math.sin(5030) + Math.cos(5031) * 83;
+acc += Math.sin(5031) + Math.cos(5032) * 84;
+acc += Math.sin(5032) + Math.cos(5033) * 85;
+acc += Math.sin(5033) + Math.cos(5034) * 86;
+acc += Math.sin(5034) + Math.cos(5035) * 87;
+acc += Math.sin(5035) + Math.cos(5036) * 88;
+acc += Math.sin(5036) + Math.cos(5037) * 89;
+acc += Math.sin(5037) + Math.cos(5038) * 90;
+acc += Math.sin(5038) + Math.cos(5039) * 91;
+acc += Math.sin(5039) + Math.cos(5040) * 92;
+acc += Math.sin(5040) + Math.cos(5041) * 93;
+acc += Math.sin(5041) + Math.cos(5042) * 94;
+acc += Math.sin(5042) + Math.cos(5043) * 95;
+acc += Math.sin(5043) + Math.cos(5044) * 96;
+acc += Math.sin(5044) + Math.cos(5045) * 0;
+acc += Math.sin(5045) + Math.cos(5046) * 1;
+acc += Math.sin(5046) + Math.cos(5047) * 2;
+acc += Math.sin(5047) + Math.cos(5048) * 3;
+acc += Math.sin(5048) + Math.cos(5049) * 4;
+acc += Math.sin(5049) + Math.cos(5050) * 5;
+acc += Math.sin(5050) + Math.cos(5051) * 6;
+acc += Math.sin(5051) + Math.cos(5052) * 7;
+acc += Math.sin(5052) + Math.cos(5053) * 8;
+acc += Math.sin(5053) + Math.cos(5054) * 9;
+acc += Math.sin(5054) + Math.cos(5055) * 10;
+acc += Math.sin(5055) + Math.cos(5056) * 11;
+acc += Math.sin(5056) + Math.cos(5057) * 12;
+acc += Math.sin(5057) + Math.cos(5058) * 13;
+acc += Math.sin(5058) + Math.cos(5059) * 14;
+acc += Math.sin(5059) + Math.cos(5060) * 15;
+acc += Math.sin(5060) + Math.cos(5061) * 16;
+acc += Math.sin(5061) + Math.cos(5062) * 17;
+acc += Math.sin(5062) + Math.cos(5063) * 18;
+acc += Math.sin(5063) + Math.cos(5064) * 19;
+acc += Math.sin(5064) + Math.cos(5065) * 20;
+acc += Math.sin(5065) + Math.cos(5066) * 21;
+acc += Math.sin(5066) + Math.cos(5067) * 22;
+acc += Math.sin(5067) + Math.cos(5068) * 23;
+acc += Math.sin(5068) + Math.cos(5069) * 24;
+acc += Math.sin(5069) + Math.cos(5070) * 25;
+acc += Math.sin(5070) + Math.cos(5071) * 26;
+acc += Math.sin(5071) + Math.cos(5072) * 27;
+acc += Math.sin(5072) + Math.cos(5073) * 28;
+acc += Math.sin(5073) + Math.cos(5074) * 29;
+acc += Math.sin(5074) + Math.cos(5075) * 30;
+acc += Math.sin(5075) + Math.cos(5076) * 31;
+acc += Math.sin(5076) + Math.cos(5077) * 32;
+acc += Math.sin(5077) + Math.cos(5078) * 33;
+acc += Math.sin(5078) + Math.cos(5079) * 34;
+acc += Math.sin(5079) + Math.cos(5080) * 35;
+acc += Math.sin(5080) + Math.cos(5081) * 36;
+acc += Math.sin(5081) + Math.cos(5082) * 37;
+acc += Math.sin(5082) + Math.cos(5083) * 38;
+acc += Math.sin(5083) + Math.cos(5084) * 39;
+acc += Math.sin(5084) + Math.cos(5085) * 40;
+acc += Math.sin(5085) + Math.cos(5086) * 41;
+acc += Math.sin(5086) + Math.cos(5087) * 42;
+acc += Math.sin(5087) + Math.cos(5088) * 43;
+acc += Math.sin(5088) + Math.cos(5089) * 44;
+acc += Math.sin(5089) + Math.cos(5090) * 45;
+acc += Math.sin(5090) + Math.cos(5091) * 46;
+acc += Math.sin(5091) + Math.cos(5092) * 47;
+acc += Math.sin(5092) + Math.cos(5093) * 48;
+acc += Math.sin(5093) + Math.cos(5094) * 49;
+acc += Math.sin(5094) + Math.cos(5095) * 50;
+acc += Math.sin(5095) + Math.cos(5096) * 51;
+acc += Math.sin(5096) + Math.cos(5097) * 52;
+acc += Math.sin(5097) + Math.cos(5098) * 53;
+acc += Math.sin(5098) + Math.cos(5099) * 54;
+acc += Math.sin(5099) + Math.cos(5100) * 55;
+acc += Math.sin(5100) + Math.cos(5101) * 56;
+acc += Math.sin(5101) + Math.cos(5102) * 57;
+acc += Math.sin(5102) + Math.cos(5103) * 58;
+acc += Math.sin(5103) + Math.cos(5104) * 59;
+acc += Math.sin(5104) + Math.cos(5105) * 60;
+acc += Math.sin(5105) + Math.cos(5106) * 61;
+acc += Math.sin(5106) + Math.cos(5107) * 62;
+acc += Math.sin(5107) + Math.cos(5108) * 63;
+acc += Math.sin(5108) + Math.cos(5109) * 64;
+acc += Math.sin(5109) + Math.cos(5110) * 65;
+acc += Math.sin(5110) + Math.cos(5111) * 66;
+acc += Math.sin(5111) + Math.cos(5112) * 67;
+acc += Math.sin(5112) + Math.cos(5113) * 68;
+acc += Math.sin(5113) + Math.cos(5114) * 69;
+acc += Math.sin(5114) + Math.cos(5115) * 70;
+acc += Math.sin(5115) + Math.cos(5116) * 71;
+acc += Math.sin(5116) + Math.cos(5117) * 72;
+acc += Math.sin(5117) + Math.cos(5118) * 73;
+acc += Math.sin(5118) + Math.cos(5119) * 74;
+acc += Math.sin(5119) + Math.cos(5120) * 75;
+acc += Math.sin(5120) + Math.cos(5121) * 76;
+acc += Math.sin(5121) + Math.cos(5122) * 77;
+acc += Math.sin(5122) + Math.cos(5123) * 78;
+acc += Math.sin(5123) + Math.cos(5124) * 79;
+acc += Math.sin(5124) + Math.cos(5125) * 80;
+acc += Math.sin(5125) + Math.cos(5126) * 81;
+acc += Math.sin(5126) + Math.cos(5127) * 82;
+acc += Math.sin(5127) + Math.cos(5128) * 83;
+acc += Math.sin(5128) + Math.cos(5129) * 84;
+acc += Math.sin(5129) + Math.cos(5130) * 85;
+acc += Math.sin(5130) + Math.cos(5131) * 86;
+acc += Math.sin(5131) + Math.cos(5132) * 87;
+acc += Math.sin(5132) + Math.cos(5133) * 88;
+acc += Math.sin(5133) + Math.cos(5134) * 89;
+acc += Math.sin(5134) + Math.cos(5135) * 90;
+acc += Math.sin(5135) + Math.cos(5136) * 91;
+acc += Math.sin(5136) + Math.cos(5137) * 92;
+acc += Math.sin(5137) + Math.cos(5138) * 93;
+acc += Math.sin(5138) + Math.cos(5139) * 94;
+acc += Math.sin(5139) + Math.cos(5140) * 95;
+acc += Math.sin(5140) + Math.cos(5141) * 96;
+acc += Math.sin(5141) + Math.cos(5142) * 0;
+acc += Math.sin(5142) + Math.cos(5143) * 1;
+acc += Math.sin(5143) + Math.cos(5144) * 2;
+acc += Math.sin(5144) + Math.cos(5145) * 3;
+acc += Math.sin(5145) + Math.cos(5146) * 4;
+acc += Math.sin(5146) + Math.cos(5147) * 5;
+acc += Math.sin(5147) + Math.cos(5148) * 6;
+acc += Math.sin(5148) + Math.cos(5149) * 7;
+acc += Math.sin(5149) + Math.cos(5150) * 8;
+acc += Math.sin(5150) + Math.cos(5151) * 9;
+acc += Math.sin(5151) + Math.cos(5152) * 10;
+acc += Math.sin(5152) + Math.cos(5153) * 11;
+acc += Math.sin(5153) + Math.cos(5154) * 12;
+acc += Math.sin(5154) + Math.cos(5155) * 13;
+acc += Math.sin(5155) + Math.cos(5156) * 14;
+acc += Math.sin(5156) + Math.cos(5157) * 15;
+acc += Math.sin(5157) + Math.cos(5158) * 16;
+acc += Math.sin(5158) + Math.cos(5159) * 17;
+acc += Math.sin(5159) + Math.cos(5160) * 18;
+acc += Math.sin(5160) + Math.cos(5161) * 19;
+acc += Math.sin(5161) + Math.cos(5162) * 20;
+acc += Math.sin(5162) + Math.cos(5163) * 21;
+acc += Math.sin(5163) + Math.cos(5164) * 22;
+acc += Math.sin(5164) + Math.cos(5165) * 23;
+acc += Math.sin(5165) + Math.cos(5166) * 24;
+acc += Math.sin(5166) + Math.cos(5167) * 25;
+acc += Math.sin(5167) + Math.cos(5168) * 26;
+acc += Math.sin(5168) + Math.cos(5169) * 27;
+acc += Math.sin(5169) + Math.cos(5170) * 28;
+acc += Math.sin(5170) + Math.cos(5171) * 29;
+acc += Math.sin(5171) + Math.cos(5172) * 30;
+acc += Math.sin(5172) + Math.cos(5173) * 31;
+acc += Math.sin(5173) + Math.cos(5174) * 32;
+acc += Math.sin(5174) + Math.cos(5175) * 33;
+acc += Math.sin(5175) + Math.cos(5176) * 34;
+acc += Math.sin(5176) + Math.cos(5177) * 35;
+acc += Math.sin(5177) + Math.cos(5178) * 36;
+acc += Math.sin(5178) + Math.cos(5179) * 37;
+acc += Math.sin(5179) + Math.cos(5180) * 38;
+acc += Math.sin(5180) + Math.cos(5181) * 39;
+acc += Math.sin(5181) + Math.cos(5182) * 40;
+acc += Math.sin(5182) + Math.cos(5183) * 41;
+acc += Math.sin(5183) + Math.cos(5184) * 42;
+acc += Math.sin(5184) + Math.cos(5185) * 43;
+acc += Math.sin(5185) + Math.cos(5186) * 44;
+acc += Math.sin(5186) + Math.cos(5187) * 45;
+acc += Math.sin(5187) + Math.cos(5188) * 46;
+acc += Math.sin(5188) + Math.cos(5189) * 47;
+acc += Math.sin(5189) + Math.cos(5190) * 48;
+acc += Math.sin(5190) + Math.cos(5191) * 49;
+acc += Math.sin(5191) + Math.cos(5192) * 50;
+acc += Math.sin(5192) + Math.cos(5193) * 51;
+acc += Math.sin(5193) + Math.cos(5194) * 52;
+acc += Math.sin(5194) + Math.cos(5195) * 53;
+acc += Math.sin(5195) + Math.cos(5196) * 54;
+acc += Math.sin(5196) + Math.cos(5197) * 55;
+acc += Math.sin(5197) + Math.cos(5198) * 56;
+acc += Math.sin(5198) + Math.cos(5199) * 57;
+acc += Math.sin(5199) + Math.cos(5200) * 58;
+acc += Math.sin(5200) + Math.cos(5201) * 59;
+acc += Math.sin(5201) + Math.cos(5202) * 60;
+acc += Math.sin(5202) + Math.cos(5203) * 61;
+acc += Math.sin(5203) + Math.cos(5204) * 62;
+acc += Math.sin(5204) + Math.cos(5205) * 63;
+acc += Math.sin(5205) + Math.cos(5206) * 64;
+acc += Math.sin(5206) + Math.cos(5207) * 65;
+acc += Math.sin(5207) + Math.cos(5208) * 66;
+acc += Math.sin(5208) + Math.cos(5209) * 67;
+acc += Math.sin(5209) + Math.cos(5210) * 68;
+acc += Math.sin(5210) + Math.cos(5211) * 69;
+acc += Math.sin(5211) + Math.cos(5212) * 70;
+acc += Math.sin(5212) + Math.cos(5213) * 71;
+acc += Math.sin(5213) + Math.cos(5214) * 72;
+acc += Math.sin(5214) + Math.cos(5215) * 73;
+acc += Math.sin(5215) + Math.cos(5216) * 74;
+acc += Math.sin(5216) + Math.cos(5217) * 75;
+acc += Math.sin(5217) + Math.cos(5218) * 76;
+acc += Math.sin(5218) + Math.cos(5219) * 77;
+acc += Math.sin(5219) + Math.cos(5220) * 78;
+acc += Math.sin(5220) + Math.cos(5221) * 79;
+acc += Math.sin(5221) + Math.cos(5222) * 80;
+acc += Math.sin(5222) + Math.cos(5223) * 81;
+acc += Math.sin(5223) + Math.cos(5224) * 82;
+acc += Math.sin(5224) + Math.cos(5225) * 83;
+acc += Math.sin(5225) + Math.cos(5226) * 84;
+acc += Math.sin(5226) + Math.cos(5227) * 85;
+acc += Math.sin(5227) + Math.cos(5228) * 86;
+acc += Math.sin(5228) + Math.cos(5229) * 87;
+acc += Math.sin(5229) + Math.cos(5230) * 88;
+acc += Math.sin(5230) + Math.cos(5231) * 89;
+acc += Math.sin(5231) + Math.cos(5232) * 90;
+acc += Math.sin(5232) + Math.cos(5233) * 91;
+acc += Math.sin(5233) + Math.cos(5234) * 92;
+acc += Math.sin(5234) + Math.cos(5235) * 93;
+acc += Math.sin(5235) + Math.cos(5236) * 94;
+acc += Math.sin(5236) + Math.cos(5237) * 95;
+acc += Math.sin(5237) + Math.cos(5238) * 96;
+acc += Math.sin(5238) + Math.cos(5239) * 0;
+acc += Math.sin(5239) + Math.cos(5240) * 1;
+acc += Math.sin(5240) + Math.cos(5241) * 2;
+acc += Math.sin(5241) + Math.cos(5242) * 3;
+acc += Math.sin(5242) + Math.cos(5243) * 4;
+acc += Math.sin(5243) + Math.cos(5244) * 5;
+acc += Math.sin(5244) + Math.cos(5245) * 6;
+acc += Math.sin(5245) + Math.cos(5246) * 7;
+acc += Math.sin(5246) + Math.cos(5247) * 8;
+acc += Math.sin(5247) + Math.cos(5248) * 9;
+acc += Math.sin(5248) + Math.cos(5249) * 10;
+acc += Math.sin(5249) + Math.cos(5250) * 11;
+acc += Math.sin(5250) + Math.cos(5251) * 12;
+acc += Math.sin(5251) + Math.cos(5252) * 13;
+acc += Math.sin(5252) + Math.cos(5253) * 14;
+acc += Math.sin(5253) + Math.cos(5254) * 15;
+acc += Math.sin(5254) + Math.cos(5255) * 16;
+acc += Math.sin(5255) + Math.cos(5256) * 17;
+acc += Math.sin(5256) + Math.cos(5257) * 18;
+acc += Math.sin(5257) + Math.cos(5258) * 19;
+acc += Math.sin(5258) + Math.cos(5259) * 20;
+acc += Math.sin(5259) + Math.cos(5260) * 21;
+acc += Math.sin(5260) + Math.cos(5261) * 22;
+acc += Math.sin(5261) + Math.cos(5262) * 23;
+acc += Math.sin(5262) + Math.cos(5263) * 24;
+acc += Math.sin(5263) + Math.cos(5264) * 25;
+acc += Math.sin(5264) + Math.cos(5265) * 26;
+acc += Math.sin(5265) + Math.cos(5266) * 27;
+acc += Math.sin(5266) + Math.cos(5267) * 28;
+acc += Math.sin(5267) + Math.cos(5268) * 29;
+acc += Math.sin(5268) + Math.cos(5269) * 30;
+acc += Math.sin(5269) + Math.cos(5270) * 31;
+acc += Math.sin(5270) + Math.cos(5271) * 32;
+acc += Math.sin(5271) + Math.cos(5272) * 33;
+acc += Math.sin(5272) + Math.cos(5273) * 34;
+acc += Math.sin(5273) + Math.cos(5274) * 35;
+acc += Math.sin(5274) + Math.cos(5275) * 36;
+acc += Math.sin(5275) + Math.cos(5276) * 37;
+acc += Math.sin(5276) + Math.cos(5277) * 38;
+acc += Math.sin(5277) + Math.cos(5278) * 39;
+acc += Math.sin(5278) + Math.cos(5279) * 40;
+acc += Math.sin(5279) + Math.cos(5280) * 41;
+acc += Math.sin(5280) + Math.cos(5281) * 42;
+acc += Math.sin(5281) + Math.cos(5282) * 43;
+acc += Math.sin(5282) + Math.cos(5283) * 44;
+acc += Math.sin(5283) + Math.cos(5284) * 45;
+acc += Math.sin(5284) + Math.cos(5285) * 46;
+acc += Math.sin(5285) + Math.cos(5286) * 47;
+acc += Math.sin(5286) + Math.cos(5287) * 48;
+acc += Math.sin(5287) + Math.cos(5288) * 49;
+acc += Math.sin(5288) + Math.cos(5289) * 50;
+acc += Math.sin(5289) + Math.cos(5290) * 51;
+acc += Math.sin(5290) + Math.cos(5291) * 52;
+acc += Math.sin(5291) + Math.cos(5292) * 53;
+acc += Math.sin(5292) + Math.cos(5293) * 54;
+acc += Math.sin(5293) + Math.cos(5294) * 55;
+acc += Math.sin(5294) + Math.cos(5295) * 56;
+acc += Math.sin(5295) + Math.cos(5296) * 57;
+acc += Math.sin(5296) + Math.cos(5297) * 58;
+acc += Math.sin(5297) + Math.cos(5298) * 59;
+acc += Math.sin(5298) + Math.cos(5299) * 60;
+acc += Math.sin(5299) + Math.cos(5300) * 61;
+acc += Math.sin(5300) + Math.cos(5301) * 62;
+acc += Math.sin(5301) + Math.cos(5302) * 63;
+acc += Math.sin(5302) + Math.cos(5303) * 64;
+acc += Math.sin(5303) + Math.cos(5304) * 65;
+acc += Math.sin(5304) + Math.cos(5305) * 66;
+acc += Math.sin(5305) + Math.cos(5306) * 67;
+acc += Math.sin(5306) + Math.cos(5307) * 68;
+acc += Math.sin(5307) + Math.cos(5308) * 69;
+acc += Math.sin(5308) + Math.cos(5309) * 70;
+acc += Math.sin(5309) + Math.cos(5310) * 71;
+acc += Math.sin(5310) + Math.cos(5311) * 72;
+acc += Math.sin(5311) + Math.cos(5312) * 73;
+acc += Math.sin(5312) + Math.cos(5313) * 74;
+acc += Math.sin(5313) + Math.cos(5314) * 75;
+acc += Math.sin(5314) + Math.cos(5315) * 76;
+acc += Math.sin(5315) + Math.cos(5316) * 77;
+acc += Math.sin(5316) + Math.cos(5317) * 78;
+acc += Math.sin(5317) + Math.cos(5318) * 79;
+acc += Math.sin(5318) + Math.cos(5319) * 80;
+acc += Math.sin(5319) + Math.cos(5320) * 81;
+acc += Math.sin(5320) + Math.cos(5321) * 82;
+acc += Math.sin(5321) + Math.cos(5322) * 83;
+acc += Math.sin(5322) + Math.cos(5323) * 84;
+acc += Math.sin(5323) + Math.cos(5324) * 85;
+acc += Math.sin(5324) + Math.cos(5325) * 86;
+acc += Math.sin(5325) + Math.cos(5326) * 87;
+acc += Math.sin(5326) + Math.cos(5327) * 88;
+acc += Math.sin(5327) + Math.cos(5328) * 89;
+acc += Math.sin(5328) + Math.cos(5329) * 90;
+acc += Math.sin(5329) + Math.cos(5330) * 91;
+acc += Math.sin(5330) + Math.cos(5331) * 92;
+acc += Math.sin(5331) + Math.cos(5332) * 93;
+acc += Math.sin(5332) + Math.cos(5333) * 94;
+acc += Math.sin(5333) + Math.cos(5334) * 95;
+acc += Math.sin(5334) + Math.cos(5335) * 96;
+acc += Math.sin(5335) + Math.cos(5336) * 0;
+acc += Math.sin(5336) + Math.cos(5337) * 1;
+acc += Math.sin(5337) + Math.cos(5338) * 2;
+acc += Math.sin(5338) + Math.cos(5339) * 3;
+acc += Math.sin(5339) + Math.cos(5340) * 4;
+acc += Math.sin(5340) + Math.cos(5341) * 5;
+acc += Math.sin(5341) + Math.cos(5342) * 6;
+acc += Math.sin(5342) + Math.cos(5343) * 7;
+acc += Math.sin(5343) + Math.cos(5344) * 8;
+acc += Math.sin(5344) + Math.cos(5345) * 9;
+acc += Math.sin(5345) + Math.cos(5346) * 10;
+acc += Math.sin(5346) + Math.cos(5347) * 11;
+acc += Math.sin(5347) + Math.cos(5348) * 12;
+acc += Math.sin(5348) + Math.cos(5349) * 13;
+acc += Math.sin(5349) + Math.cos(5350) * 14;
+acc += Math.sin(5350) + Math.cos(5351) * 15;
+acc += Math.sin(5351) + Math.cos(5352) * 16;
+acc += Math.sin(5352) + Math.cos(5353) * 17;
+acc += Math.sin(5353) + Math.cos(5354) * 18;
+acc += Math.sin(5354) + Math.cos(5355) * 19;
+acc += Math.sin(5355) + Math.cos(5356) * 20;
+acc += Math.sin(5356) + Math.cos(5357) * 21;
+acc += Math.sin(5357) + Math.cos(5358) * 22;
+acc += Math.sin(5358) + Math.cos(5359) * 23;
+acc += Math.sin(5359) + Math.cos(5360) * 24;
+acc += Math.sin(5360) + Math.cos(5361) * 25;
+acc += Math.sin(5361) + Math.cos(5362) * 26;
+acc += Math.sin(5362) + Math.cos(5363) * 27;
+acc += Math.sin(5363) + Math.cos(5364) * 28;
+acc += Math.sin(5364) + Math.cos(5365) * 29;
+acc += Math.sin(5365) + Math.cos(5366) * 30;
+acc += Math.sin(5366) + Math.cos(5367) * 31;
+acc += Math.sin(5367) + Math.cos(5368) * 32;
+acc += Math.sin(5368) + Math.cos(5369) * 33;
+acc += Math.sin(5369) + Math.cos(5370) * 34;
+acc += Math.sin(5370) + Math.cos(5371) * 35;
+acc += Math.sin(5371) + Math.cos(5372) * 36;
+acc += Math.sin(5372) + Math.cos(5373) * 37;
+acc += Math.sin(5373) + Math.cos(5374) * 38;
+acc += Math.sin(5374) + Math.cos(5375) * 39;
+acc += Math.sin(5375) + Math.cos(5376) * 40;
+acc += Math.sin(5376) + Math.cos(5377) * 41;
+acc += Math.sin(5377) + Math.cos(5378) * 42;
+acc += Math.sin(5378) + Math.cos(5379) * 43;
+acc += Math.sin(5379) + Math.cos(5380) * 44;
+acc += Math.sin(5380) + Math.cos(5381) * 45;
+acc += Math.sin(5381) + Math.cos(5382) * 46;
+acc += Math.sin(5382) + Math.cos(5383) * 47;
+acc += Math.sin(5383) + Math.cos(5384) * 48;
+acc += Math.sin(5384) + Math.cos(5385) * 49;
+acc += Math.sin(5385) + Math.cos(5386) * 50;
+acc += Math.sin(5386) + Math.cos(5387) * 51;
+acc += Math.sin(5387) + Math.cos(5388) * 52;
+acc += Math.sin(5388) + Math.cos(5389) * 53;
+acc += Math.sin(5389) + Math.cos(5390) * 54;
+acc += Math.sin(5390) + Math.cos(5391) * 55;
+acc += Math.sin(5391) + Math.cos(5392) * 56;
+acc += Math.sin(5392) + Math.cos(5393) * 57;
+acc += Math.sin(5393) + Math.cos(5394) * 58;
+acc += Math.sin(5394) + Math.cos(5395) * 59;
+acc += Math.sin(5395) + Math.cos(5396) * 60;
+acc += Math.sin(5396) + Math.cos(5397) * 61;
+acc += Math.sin(5397) + Math.cos(5398) * 62;
+acc += Math.sin(5398) + Math.cos(5399) * 63;
+acc += Math.sin(5399) + Math.cos(5400) * 64;
+acc += Math.sin(5400) + Math.cos(5401) * 65;
+acc += Math.sin(5401) + Math.cos(5402) * 66;
+acc += Math.sin(5402) + Math.cos(5403) * 67;
+acc += Math.sin(5403) + Math.cos(5404) * 68;
+acc += Math.sin(5404) + Math.cos(5405) * 69;
+acc += Math.sin(5405) + Math.cos(5406) * 70;
+acc += Math.sin(5406) + Math.cos(5407) * 71;
+acc += Math.sin(5407) + Math.cos(5408) * 72;
+acc += Math.sin(5408) + Math.cos(5409) * 73;
+acc += Math.sin(5409) + Math.cos(5410) * 74;
+acc += Math.sin(5410) + Math.cos(5411) * 75;
+acc += Math.sin(5411) + Math.cos(5412) * 76;
+acc += Math.sin(5412) + Math.cos(5413) * 77;
+acc += Math.sin(5413) + Math.cos(5414) * 78;
+acc += Math.sin(5414) + Math.cos(5415) * 79;
+acc += Math.sin(5415) + Math.cos(5416) * 80;
+acc += Math.sin(5416) + Math.cos(5417) * 81;
+acc += Math.sin(5417) + Math.cos(5418) * 82;
+acc += Math.sin(5418) + Math.cos(5419) * 83;
+acc += Math.sin(5419) + Math.cos(5420) * 84;
+acc += Math.sin(5420) + Math.cos(5421) * 85;
+acc += Math.sin(5421) + Math.cos(5422) * 86;
+acc += Math.sin(5422) + Math.cos(5423) * 87;
+acc += Math.sin(5423) + Math.cos(5424) * 88;
+acc += Math.sin(5424) + Math.cos(5425) * 89;
+acc += Math.sin(5425) + Math.cos(5426) * 90;
+acc += Math.sin(5426) + Math.cos(5427) * 91;
+acc += Math.sin(5427) + Math.cos(5428) * 92;
+acc += Math.sin(5428) + Math.cos(5429) * 93;
+acc += Math.sin(5429) + Math.cos(5430) * 94;
+acc += Math.sin(5430) + Math.cos(5431) * 95;
+acc += Math.sin(5431) + Math.cos(5432) * 96;
+acc += Math.sin(5432) + Math.cos(5433) * 0;
+acc += Math.sin(5433) + Math.cos(5434) * 1;
+acc += Math.sin(5434) + Math.cos(5435) * 2;
+acc += Math.sin(5435) + Math.cos(5436) * 3;
+acc += Math.sin(5436) + Math.cos(5437) * 4;
+acc += Math.sin(5437) + Math.cos(5438) * 5;
+acc += Math.sin(5438) + Math.cos(5439) * 6;
+acc += Math.sin(5439) + Math.cos(5440) * 7;
+acc += Math.sin(5440) + Math.cos(5441) * 8;
+acc += Math.sin(5441) + Math.cos(5442) * 9;
+acc += Math.sin(5442) + Math.cos(5443) * 10;
+acc += Math.sin(5443) + Math.cos(5444) * 11;
+acc += Math.sin(5444) + Math.cos(5445) * 12;
+acc += Math.sin(5445) + Math.cos(5446) * 13;
+acc += Math.sin(5446) + Math.cos(5447) * 14;
+acc += Math.sin(5447) + Math.cos(5448) * 15;
+acc += Math.sin(5448) + Math.cos(5449) * 16;
+acc += Math.sin(5449) + Math.cos(5450) * 17;
+acc += Math.sin(5450) + Math.cos(5451) * 18;
+acc += Math.sin(5451) + Math.cos(5452) * 19;
+acc += Math.sin(5452) + Math.cos(5453) * 20;
+acc += Math.sin(5453) + Math.cos(5454) * 21;
+acc += Math.sin(5454) + Math.cos(5455) * 22;
+acc += Math.sin(5455) + Math.cos(5456) * 23;
+acc += Math.sin(5456) + Math.cos(5457) * 24;
+acc += Math.sin(5457) + Math.cos(5458) * 25;
+acc += Math.sin(5458) + Math.cos(5459) * 26;
+acc += Math.sin(5459) + Math.cos(5460) * 27;
+acc += Math.sin(5460) + Math.cos(5461) * 28;
+acc += Math.sin(5461) + Math.cos(5462) * 29;
+acc += Math.sin(5462) + Math.cos(5463) * 30;
+acc += Math.sin(5463) + Math.cos(5464) * 31;
+acc += Math.sin(5464) + Math.cos(5465) * 32;
+acc += Math.sin(5465) + Math.cos(5466) * 33;
+acc += Math.sin(5466) + Math.cos(5467) * 34;
+acc += Math.sin(5467) + Math.cos(5468) * 35;
+acc += Math.sin(5468) + Math.cos(5469) * 36;
+acc += Math.sin(5469) + Math.cos(5470) * 37;
+acc += Math.sin(5470) + Math.cos(5471) * 38;
+acc += Math.sin(5471) + Math.cos(5472) * 39;
+acc += Math.sin(5472) + Math.cos(5473) * 40;
+acc += Math.sin(5473) + Math.cos(5474) * 41;
+acc += Math.sin(5474) + Math.cos(5475) * 42;
+acc += Math.sin(5475) + Math.cos(5476) * 43;
+acc += Math.sin(5476) + Math.cos(5477) * 44;
+acc += Math.sin(5477) + Math.cos(5478) * 45;
+acc += Math.sin(5478) + Math.cos(5479) * 46;
+acc += Math.sin(5479) + Math.cos(5480) * 47;
+acc += Math.sin(5480) + Math.cos(5481) * 48;
+acc += Math.sin(5481) + Math.cos(5482) * 49;
+acc += Math.sin(5482) + Math.cos(5483) * 50;
+acc += Math.sin(5483) + Math.cos(5484) * 51;
+acc += Math.sin(5484) + Math.cos(5485) * 52;
+acc += Math.sin(5485) + Math.cos(5486) * 53;
+acc += Math.sin(5486) + Math.cos(5487) * 54;
+acc += Math.sin(5487) + Math.cos(5488) * 55;
+acc += Math.sin(5488) + Math.cos(5489) * 56;
+acc += Math.sin(5489) + Math.cos(5490) * 57;
+acc += Math.sin(5490) + Math.cos(5491) * 58;
+acc += Math.sin(5491) + Math.cos(5492) * 59;
+acc += Math.sin(5492) + Math.cos(5493) * 60;
+acc += Math.sin(5493) + Math.cos(5494) * 61;
+acc += Math.sin(5494) + Math.cos(5495) * 62;
+acc += Math.sin(5495) + Math.cos(5496) * 63;
+acc += Math.sin(5496) + Math.cos(5497) * 64;
+acc += Math.sin(5497) + Math.cos(5498) * 65;
+acc += Math.sin(5498) + Math.cos(5499) * 66;
+acc += Math.sin(5499) + Math.cos(5500) * 67;
+acc += Math.sin(5500) + Math.cos(5501) * 68;
+acc += Math.sin(5501) + Math.cos(5502) * 69;
+acc += Math.sin(5502) + Math.cos(5503) * 70;
+acc += Math.sin(5503) + Math.cos(5504) * 71;
+acc += Math.sin(5504) + Math.cos(5505) * 72;
+acc += Math.sin(5505) + Math.cos(5506) * 73;
+acc += Math.sin(5506) + Math.cos(5507) * 74;
+acc += Math.sin(5507) + Math.cos(5508) * 75;
+acc += Math.sin(5508) + Math.cos(5509) * 76;
+acc += Math.sin(5509) + Math.cos(5510) * 77;
+acc += Math.sin(5510) + Math.cos(5511) * 78;
+acc += Math.sin(5511) + Math.cos(5512) * 79;
+acc += Math.sin(5512) + Math.cos(5513) * 80;
+acc += Math.sin(5513) + Math.cos(5514) * 81;
+acc += Math.sin(5514) + Math.cos(5515) * 82;
+acc += Math.sin(5515) + Math.cos(5516) * 83;
+acc += Math.sin(5516) + Math.cos(5517) * 84;
+acc += Math.sin(5517) + Math.cos(5518) * 85;
+acc += Math.sin(5518) + Math.cos(5519) * 86;
+acc += Math.sin(5519) + Math.cos(5520) * 87;
+acc += Math.sin(5520) + Math.cos(5521) * 88;
+acc += Math.sin(5521) + Math.cos(5522) * 89;
+acc += Math.sin(5522) + Math.cos(5523) * 90;
+acc += Math.sin(5523) + Math.cos(5524) * 91;
+acc += Math.sin(5524) + Math.cos(5525) * 92;
+acc += Math.sin(5525) + Math.cos(5526) * 93;
+acc += Math.sin(5526) + Math.cos(5527) * 94;
+acc += Math.sin(5527) + Math.cos(5528) * 95;
+acc += Math.sin(5528) + Math.cos(5529) * 96;
+acc += Math.sin(5529) + Math.cos(5530) * 0;
+acc += Math.sin(5530) + Math.cos(5531) * 1;
+acc += Math.sin(5531) + Math.cos(5532) * 2;
+acc += Math.sin(5532) + Math.cos(5533) * 3;
+acc += Math.sin(5533) + Math.cos(5534) * 4;
+acc += Math.sin(5534) + Math.cos(5535) * 5;
+acc += Math.sin(5535) + Math.cos(5536) * 6;
+acc += Math.sin(5536) + Math.cos(5537) * 7;
+acc += Math.sin(5537) + Math.cos(5538) * 8;
+acc += Math.sin(5538) + Math.cos(5539) * 9;
+acc += Math.sin(5539) + Math.cos(5540) * 10;
+acc += Math.sin(5540) + Math.cos(5541) * 11;
+acc += Math.sin(5541) + Math.cos(5542) * 12;
+acc += Math.sin(5542) + Math.cos(5543) * 13;
+acc += Math.sin(5543) + Math.cos(5544) * 14;
+acc += Math.sin(5544) + Math.cos(5545) * 15;
+acc += Math.sin(5545) + Math.cos(5546) * 16;
+acc += Math.sin(5546) + Math.cos(5547) * 17;
+acc += Math.sin(5547) + Math.cos(5548) * 18;
+acc += Math.sin(5548) + Math.cos(5549) * 19;
+acc += Math.sin(5549) + Math.cos(5550) * 20;
+acc += Math.sin(5550) + Math.cos(5551) * 21;
+acc += Math.sin(5551) + Math.cos(5552) * 22;
+acc += Math.sin(5552) + Math.cos(5553) * 23;
+acc += Math.sin(5553) + Math.cos(5554) * 24;
+acc += Math.sin(5554) + Math.cos(5555) * 25;
+acc += Math.sin(5555) + Math.cos(5556) * 26;
+acc += Math.sin(5556) + Math.cos(5557) * 27;
+acc += Math.sin(5557) + Math.cos(5558) * 28;
+acc += Math.sin(5558) + Math.cos(5559) * 29;
+acc += Math.sin(5559) + Math.cos(5560) * 30;
+acc += Math.sin(5560) + Math.cos(5561) * 31;
+acc += Math.sin(5561) + Math.cos(5562) * 32;
+acc += Math.sin(5562) + Math.cos(5563) * 33;
+acc += Math.sin(5563) + Math.cos(5564) * 34;
+acc += Math.sin(5564) + Math.cos(5565) * 35;
+acc += Math.sin(5565) + Math.cos(5566) * 36;
+acc += Math.sin(5566) + Math.cos(5567) * 37;
+acc += Math.sin(5567) + Math.cos(5568) * 38;
+acc += Math.sin(5568) + Math.cos(5569) * 39;
+acc += Math.sin(5569) + Math.cos(5570) * 40;
+acc += Math.sin(5570) + Math.cos(5571) * 41;
+acc += Math.sin(5571) + Math.cos(5572) * 42;
+acc += Math.sin(5572) + Math.cos(5573) * 43;
+acc += Math.sin(5573) + Math.cos(5574) * 44;
+acc += Math.sin(5574) + Math.cos(5575) * 45;
+acc += Math.sin(5575) + Math.cos(5576) * 46;
+acc += Math.sin(5576) + Math.cos(5577) * 47;
+acc += Math.sin(5577) + Math.cos(5578) * 48;
+acc += Math.sin(5578) + Math.cos(5579) * 49;
+acc += Math.sin(5579) + Math.cos(5580) * 50;
+acc += Math.sin(5580) + Math.cos(5581) * 51;
+acc += Math.sin(5581) + Math.cos(5582) * 52;
+acc += Math.sin(5582) + Math.cos(5583) * 53;
+acc += Math.sin(5583) + Math.cos(5584) * 54;
+acc += Math.sin(5584) + Math.cos(5585) * 55;
+acc += Math.sin(5585) + Math.cos(5586) * 56;
+acc += Math.sin(5586) + Math.cos(5587) * 57;
+acc += Math.sin(5587) + Math.cos(5588) * 58;
+acc += Math.sin(5588) + Math.cos(5589) * 59;
+acc += Math.sin(5589) + Math.cos(5590) * 60;
+acc += Math.sin(5590) + Math.cos(5591) * 61;
+acc += Math.sin(5591) + Math.cos(5592) * 62;
+acc += Math.sin(5592) + Math.cos(5593) * 63;
+acc += Math.sin(5593) + Math.cos(5594) * 64;
+acc += Math.sin(5594) + Math.cos(5595) * 65;
+acc += Math.sin(5595) + Math.cos(5596) * 66;
+acc += Math.sin(5596) + Math.cos(5597) * 67;
+acc += Math.sin(5597) + Math.cos(5598) * 68;
+acc += Math.sin(5598) + Math.cos(5599) * 69;
+acc += Math.sin(5599) + Math.cos(5600) * 70;
+acc += Math.sin(5600) + Math.cos(5601) * 71;
+acc += Math.sin(5601) + Math.cos(5602) * 72;
+acc += Math.sin(5602) + Math.cos(5603) * 73;
+acc += Math.sin(5603) + Math.cos(5604) * 74;
+acc += Math.sin(5604) + Math.cos(5605) * 75;
+acc += Math.sin(5605) + Math.cos(5606) * 76;
+acc += Math.sin(5606) + Math.cos(5607) * 77;
+acc += Math.sin(5607) + Math.cos(5608) * 78;
+acc += Math.sin(5608) + Math.cos(5609) * 79;
+acc += Math.sin(5609) + Math.cos(5610) * 80;
+acc += Math.sin(5610) + Math.cos(5611) * 81;
+acc += Math.sin(5611) + Math.cos(5612) * 82;
+acc += Math.sin(5612) + Math.cos(5613) * 83;
+acc += Math.sin(5613) + Math.cos(5614) * 84;
+acc += Math.sin(5614) + Math.cos(5615) * 85;
+acc += Math.sin(5615) + Math.cos(5616) * 86;
+acc += Math.sin(5616) + Math.cos(5617) * 87;
+acc += Math.sin(5617) + Math.cos(5618) * 88;
+acc += Math.sin(5618) + Math.cos(5619) * 89;
+acc += Math.sin(5619) + Math.cos(5620) * 90;
+acc += Math.sin(5620) + Math.cos(5621) * 91;
+acc += Math.sin(5621) + Math.cos(5622) * 92;
+acc += Math.sin(5622) + Math.cos(5623) * 93;
+acc += Math.sin(5623) + Math.cos(5624) * 94;
+acc += Math.sin(5624) + Math.cos(5625) * 95;
+acc += Math.sin(5625) + Math.cos(5626) * 96;
+acc += Math.sin(5626) + Math.cos(5627) * 0;
+acc += Math.sin(5627) + Math.cos(5628) * 1;
+acc += Math.sin(5628) + Math.cos(5629) * 2;
+acc += Math.sin(5629) + Math.cos(5630) * 3;
+acc += Math.sin(5630) + Math.cos(5631) * 4;
+acc += Math.sin(5631) + Math.cos(5632) * 5;
+acc += Math.sin(5632) + Math.cos(5633) * 6;
+acc += Math.sin(5633) + Math.cos(5634) * 7;
+acc += Math.sin(5634) + Math.cos(5635) * 8;
+acc += Math.sin(5635) + Math.cos(5636) * 9;
+acc += Math.sin(5636) + Math.cos(5637) * 10;
+acc += Math.sin(5637) + Math.cos(5638) * 11;
+acc += Math.sin(5638) + Math.cos(5639) * 12;
+acc += Math.sin(5639) + Math.cos(5640) * 13;
+acc += Math.sin(5640) + Math.cos(5641) * 14;
+acc += Math.sin(5641) + Math.cos(5642) * 15;
+acc += Math.sin(5642) + Math.cos(5643) * 16;
+acc += Math.sin(5643) + Math.cos(5644) * 17;
+acc += Math.sin(5644) + Math.cos(5645) * 18;
+acc += Math.sin(5645) + Math.cos(5646) * 19;
+acc += Math.sin(5646) + Math.cos(5647) * 20;
+acc += Math.sin(5647) + Math.cos(5648) * 21;
+acc += Math.sin(5648) + Math.cos(5649) * 22;
+acc += Math.sin(5649) + Math.cos(5650) * 23;
+acc += Math.sin(5650) + Math.cos(5651) * 24;
+acc += Math.sin(5651) + Math.cos(5652) * 25;
+acc += Math.sin(5652) + Math.cos(5653) * 26;
+acc += Math.sin(5653) + Math.cos(5654) * 27;
+acc += Math.sin(5654) + Math.cos(5655) * 28;
+acc += Math.sin(5655) + Math.cos(5656) * 29;
+acc += Math.sin(5656) + Math.cos(5657) * 30;
+acc += Math.sin(5657) + Math.cos(5658) * 31;
+acc += Math.sin(5658) + Math.cos(5659) * 32;
+acc += Math.sin(5659) + Math.cos(5660) * 33;
+acc += Math.sin(5660) + Math.cos(5661) * 34;
+acc += Math.sin(5661) + Math.cos(5662) * 35;
+acc += Math.sin(5662) + Math.cos(5663) * 36;
+acc += Math.sin(5663) + Math.cos(5664) * 37;
+acc += Math.sin(5664) + Math.cos(5665) * 38;
+acc += Math.sin(5665) + Math.cos(5666) * 39;
+acc += Math.sin(5666) + Math.cos(5667) * 40;
+acc += Math.sin(5667) + Math.cos(5668) * 41;
+acc += Math.sin(5668) + Math.cos(5669) * 42;
+acc += Math.sin(5669) + Math.cos(5670) * 43;
+acc += Math.sin(5670) + Math.cos(5671) * 44;
+acc += Math.sin(5671) + Math.cos(5672) * 45;
+acc += Math.sin(5672) + Math.cos(5673) * 46;
+acc += Math.sin(5673) + Math.cos(5674) * 47;
+acc += Math.sin(5674) + Math.cos(5675) * 48;
+acc += Math.sin(5675) + Math.cos(5676) * 49;
+acc += Math.sin(5676) + Math.cos(5677) * 50;
+acc += Math.sin(5677) + Math.cos(5678) * 51;
+acc += Math.sin(5678) + Math.cos(5679) * 52;
+acc += Math.sin(5679) + Math.cos(5680) * 53;
+acc += Math.sin(5680) + Math.cos(5681) * 54;
+acc += Math.sin(5681) + Math.cos(5682) * 55;
+acc += Math.sin(5682) + Math.cos(5683) * 56;
+acc += Math.sin(5683) + Math.cos(5684) * 57;
+acc += Math.sin(5684) + Math.cos(5685) * 58;
+acc += Math.sin(5685) + Math.cos(5686) * 59;
+acc += Math.sin(5686) + Math.cos(5687) * 60;
+acc += Math.sin(5687) + Math.cos(5688) * 61;
+acc += Math.sin(5688) + Math.cos(5689) * 62;
+acc += Math.sin(5689) + Math.cos(5690) * 63;
+acc += Math.sin(5690) + Math.cos(5691) * 64;
+acc += Math.sin(5691) + Math.cos(5692) * 65;
+acc += Math.sin(5692) + Math.cos(5693) * 66;
+acc += Math.sin(5693) + Math.cos(5694) * 67;
+acc += Math.sin(5694) + Math.cos(5695) * 68;
+acc += Math.sin(5695) + Math.cos(5696) * 69;
+acc += Math.sin(5696) + Math.cos(5697) * 70;
+acc += Math.sin(5697) + Math.cos(5698) * 71;
+acc += Math.sin(5698) + Math.cos(5699) * 72;
+acc += Math.sin(5699) + Math.cos(5700) * 73;
+acc += Math.sin(5700) + Math.cos(5701) * 74;
+acc += Math.sin(5701) + Math.cos(5702) * 75;
+acc += Math.sin(5702) + Math.cos(5703) * 76;
+acc += Math.sin(5703) + Math.cos(5704) * 77;
+acc += Math.sin(5704) + Math.cos(5705) * 78;
+acc += Math.sin(5705) + Math.cos(5706) * 79;
+acc += Math.sin(5706) + Math.cos(5707) * 80;
+acc += Math.sin(5707) + Math.cos(5708) * 81;
+acc += Math.sin(5708) + Math.cos(5709) * 82;
+acc += Math.sin(5709) + Math.cos(5710) * 83;
+acc += Math.sin(5710) + Math.cos(5711) * 84;
+acc += Math.sin(5711) + Math.cos(5712) * 85;
+acc += Math.sin(5712) + Math.cos(5713) * 86;
+acc += Math.sin(5713) + Math.cos(5714) * 87;
+acc += Math.sin(5714) + Math.cos(5715) * 88;
+acc += Math.sin(5715) + Math.cos(5716) * 89;
+acc += Math.sin(5716) + Math.cos(5717) * 90;
+acc += Math.sin(5717) + Math.cos(5718) * 91;
+acc += Math.sin(5718) + Math.cos(5719) * 92;
+acc += Math.sin(5719) + Math.cos(5720) * 93;
+acc += Math.sin(5720) + Math.cos(5721) * 94;
+acc += Math.sin(5721) + Math.cos(5722) * 95;
+acc += Math.sin(5722) + Math.cos(5723) * 96;
+acc += Math.sin(5723) + Math.cos(5724) * 0;
+acc += Math.sin(5724) + Math.cos(5725) * 1;
+acc += Math.sin(5725) + Math.cos(5726) * 2;
+acc += Math.sin(5726) + Math.cos(5727) * 3;
+acc += Math.sin(5727) + Math.cos(5728) * 4;
+acc += Math.sin(5728) + Math.cos(5729) * 5;
+acc += Math.sin(5729) + Math.cos(5730) * 6;
+acc += Math.sin(5730) + Math.cos(5731) * 7;
+acc += Math.sin(5731) + Math.cos(5732) * 8;
+acc += Math.sin(5732) + Math.cos(5733) * 9;
+acc += Math.sin(5733) + Math.cos(5734) * 10;
+acc += Math.sin(5734) + Math.cos(5735) * 11;
+acc += Math.sin(5735) + Math.cos(5736) * 12;
+acc += Math.sin(5736) + Math.cos(5737) * 13;
+acc += Math.sin(5737) + Math.cos(5738) * 14;
+acc += Math.sin(5738) + Math.cos(5739) * 15;
+acc += Math.sin(5739) + Math.cos(5740) * 16;
+acc += Math.sin(5740) + Math.cos(5741) * 17;
+acc += Math.sin(5741) + Math.cos(5742) * 18;
+acc += Math.sin(5742) + Math.cos(5743) * 19;
+acc += Math.sin(5743) + Math.cos(5744) * 20;
+acc += Math.sin(5744) + Math.cos(5745) * 21;
+acc += Math.sin(5745) + Math.cos(5746) * 22;
+acc += Math.sin(5746) + Math.cos(5747) * 23;
+acc += Math.sin(5747) + Math.cos(5748) * 24;
+acc += Math.sin(5748) + Math.cos(5749) * 25;
+acc += Math.sin(5749) + Math.cos(5750) * 26;
+acc += Math.sin(5750) + Math.cos(5751) * 27;
+acc += Math.sin(5751) + Math.cos(5752) * 28;
+acc += Math.sin(5752) + Math.cos(5753) * 29;
+acc += Math.sin(5753) + Math.cos(5754) * 30;
+acc += Math.sin(5754) + Math.cos(5755) * 31;
+acc += Math.sin(5755) + Math.cos(5756) * 32;
+acc += Math.sin(5756) + Math.cos(5757) * 33;
+acc += Math.sin(5757) + Math.cos(5758) * 34;
+acc += Math.sin(5758) + Math.cos(5759) * 35;
+acc += Math.sin(5759) + Math.cos(5760) * 36;
+acc += Math.sin(5760) + Math.cos(5761) * 37;
+acc += Math.sin(5761) + Math.cos(5762) * 38;
+acc += Math.sin(5762) + Math.cos(5763) * 39;
+acc += Math.sin(5763) + Math.cos(5764) * 40;
+acc += Math.sin(5764) + Math.cos(5765) * 41;
+acc += Math.sin(5765) + Math.cos(5766) * 42;
+acc += Math.sin(5766) + Math.cos(5767) * 43;
+acc += Math.sin(5767) + Math.cos(5768) * 44;
+acc += Math.sin(5768) + Math.cos(5769) * 45;
+acc += Math.sin(5769) + Math.cos(5770) * 46;
+acc += Math.sin(5770) + Math.cos(5771) * 47;
+acc += Math.sin(5771) + Math.cos(5772) * 48;
+acc += Math.sin(5772) + Math.cos(5773) * 49;
+acc += Math.sin(5773) + Math.cos(5774) * 50;
+acc += Math.sin(5774) + Math.cos(5775) * 51;
+acc += Math.sin(5775) + Math.cos(5776) * 52;
+acc += Math.sin(5776) + Math.cos(5777) * 53;
+acc += Math.sin(5777) + Math.cos(5778) * 54;
+acc += Math.sin(5778) + Math.cos(5779) * 55;
+acc += Math.sin(5779) + Math.cos(5780) * 56;
+acc += Math.sin(5780) + Math.cos(5781) * 57;
+acc += Math.sin(5781) + Math.cos(5782) * 58;
+acc += Math.sin(5782) + Math.cos(5783) * 59;
+acc += Math.sin(5783) + Math.cos(5784) * 60;
+acc += Math.sin(5784) + Math.cos(5785) * 61;
+acc += Math.sin(5785) + Math.cos(5786) * 62;
+acc += Math.sin(5786) + Math.cos(5787) * 63;
+acc += Math.sin(5787) + Math.cos(5788) * 64;
+acc += Math.sin(5788) + Math.cos(5789) * 65;
+acc += Math.sin(5789) + Math.cos(5790) * 66;
+acc += Math.sin(5790) + Math.cos(5791) * 67;
+acc += Math.sin(5791) + Math.cos(5792) * 68;
+acc += Math.sin(5792) + Math.cos(5793) * 69;
+acc += Math.sin(5793) + Math.cos(5794) * 70;
+acc += Math.sin(5794) + Math.cos(5795) * 71;
+acc += Math.sin(5795) + Math.cos(5796) * 72;
+acc += Math.sin(5796) + Math.cos(5797) * 73;
+acc += Math.sin(5797) + Math.cos(5798) * 74;
+acc += Math.sin(5798) + Math.cos(5799) * 75;
+acc += Math.sin(5799) + Math.cos(5800) * 76;
+acc += Math.sin(5800) + Math.cos(5801) * 77;
+acc += Math.sin(5801) + Math.cos(5802) * 78;
+acc += Math.sin(5802) + Math.cos(5803) * 79;
+acc += Math.sin(5803) + Math.cos(5804) * 80;
+acc += Math.sin(5804) + Math.cos(5805) * 81;
+acc += Math.sin(5805) + Math.cos(5806) * 82;
+acc += Math.sin(5806) + Math.cos(5807) * 83;
+acc += Math.sin(5807) + Math.cos(5808) * 84;
+acc += Math.sin(5808) + Math.cos(5809) * 85;
+acc += Math.sin(5809) + Math.cos(5810) * 86;
+acc += Math.sin(5810) + Math.cos(5811) * 87;
+acc += Math.sin(5811) + Math.cos(5812) * 88;
+acc += Math.sin(5812) + Math.cos(5813) * 89;
+acc += Math.sin(5813) + Math.cos(5814) * 90;
+acc += Math.sin(5814) + Math.cos(5815) * 91;
+acc += Math.sin(5815) + Math.cos(5816) * 92;
+acc += Math.sin(5816) + Math.cos(5817) * 93;
+acc += Math.sin(5817) + Math.cos(5818) * 94;
+acc += Math.sin(5818) + Math.cos(5819) * 95;
+acc += Math.sin(5819) + Math.cos(5820) * 96;
+acc += Math.sin(5820) + Math.cos(5821) * 0;
+acc += Math.sin(5821) + Math.cos(5822) * 1;
+acc += Math.sin(5822) + Math.cos(5823) * 2;
+acc += Math.sin(5823) + Math.cos(5824) * 3;
+acc += Math.sin(5824) + Math.cos(5825) * 4;
+acc += Math.sin(5825) + Math.cos(5826) * 5;
+acc += Math.sin(5826) + Math.cos(5827) * 6;
+acc += Math.sin(5827) + Math.cos(5828) * 7;
+acc += Math.sin(5828) + Math.cos(5829) * 8;
+acc += Math.sin(5829) + Math.cos(5830) * 9;
+acc += Math.sin(5830) + Math.cos(5831) * 10;
+acc += Math.sin(5831) + Math.cos(5832) * 11;
+acc += Math.sin(5832) + Math.cos(5833) * 12;
+acc += Math.sin(5833) + Math.cos(5834) * 13;
+acc += Math.sin(5834) + Math.cos(5835) * 14;
+acc += Math.sin(5835) + Math.cos(5836) * 15;
+acc += Math.sin(5836) + Math.cos(5837) * 16;
+acc += Math.sin(5837) + Math.cos(5838) * 17;
+acc += Math.sin(5838) + Math.cos(5839) * 18;
+acc += Math.sin(5839) + Math.cos(5840) * 19;
+acc += Math.sin(5840) + Math.cos(5841) * 20;
+acc += Math.sin(5841) + Math.cos(5842) * 21;
+acc += Math.sin(5842) + Math.cos(5843) * 22;
+acc += Math.sin(5843) + Math.cos(5844) * 23;
+acc += Math.sin(5844) + Math.cos(5845) * 24;
+acc += Math.sin(5845) + Math.cos(5846) * 25;
+acc += Math.sin(5846) + Math.cos(5847) * 26;
+acc += Math.sin(5847) + Math.cos(5848) * 27;
+acc += Math.sin(5848) + Math.cos(5849) * 28;
+acc += Math.sin(5849) + Math.cos(5850) * 29;
+acc += Math.sin(5850) + Math.cos(5851) * 30;
+acc += Math.sin(5851) + Math.cos(5852) * 31;
+acc += Math.sin(5852) + Math.cos(5853) * 32;
+acc += Math.sin(5853) + Math.cos(5854) * 33;
+acc += Math.sin(5854) + Math.cos(5855) * 34;
+acc += Math.sin(5855) + Math.cos(5856) * 35;
+acc += Math.sin(5856) + Math.cos(5857) * 36;
+acc += Math.sin(5857) + Math.cos(5858) * 37;
+acc += Math.sin(5858) + Math.cos(5859) * 38;
+acc += Math.sin(5859) + Math.cos(5860) * 39;
+acc += Math.sin(5860) + Math.cos(5861) * 40;
+acc += Math.sin(5861) + Math.cos(5862) * 41;
+acc += Math.sin(5862) + Math.cos(5863) * 42;
+acc += Math.sin(5863) + Math.cos(5864) * 43;
+acc += Math.sin(5864) + Math.cos(5865) * 44;
+acc += Math.sin(5865) + Math.cos(5866) * 45;
+acc += Math.sin(5866) + Math.cos(5867) * 46;
+acc += Math.sin(5867) + Math.cos(5868) * 47;
+acc += Math.sin(5868) + Math.cos(5869) * 48;
+acc += Math.sin(5869) + Math.cos(5870) * 49;
+acc += Math.sin(5870) + Math.cos(5871) * 50;
+acc += Math.sin(5871) + Math.cos(5872) * 51;
+acc += Math.sin(5872) + Math.cos(5873) * 52;
+acc += Math.sin(5873) + Math.cos(5874) * 53;
+acc += Math.sin(5874) + Math.cos(5875) * 54;
+acc += Math.sin(5875) + Math.cos(5876) * 55;
+acc += Math.sin(5876) + Math.cos(5877) * 56;
+acc += Math.sin(5877) + Math.cos(5878) * 57;
+acc += Math.sin(5878) + Math.cos(5879) * 58;
+acc += Math.sin(5879) + Math.cos(5880) * 59;
+acc += Math.sin(5880) + Math.cos(5881) * 60;
+acc += Math.sin(5881) + Math.cos(5882) * 61;
+acc += Math.sin(5882) + Math.cos(5883) * 62;
+acc += Math.sin(5883) + Math.cos(5884) * 63;
+acc += Math.sin(5884) + Math.cos(5885) * 64;
+acc += Math.sin(5885) + Math.cos(5886) * 65;
+acc += Math.sin(5886) + Math.cos(5887) * 66;
+acc += Math.sin(5887) + Math.cos(5888) * 67;
+acc += Math.sin(5888) + Math.cos(5889) * 68;
+acc += Math.sin(5889) + Math.cos(5890) * 69;
+acc += Math.sin(5890) + Math.cos(5891) * 70;
+acc += Math.sin(5891) + Math.cos(5892) * 71;
+acc += Math.sin(5892) + Math.cos(5893) * 72;
+acc += Math.sin(5893) + Math.cos(5894) * 73;
+acc += Math.sin(5894) + Math.cos(5895) * 74;
+acc += Math.sin(5895) + Math.cos(5896) * 75;
+acc += Math.sin(5896) + Math.cos(5897) * 76;
+acc += Math.sin(5897) + Math.cos(5898) * 77;
+acc += Math.sin(5898) + Math.cos(5899) * 78;
+acc += Math.sin(5899) + Math.cos(5900) * 79;
+acc += Math.sin(5900) + Math.cos(5901) * 80;
+acc += Math.sin(5901) + Math.cos(5902) * 81;
+acc += Math.sin(5902) + Math.cos(5903) * 82;
+acc += Math.sin(5903) + Math.cos(5904) * 83;
+acc += Math.sin(5904) + Math.cos(5905) * 84;
+acc += Math.sin(5905) + Math.cos(5906) * 85;
+acc += Math.sin(5906) + Math.cos(5907) * 86;
+acc += Math.sin(5907) + Math.cos(5908) * 87;
+acc += Math.sin(5908) + Math.cos(5909) * 88;
+acc += Math.sin(5909) + Math.cos(5910) * 89;
+acc += Math.sin(5910) + Math.cos(5911) * 90;
+acc += Math.sin(5911) + Math.cos(5912) * 91;
+acc += Math.sin(5912) + Math.cos(5913) * 92;
+acc += Math.sin(5913) + Math.cos(5914) * 93;
+acc += Math.sin(5914) + Math.cos(5915) * 94;
+acc += Math.sin(5915) + Math.cos(5916) * 95;
+acc += Math.sin(5916) + Math.cos(5917) * 96;
+acc += Math.sin(5917) + Math.cos(5918) * 0;
+acc += Math.sin(5918) + Math.cos(5919) * 1;
+acc += Math.sin(5919) + Math.cos(5920) * 2;
+acc += Math.sin(5920) + Math.cos(5921) * 3;
+acc += Math.sin(5921) + Math.cos(5922) * 4;
+acc += Math.sin(5922) + Math.cos(5923) * 5;
+acc += Math.sin(5923) + Math.cos(5924) * 6;
+acc += Math.sin(5924) + Math.cos(5925) * 7;
+acc += Math.sin(5925) + Math.cos(5926) * 8;
+acc += Math.sin(5926) + Math.cos(5927) * 9;
+acc += Math.sin(5927) + Math.cos(5928) * 10;
+acc += Math.sin(5928) + Math.cos(5929) * 11;
+acc += Math.sin(5929) + Math.cos(5930) * 12;
+acc += Math.sin(5930) + Math.cos(5931) * 13;
+acc += Math.sin(5931) + Math.cos(5932) * 14;
+acc += Math.sin(5932) + Math.cos(5933) * 15;
+acc += Math.sin(5933) + Math.cos(5934) * 16;
+acc += Math.sin(5934) + Math.cos(5935) * 17;
+acc += Math.sin(5935) + Math.cos(5936) * 18;
+acc += Math.sin(5936) + Math.cos(5937) * 19;
+acc += Math.sin(5937) + Math.cos(5938) * 20;
+acc += Math.sin(5938) + Math.cos(5939) * 21;
+acc += Math.sin(5939) + Math.cos(5940) * 22;
+acc += Math.sin(5940) + Math.cos(5941) * 23;
+acc += Math.sin(5941) + Math.cos(5942) * 24;
+acc += Math.sin(5942) + Math.cos(5943) * 25;
+acc += Math.sin(5943) + Math.cos(5944) * 26;
+acc += Math.sin(5944) + Math.cos(5945) * 27;
+acc += Math.sin(5945) + Math.cos(5946) * 28;
+acc += Math.sin(5946) + Math.cos(5947) * 29;
+acc += Math.sin(5947) + Math.cos(5948) * 30;
+acc += Math.sin(5948) + Math.cos(5949) * 31;
+acc += Math.sin(5949) + Math.cos(5950) * 32;
+acc += Math.sin(5950) + Math.cos(5951) * 33;
+acc += Math.sin(5951) + Math.cos(5952) * 34;
+acc += Math.sin(5952) + Math.cos(5953) * 35;
+acc += Math.sin(5953) + Math.cos(5954) * 36;
+acc += Math.sin(5954) + Math.cos(5955) * 37;
+acc += Math.sin(5955) + Math.cos(5956) * 38;
+acc += Math.sin(5956) + Math.cos(5957) * 39;
+acc += Math.sin(5957) + Math.cos(5958) * 40;
+acc += Math.sin(5958) + Math.cos(5959) * 41;
+acc += Math.sin(5959) + Math.cos(5960) * 42;
+acc += Math.sin(5960) + Math.cos(5961) * 43;
+acc += Math.sin(5961) + Math.cos(5962) * 44;
+acc += Math.sin(5962) + Math.cos(5963) * 45;
+acc += Math.sin(5963) + Math.cos(5964) * 46;
+acc += Math.sin(5964) + Math.cos(5965) * 47;
+acc += Math.sin(5965) + Math.cos(5966) * 48;
+acc += Math.sin(5966) + Math.cos(5967) * 49;
+acc += Math.sin(5967) + Math.cos(5968) * 50;
+acc += Math.sin(5968) + Math.cos(5969) * 51;
+acc += Math.sin(5969) + Math.cos(5970) * 52;
+acc += Math.sin(5970) + Math.cos(5971) * 53;
+acc += Math.sin(5971) + Math.cos(5972) * 54;
+acc += Math.sin(5972) + Math.cos(5973) * 55;
+acc += Math.sin(5973) + Math.cos(5974) * 56;
+acc += Math.sin(5974) + Math.cos(5975) * 57;
+acc += Math.sin(5975) + Math.cos(5976) * 58;
+acc += Math.sin(5976) + Math.cos(5977) * 59;
+acc += Math.sin(5977) + Math.cos(5978) * 60;
+acc += Math.sin(5978) + Math.cos(5979) * 61;
+acc += Math.sin(5979) + Math.cos(5980) * 62;
+acc += Math.sin(5980) + Math.cos(5981) * 63;
+acc += Math.sin(5981) + Math.cos(5982) * 64;
+acc += Math.sin(5982) + Math.cos(5983) * 65;
+acc += Math.sin(5983) + Math.cos(5984) * 66;
+acc += Math.sin(5984) + Math.cos(5985) * 67;
+acc += Math.sin(5985) + Math.cos(5986) * 68;
+acc += Math.sin(5986) + Math.cos(5987) * 69;
+acc += Math.sin(5987) + Math.cos(5988) * 70;
+acc += Math.sin(5988) + Math.cos(5989) * 71;
+acc += Math.sin(5989) + Math.cos(5990) * 72;
+acc += Math.sin(5990) + Math.cos(5991) * 73;
+acc += Math.sin(5991) + Math.cos(5992) * 74;
+acc += Math.sin(5992) + Math.cos(5993) * 75;
+acc += Math.sin(5993) + Math.cos(5994) * 76;
+acc += Math.sin(5994) + Math.cos(5995) * 77;
+acc += Math.sin(5995) + Math.cos(5996) * 78;
+acc += Math.sin(5996) + Math.cos(5997) * 79;
+acc += Math.sin(5997) + Math.cos(5998) * 80;
+acc += Math.sin(5998) + Math.cos(5999) * 81;
+acc += Math.sin(5999) + Math.cos(6000) * 82;
+acc += Math.sin(6000) + Math.cos(6001) * 83;
+acc += Math.sin(6001) + Math.cos(6002) * 84;
+acc += Math.sin(6002) + Math.cos(6003) * 85;
+acc += Math.sin(6003) + Math.cos(6004) * 86;
+acc += Math.sin(6004) + Math.cos(6005) * 87;
+acc += Math.sin(6005) + Math.cos(6006) * 88;
+acc += Math.sin(6006) + Math.cos(6007) * 89;
+acc += Math.sin(6007) + Math.cos(6008) * 90;
+acc += Math.sin(6008) + Math.cos(6009) * 91;
+acc += Math.sin(6009) + Math.cos(6010) * 92;
+acc += Math.sin(6010) + Math.cos(6011) * 93;
+acc += Math.sin(6011) + Math.cos(6012) * 94;
+acc += Math.sin(6012) + Math.cos(6013) * 95;
+acc += Math.sin(6013) + Math.cos(6014) * 96;
+acc += Math.sin(6014) + Math.cos(6015) * 0;
+acc += Math.sin(6015) + Math.cos(6016) * 1;
+acc += Math.sin(6016) + Math.cos(6017) * 2;
+acc += Math.sin(6017) + Math.cos(6018) * 3;
+acc += Math.sin(6018) + Math.cos(6019) * 4;
+acc += Math.sin(6019) + Math.cos(6020) * 5;
+acc += Math.sin(6020) + Math.cos(6021) * 6;
+acc += Math.sin(6021) + Math.cos(6022) * 7;
+acc += Math.sin(6022) + Math.cos(6023) * 8;
+acc += Math.sin(6023) + Math.cos(6024) * 9;
+acc += Math.sin(6024) + Math.cos(6025) * 10;
+acc += Math.sin(6025) + Math.cos(6026) * 11;
+acc += Math.sin(6026) + Math.cos(6027) * 12;
+acc += Math.sin(6027) + Math.cos(6028) * 13;
+acc += Math.sin(6028) + Math.cos(6029) * 14;
+acc += Math.sin(6029) + Math.cos(6030) * 15;
+acc += Math.sin(6030) + Math.cos(6031) * 16;
+acc += Math.sin(6031) + Math.cos(6032) * 17;
+acc += Math.sin(6032) + Math.cos(6033) * 18;
+acc += Math.sin(6033) + Math.cos(6034) * 19;
+acc += Math.sin(6034) + Math.cos(6035) * 20;
+acc += Math.sin(6035) + Math.cos(6036) * 21;
+acc += Math.sin(6036) + Math.cos(6037) * 22;
+acc += Math.sin(6037) + Math.cos(6038) * 23;
+acc += Math.sin(6038) + Math.cos(6039) * 24;
+acc += Math.sin(6039) + Math.cos(6040) * 25;
+acc += Math.sin(6040) + Math.cos(6041) * 26;
+acc += Math.sin(6041) + Math.cos(6042) * 27;
+acc += Math.sin(6042) + Math.cos(6043) * 28;
+acc += Math.sin(6043) + Math.cos(6044) * 29;
+acc += Math.sin(6044) + Math.cos(6045) * 30;
+acc += Math.sin(6045) + Math.cos(6046) * 31;
+acc += Math.sin(6046) + Math.cos(6047) * 32;
+acc += Math.sin(6047) + Math.cos(6048) * 33;
+acc += Math.sin(6048) + Math.cos(6049) * 34;
+acc += Math.sin(6049) + Math.cos(6050) * 35;
+acc += Math.sin(6050) + Math.cos(6051) * 36;
+acc += Math.sin(6051) + Math.cos(6052) * 37;
+acc += Math.sin(6052) + Math.cos(6053) * 38;
+acc += Math.sin(6053) + Math.cos(6054) * 39;
+acc += Math.sin(6054) + Math.cos(6055) * 40;
+acc += Math.sin(6055) + Math.cos(6056) * 41;
+acc += Math.sin(6056) + Math.cos(6057) * 42;
+acc += Math.sin(6057) + Math.cos(6058) * 43;
+acc += Math.sin(6058) + Math.cos(6059) * 44;
+acc += Math.sin(6059) + Math.cos(6060) * 45;
+acc += Math.sin(6060) + Math.cos(6061) * 46;
+acc += Math.sin(6061) + Math.cos(6062) * 47;
+acc += Math.sin(6062) + Math.cos(6063) * 48;
+acc += Math.sin(6063) + Math.cos(6064) * 49;
+acc += Math.sin(6064) + Math.cos(6065) * 50;
+acc += Math.sin(6065) + Math.cos(6066) * 51;
+acc += Math.sin(6066) + Math.cos(6067) * 52;
+acc += Math.sin(6067) + Math.cos(6068) * 53;
+acc += Math.sin(6068) + Math.cos(6069) * 54;
+acc += Math.sin(6069) + Math.cos(6070) * 55;
+acc += Math.sin(6070) + Math.cos(6071) * 56;
+acc += Math.sin(6071) + Math.cos(6072) * 57;
+acc += Math.sin(6072) + Math.cos(6073) * 58;
+acc += Math.sin(6073) + Math.cos(6074) * 59;
+acc += Math.sin(6074) + Math.cos(6075) * 60;
+acc += Math.sin(6075) + Math.cos(6076) * 61;
+acc += Math.sin(6076) + Math.cos(6077) * 62;
+acc += Math.sin(6077) + Math.cos(6078) * 63;
+acc += Math.sin(6078) + Math.cos(6079) * 64;
+acc += Math.sin(6079) + Math.cos(6080) * 65;
+acc += Math.sin(6080) + Math.cos(6081) * 66;
+acc += Math.sin(6081) + Math.cos(6082) * 67;
+acc += Math.sin(6082) + Math.cos(6083) * 68;
+acc += Math.sin(6083) + Math.cos(6084) * 69;
+acc += Math.sin(6084) + Math.cos(6085) * 70;
+acc += Math.sin(6085) + Math.cos(6086) * 71;
+acc += Math.sin(6086) + Math.cos(6087) * 72;
+acc += Math.sin(6087) + Math.cos(6088) * 73;
+acc += Math.sin(6088) + Math.cos(6089) * 74;
+acc += Math.sin(6089) + Math.cos(6090) * 75;
+acc += Math.sin(6090) + Math.cos(6091) * 76;
+acc += Math.sin(6091) + Math.cos(6092) * 77;
+acc += Math.sin(6092) + Math.cos(6093) * 78;
+acc += Math.sin(6093) + Math.cos(6094) * 79;
+acc += Math.sin(6094) + Math.cos(6095) * 80;
+acc += Math.sin(6095) + Math.cos(6096) * 81;
+acc += Math.sin(6096) + Math.cos(6097) * 82;
+acc += Math.sin(6097) + Math.cos(6098) * 83;
+acc += Math.sin(6098) + Math.cos(6099) * 84;
+acc += Math.sin(6099) + Math.cos(6100) * 85;
+acc += Math.sin(6100) + Math.cos(6101) * 86;
+acc += Math.sin(6101) + Math.cos(6102) * 87;
+acc += Math.sin(6102) + Math.cos(6103) * 88;
+acc += Math.sin(6103) + Math.cos(6104) * 89;
+acc += Math.sin(6104) + Math.cos(6105) * 90;
+acc += Math.sin(6105) + Math.cos(6106) * 91;
+acc += Math.sin(6106) + Math.cos(6107) * 92;
+acc += Math.sin(6107) + Math.cos(6108) * 93;
+acc += Math.sin(6108) + Math.cos(6109) * 94;
+acc += Math.sin(6109) + Math.cos(6110) * 95;
+acc += Math.sin(6110) + Math.cos(6111) * 96;
+acc += Math.sin(6111) + Math.cos(6112) * 0;
+acc += Math.sin(6112) + Math.cos(6113) * 1;
+acc += Math.sin(6113) + Math.cos(6114) * 2;
+acc += Math.sin(6114) + Math.cos(6115) * 3;
+acc += Math.sin(6115) + Math.cos(6116) * 4;
+acc += Math.sin(6116) + Math.cos(6117) * 5;
+acc += Math.sin(6117) + Math.cos(6118) * 6;
+acc += Math.sin(6118) + Math.cos(6119) * 7;
+acc += Math.sin(6119) + Math.cos(6120) * 8;
+acc += Math.sin(6120) + Math.cos(6121) * 9;
+acc += Math.sin(6121) + Math.cos(6122) * 10;
+acc += Math.sin(6122) + Math.cos(6123) * 11;
+acc += Math.sin(6123) + Math.cos(6124) * 12;
+acc += Math.sin(6124) + Math.cos(6125) * 13;
+acc += Math.sin(6125) + Math.cos(6126) * 14;
+acc += Math.sin(6126) + Math.cos(6127) * 15;
+acc += Math.sin(6127) + Math.cos(6128) * 16;
+acc += Math.sin(6128) + Math.cos(6129) * 17;
+acc += Math.sin(6129) + Math.cos(6130) * 18;
+acc += Math.sin(6130) + Math.cos(6131) * 19;
+acc += Math.sin(6131) + Math.cos(6132) * 20;
+acc += Math.sin(6132) + Math.cos(6133) * 21;
+acc += Math.sin(6133) + Math.cos(6134) * 22;
+acc += Math.sin(6134) + Math.cos(6135) * 23;
+acc += Math.sin(6135) + Math.cos(6136) * 24;
+acc += Math.sin(6136) + Math.cos(6137) * 25;
+acc += Math.sin(6137) + Math.cos(6138) * 26;
+acc += Math.sin(6138) + Math.cos(6139) * 27;
+acc += Math.sin(6139) + Math.cos(6140) * 28;
+acc += Math.sin(6140) + Math.cos(6141) * 29;
+acc += Math.sin(6141) + Math.cos(6142) * 30;
+acc += Math.sin(6142) + Math.cos(6143) * 31;
+acc += Math.sin(6143) + Math.cos(6144) * 32;
+acc += Math.sin(6144) + Math.cos(6145) * 33;
+acc += Math.sin(6145) + Math.cos(6146) * 34;
+acc += Math.sin(6146) + Math.cos(6147) * 35;
+acc += Math.sin(6147) + Math.cos(6148) * 36;
+acc += Math.sin(6148) + Math.cos(6149) * 37;
+acc += Math.sin(6149) + Math.cos(6150) * 38;
+acc += Math.sin(6150) + Math.cos(6151) * 39;
+acc += Math.sin(6151) + Math.cos(6152) * 40;
+acc += Math.sin(6152) + Math.cos(6153) * 41;
+acc += Math.sin(6153) + Math.cos(6154) * 42;
+acc += Math.sin(6154) + Math.cos(6155) * 43;
+acc += Math.sin(6155) + Math.cos(6156) * 44;
+acc += Math.sin(6156) + Math.cos(6157) * 45;
+acc += Math.sin(6157) + Math.cos(6158) * 46;
+acc += Math.sin(6158) + Math.cos(6159) * 47;
+acc += Math.sin(6159) + Math.cos(6160) * 48;
+acc += Math.sin(6160) + Math.cos(6161) * 49;
+acc += Math.sin(6161) + Math.cos(6162) * 50;
+acc += Math.sin(6162) + Math.cos(6163) * 51;
+acc += Math.sin(6163) + Math.cos(6164) * 52;
+acc += Math.sin(6164) + Math.cos(6165) * 53;
+acc += Math.sin(6165) + Math.cos(6166) * 54;
+acc += Math.sin(6166) + Math.cos(6167) * 55;
+acc += Math.sin(6167) + Math.cos(6168) * 56;
+acc += Math.sin(6168) + Math.cos(6169) * 57;
+acc += Math.sin(6169) + Math.cos(6170) * 58;
+acc += Math.sin(6170) + Math.cos(6171) * 59;
+acc += Math.sin(6171) + Math.cos(6172) * 60;
+acc += Math.sin(6172) + Math.cos(6173) * 61;
+acc += Math.sin(6173) + Math.cos(6174) * 62;
+acc += Math.sin(6174) + Math.cos(6175) * 63;
+acc += Math.sin(6175) + Math.cos(6176) * 64;
+acc += Math.sin(6176) + Math.cos(6177) * 65;
+acc += Math.sin(6177) + Math.cos(6178) * 66;
+acc += Math.sin(6178) + Math.cos(6179) * 67;
+acc += Math.sin(6179) + Math.cos(6180) * 68;
+acc += Math.sin(6180) + Math.cos(6181) * 69;
+acc += Math.sin(6181) + Math.cos(6182) * 70;
+acc += Math.sin(6182) + Math.cos(6183) * 71;
+acc += Math.sin(6183) + Math.cos(6184) * 72;
+acc += Math.sin(6184) + Math.cos(6185) * 73;
+acc += Math.sin(6185) + Math.cos(6186) * 74;
+acc += Math.sin(6186) + Math.cos(6187) * 75;
+acc += Math.sin(6187) + Math.cos(6188) * 76;
+acc += Math.sin(6188) + Math.cos(6189) * 77;
+acc += Math.sin(6189) + Math.cos(6190) * 78;
+acc += Math.sin(6190) + Math.cos(6191) * 79;
+acc += Math.sin(6191) + Math.cos(6192) * 80;
+acc += Math.sin(6192) + Math.cos(6193) * 81;
+acc += Math.sin(6193) + Math.cos(6194) * 82;
+acc += Math.sin(6194) + Math.cos(6195) * 83;
+acc += Math.sin(6195) + Math.cos(6196) * 84;
+acc += Math.sin(6196) + Math.cos(6197) * 85;
+acc += Math.sin(6197) + Math.cos(6198) * 86;
+acc += Math.sin(6198) + Math.cos(6199) * 87;
+acc += Math.sin(6199) + Math.cos(6200) * 88;
+acc += Math.sin(6200) + Math.cos(6201) * 89;
+acc += Math.sin(6201) + Math.cos(6202) * 90;
+acc += Math.sin(6202) + Math.cos(6203) * 91;
+acc += Math.sin(6203) + Math.cos(6204) * 92;
+acc += Math.sin(6204) + Math.cos(6205) * 93;
+acc += Math.sin(6205) + Math.cos(6206) * 94;
+acc += Math.sin(6206) + Math.cos(6207) * 95;
+acc += Math.sin(6207) + Math.cos(6208) * 96;
+acc += Math.sin(6208) + Math.cos(6209) * 0;
+acc += Math.sin(6209) + Math.cos(6210) * 1;
+acc += Math.sin(6210) + Math.cos(6211) * 2;
+acc += Math.sin(6211) + Math.cos(6212) * 3;
+acc += Math.sin(6212) + Math.cos(6213) * 4;
+acc += Math.sin(6213) + Math.cos(6214) * 5;
+acc += Math.sin(6214) + Math.cos(6215) * 6;
+acc += Math.sin(6215) + Math.cos(6216) * 7;
+acc += Math.sin(6216) + Math.cos(6217) * 8;
+acc += Math.sin(6217) + Math.cos(6218) * 9;
+acc += Math.sin(6218) + Math.cos(6219) * 10;
+acc += Math.sin(6219) + Math.cos(6220) * 11;
+acc += Math.sin(6220) + Math.cos(6221) * 12;
+acc += Math.sin(6221) + Math.cos(6222) * 13;
+acc += Math.sin(6222) + Math.cos(6223) * 14;
+acc += Math.sin(6223) + Math.cos(6224) * 15;
+acc += Math.sin(6224) + Math.cos(6225) * 16;
+acc += Math.sin(6225) + Math.cos(6226) * 17;
+acc += Math.sin(6226) + Math.cos(6227) * 18;
+acc += Math.sin(6227) + Math.cos(6228) * 19;
+acc += Math.sin(6228) + Math.cos(6229) * 20;
+acc += Math.sin(6229) + Math.cos(6230) * 21;
+acc += Math.sin(6230) + Math.cos(6231) * 22;
+acc += Math.sin(6231) + Math.cos(6232) * 23;
+acc += Math.sin(6232) + Math.cos(6233) * 24;
+acc += Math.sin(6233) + Math.cos(6234) * 25;
+acc += Math.sin(6234) + Math.cos(6235) * 26;
+acc += Math.sin(6235) + Math.cos(6236) * 27;
+acc += Math.sin(6236) + Math.cos(6237) * 28;
+acc += Math.sin(6237) + Math.cos(6238) * 29;
+acc += Math.sin(6238) + Math.cos(6239) * 30;
+acc += Math.sin(6239) + Math.cos(6240) * 31;
+acc += Math.sin(6240) + Math.cos(6241) * 32;
+acc += Math.sin(6241) + Math.cos(6242) * 33;
+acc += Math.sin(6242) + Math.cos(6243) * 34;
+acc += Math.sin(6243) + Math.cos(6244) * 35;
+acc += Math.sin(6244) + Math.cos(6245) * 36;
+acc += Math.sin(6245) + Math.cos(6246) * 37;
+acc += Math.sin(6246) + Math.cos(6247) * 38;
+acc += Math.sin(6247) + Math.cos(6248) * 39;
+acc += Math.sin(6248) + Math.cos(6249) * 40;
+acc += Math.sin(6249) + Math.cos(6250) * 41;
+acc += Math.sin(6250) + Math.cos(6251) * 42;
+acc += Math.sin(6251) + Math.cos(6252) * 43;
+acc += Math.sin(6252) + Math.cos(6253) * 44;
+acc += Math.sin(6253) + Math.cos(6254) * 45;
+acc += Math.sin(6254) + Math.cos(6255) * 46;
+acc += Math.sin(6255) + Math.cos(6256) * 47;
+acc += Math.sin(6256) + Math.cos(6257) * 48;
+acc += Math.sin(6257) + Math.cos(6258) * 49;
+acc += Math.sin(6258) + Math.cos(6259) * 50;
+acc += Math.sin(6259) + Math.cos(6260) * 51;
+acc += Math.sin(6260) + Math.cos(6261) * 52;
+acc += Math.sin(6261) + Math.cos(6262) * 53;
+acc += Math.sin(6262) + Math.cos(6263) * 54;
+acc += Math.sin(6263) + Math.cos(6264) * 55;
+acc += Math.sin(6264) + Math.cos(6265) * 56;
+acc += Math.sin(6265) + Math.cos(6266) * 57;
+acc += Math.sin(6266) + Math.cos(6267) * 58;
+acc += Math.sin(6267) + Math.cos(6268) * 59;
+acc += Math.sin(6268) + Math.cos(6269) * 60;
+acc += Math.sin(6269) + Math.cos(6270) * 61;
+acc += Math.sin(6270) + Math.cos(6271) * 62;
+acc += Math.sin(6271) + Math.cos(6272) * 63;
+acc += Math.sin(6272) + Math.cos(6273) * 64;
+acc += Math.sin(6273) + Math.cos(6274) * 65;
+acc += Math.sin(6274) + Math.cos(6275) * 66;
+acc += Math.sin(6275) + Math.cos(6276) * 67;
+acc += Math.sin(6276) + Math.cos(6277) * 68;
+acc += Math.sin(6277) + Math.cos(6278) * 69;
+acc += Math.sin(6278) + Math.cos(6279) * 70;
+acc += Math.sin(6279) + Math.cos(6280) * 71;
+acc += Math.sin(6280) + Math.cos(6281) * 72;
+acc += Math.sin(6281) + Math.cos(6282) * 73;
+acc += Math.sin(6282) + Math.cos(6283) * 74;
+acc += Math.sin(6283) + Math.cos(6284) * 75;
+acc += Math.sin(6284) + Math.cos(6285) * 76;
+acc += Math.sin(6285) + Math.cos(6286) * 77;
+acc += Math.sin(6286) + Math.cos(6287) * 78;
+acc += Math.sin(6287) + Math.cos(6288) * 79;
+acc += Math.sin(6288) + Math.cos(6289) * 80;
+acc += Math.sin(6289) + Math.cos(6290) * 81;
+acc += Math.sin(6290) + Math.cos(6291) * 82;
+acc += Math.sin(6291) + Math.cos(6292) * 83;
+acc += Math.sin(6292) + Math.cos(6293) * 84;
+acc += Math.sin(6293) + Math.cos(6294) * 85;
+acc += Math.sin(6294) + Math.cos(6295) * 86;
+acc += Math.sin(6295) + Math.cos(6296) * 87;
+acc += Math.sin(6296) + Math.cos(6297) * 88;
+acc += Math.sin(6297) + Math.cos(6298) * 89;
+acc += Math.sin(6298) + Math.cos(6299) * 90;
+acc += Math.sin(6299) + Math.cos(6300) * 91;
+acc += Math.sin(6300) + Math.cos(6301) * 92;
+acc += Math.sin(6301) + Math.cos(6302) * 93;
+acc += Math.sin(6302) + Math.cos(6303) * 94;
+acc += Math.sin(6303) + Math.cos(6304) * 95;
+acc += Math.sin(6304) + Math.cos(6305) * 96;
+acc += Math.sin(6305) + Math.cos(6306) * 0;
+acc += Math.sin(6306) + Math.cos(6307) * 1;
+acc += Math.sin(6307) + Math.cos(6308) * 2;
+acc += Math.sin(6308) + Math.cos(6309) * 3;
+acc += Math.sin(6309) + Math.cos(6310) * 4;
+acc += Math.sin(6310) + Math.cos(6311) * 5;
+acc += Math.sin(6311) + Math.cos(6312) * 6;
+acc += Math.sin(6312) + Math.cos(6313) * 7;
+acc += Math.sin(6313) + Math.cos(6314) * 8;
+acc += Math.sin(6314) + Math.cos(6315) * 9;
+acc += Math.sin(6315) + Math.cos(6316) * 10;
+acc += Math.sin(6316) + Math.cos(6317) * 11;
+acc += Math.sin(6317) + Math.cos(6318) * 12;
+acc += Math.sin(6318) + Math.cos(6319) * 13;
+acc += Math.sin(6319) + Math.cos(6320) * 14;
+acc += Math.sin(6320) + Math.cos(6321) * 15;
+acc += Math.sin(6321) + Math.cos(6322) * 16;
+acc += Math.sin(6322) + Math.cos(6323) * 17;
+acc += Math.sin(6323) + Math.cos(6324) * 18;
+acc += Math.sin(6324) + Math.cos(6325) * 19;
+acc += Math.sin(6325) + Math.cos(6326) * 20;
+acc += Math.sin(6326) + Math.cos(6327) * 21;
+acc += Math.sin(6327) + Math.cos(6328) * 22;
+acc += Math.sin(6328) + Math.cos(6329) * 23;
+acc += Math.sin(6329) + Math.cos(6330) * 24;
+acc += Math.sin(6330) + Math.cos(6331) * 25;
+acc += Math.sin(6331) + Math.cos(6332) * 26;
+acc += Math.sin(6332) + Math.cos(6333) * 27;
+acc += Math.sin(6333) + Math.cos(6334) * 28;
+acc += Math.sin(6334) + Math.cos(6335) * 29;
+acc += Math.sin(6335) + Math.cos(6336) * 30;
+acc += Math.sin(6336) + Math.cos(6337) * 31;
+acc += Math.sin(6337) + Math.cos(6338) * 32;
+acc += Math.sin(6338) + Math.cos(6339) * 33;
+acc += Math.sin(6339) + Math.cos(6340) * 34;
+acc += Math.sin(6340) + Math.cos(6341) * 35;
+acc += Math.sin(6341) + Math.cos(6342) * 36;
+acc += Math.sin(6342) + Math.cos(6343) * 37;
+acc += Math.sin(6343) + Math.cos(6344) * 38;
+acc += Math.sin(6344) + Math.cos(6345) * 39;
+acc += Math.sin(6345) + Math.cos(6346) * 40;
+acc += Math.sin(6346) + Math.cos(6347) * 41;
+acc += Math.sin(6347) + Math.cos(6348) * 42;
+acc += Math.sin(6348) + Math.cos(6349) * 43;
+acc += Math.sin(6349) + Math.cos(6350) * 44;
+acc += Math.sin(6350) + Math.cos(6351) * 45;
+acc += Math.sin(6351) + Math.cos(6352) * 46;
+acc += Math.sin(6352) + Math.cos(6353) * 47;
+acc += Math.sin(6353) + Math.cos(6354) * 48;
+acc += Math.sin(6354) + Math.cos(6355) * 49;
+acc += Math.sin(6355) + Math.cos(6356) * 50;
+acc += Math.sin(6356) + Math.cos(6357) * 51;
+acc += Math.sin(6357) + Math.cos(6358) * 52;
+acc += Math.sin(6358) + Math.cos(6359) * 53;
+acc += Math.sin(6359) + Math.cos(6360) * 54;
+acc += Math.sin(6360) + Math.cos(6361) * 55;
+acc += Math.sin(6361) + Math.cos(6362) * 56;
+acc += Math.sin(6362) + Math.cos(6363) * 57;
+acc += Math.sin(6363) + Math.cos(6364) * 58;
+acc += Math.sin(6364) + Math.cos(6365) * 59;
+acc += Math.sin(6365) + Math.cos(6366) * 60;
+acc += Math.sin(6366) + Math.cos(6367) * 61;
+acc += Math.sin(6367) + Math.cos(6368) * 62;
+acc += Math.sin(6368) + Math.cos(6369) * 63;
+acc += Math.sin(6369) + Math.cos(6370) * 64;
+acc += Math.sin(6370) + Math.cos(6371) * 65;
+acc += Math.sin(6371) + Math.cos(6372) * 66;
+acc += Math.sin(6372) + Math.cos(6373) * 67;
+acc += Math.sin(6373) + Math.cos(6374) * 68;
+acc += Math.sin(6374) + Math.cos(6375) * 69;
+acc += Math.sin(6375) + Math.cos(6376) * 70;
+acc += Math.sin(6376) + Math.cos(6377) * 71;
+acc += Math.sin(6377) + Math.cos(6378) * 72;
+acc += Math.sin(6378) + Math.cos(6379) * 73;
+acc += Math.sin(6379) + Math.cos(6380) * 74;
+acc += Math.sin(6380) + Math.cos(6381) * 75;
+acc += Math.sin(6381) + Math.cos(6382) * 76;
+acc += Math.sin(6382) + Math.cos(6383) * 77;
+acc += Math.sin(6383) + Math.cos(6384) * 78;
+acc += Math.sin(6384) + Math.cos(6385) * 79;
+acc += Math.sin(6385) + Math.cos(6386) * 80;
+acc += Math.sin(6386) + Math.cos(6387) * 81;
+acc += Math.sin(6387) + Math.cos(6388) * 82;
+acc += Math.sin(6388) + Math.cos(6389) * 83;
+acc += Math.sin(6389) + Math.cos(6390) * 84;
+acc += Math.sin(6390) + Math.cos(6391) * 85;
+acc += Math.sin(6391) + Math.cos(6392) * 86;
+acc += Math.sin(6392) + Math.cos(6393) * 87;
+acc += Math.sin(6393) + Math.cos(6394) * 88;
+acc += Math.sin(6394) + Math.cos(6395) * 89;
+acc += Math.sin(6395) + Math.cos(6396) * 90;
+acc += Math.sin(6396) + Math.cos(6397) * 91;
+acc += Math.sin(6397) + Math.cos(6398) * 92;
+acc += Math.sin(6398) + Math.cos(6399) * 93;
+acc += Math.sin(6399) + Math.cos(6400) * 94;
+acc += Math.sin(6400) + Math.cos(6401) * 95;
+acc += Math.sin(6401) + Math.cos(6402) * 96;
+acc += Math.sin(6402) + Math.cos(6403) * 0;
+acc += Math.sin(6403) + Math.cos(6404) * 1;
+acc += Math.sin(6404) + Math.cos(6405) * 2;
+acc += Math.sin(6405) + Math.cos(6406) * 3;
+acc += Math.sin(6406) + Math.cos(6407) * 4;
+acc += Math.sin(6407) + Math.cos(6408) * 5;
+acc += Math.sin(6408) + Math.cos(6409) * 6;
+acc += Math.sin(6409) + Math.cos(6410) * 7;
+acc += Math.sin(6410) + Math.cos(6411) * 8;
+acc += Math.sin(6411) + Math.cos(6412) * 9;
+acc += Math.sin(6412) + Math.cos(6413) * 10;
+acc += Math.sin(6413) + Math.cos(6414) * 11;
+acc += Math.sin(6414) + Math.cos(6415) * 12;
+acc += Math.sin(6415) + Math.cos(6416) * 13;
+acc += Math.sin(6416) + Math.cos(6417) * 14;
+acc += Math.sin(6417) + Math.cos(6418) * 15;
+acc += Math.sin(6418) + Math.cos(6419) * 16;
+acc += Math.sin(6419) + Math.cos(6420) * 17;
+acc += Math.sin(6420) + Math.cos(6421) * 18;
+acc += Math.sin(6421) + Math.cos(6422) * 19;
+acc += Math.sin(6422) + Math.cos(6423) * 20;
+acc += Math.sin(6423) + Math.cos(6424) * 21;
+acc += Math.sin(6424) + Math.cos(6425) * 22;
+acc += Math.sin(6425) + Math.cos(6426) * 23;
+acc += Math.sin(6426) + Math.cos(6427) * 24;
+acc += Math.sin(6427) + Math.cos(6428) * 25;
+acc += Math.sin(6428) + Math.cos(6429) * 26;
+acc += Math.sin(6429) + Math.cos(6430) * 27;
+acc += Math.sin(6430) + Math.cos(6431) * 28;
+acc += Math.sin(6431) + Math.cos(6432) * 29;
+acc += Math.sin(6432) + Math.cos(6433) * 30;
+acc += Math.sin(6433) + Math.cos(6434) * 31;
+acc += Math.sin(6434) + Math.cos(6435) * 32;
+acc += Math.sin(6435) + Math.cos(6436) * 33;
+acc += Math.sin(6436) + Math.cos(6437) * 34;
+acc += Math.sin(6437) + Math.cos(6438) * 35;
+acc += Math.sin(6438) + Math.cos(6439) * 36;
+acc += Math.sin(6439) + Math.cos(6440) * 37;
+acc += Math.sin(6440) + Math.cos(6441) * 38;
+acc += Math.sin(6441) + Math.cos(6442) * 39;
+acc += Math.sin(6442) + Math.cos(6443) * 40;
+acc += Math.sin(6443) + Math.cos(6444) * 41;
+acc += Math.sin(6444) + Math.cos(6445) * 42;
+acc += Math.sin(6445) + Math.cos(6446) * 43;
+acc += Math.sin(6446) + Math.cos(6447) * 44;
+acc += Math.sin(6447) + Math.cos(6448) * 45;
+acc += Math.sin(6448) + Math.cos(6449) * 46;
+acc += Math.sin(6449) + Math.cos(6450) * 47;
+acc += Math.sin(6450) + Math.cos(6451) * 48;
+acc += Math.sin(6451) + Math.cos(6452) * 49;
+acc += Math.sin(6452) + Math.cos(6453) * 50;
+acc += Math.sin(6453) + Math.cos(6454) * 51;
+acc += Math.sin(6454) + Math.cos(6455) * 52;
+acc += Math.sin(6455) + Math.cos(6456) * 53;
+acc += Math.sin(6456) + Math.cos(6457) * 54;
+acc += Math.sin(6457) + Math.cos(6458) * 55;
+acc += Math.sin(6458) + Math.cos(6459) * 56;
+acc += Math.sin(6459) + Math.cos(6460) * 57;
+acc += Math.sin(6460) + Math.cos(6461) * 58;
+acc += Math.sin(6461) + Math.cos(6462) * 59;
+acc += Math.sin(6462) + Math.cos(6463) * 60;
+acc += Math.sin(6463) + Math.cos(6464) * 61;
+acc += Math.sin(6464) + Math.cos(6465) * 62;
+acc += Math.sin(6465) + Math.cos(6466) * 63;
+acc += Math.sin(6466) + Math.cos(6467) * 64;
+acc += Math.sin(6467) + Math.cos(6468) * 65;
+acc += Math.sin(6468) + Math.cos(6469) * 66;
+acc += Math.sin(6469) + Math.cos(6470) * 67;
+acc += Math.sin(6470) + Math.cos(6471) * 68;
+acc += Math.sin(6471) + Math.cos(6472) * 69;
+acc += Math.sin(6472) + Math.cos(6473) * 70;
+acc += Math.sin(6473) + Math.cos(6474) * 71;
+acc += Math.sin(6474) + Math.cos(6475) * 72;
+acc += Math.sin(6475) + Math.cos(6476) * 73;
+acc += Math.sin(6476) + Math.cos(6477) * 74;
+acc += Math.sin(6477) + Math.cos(6478) * 75;
+acc += Math.sin(6478) + Math.cos(6479) * 76;
+acc += Math.sin(6479) + Math.cos(6480) * 77;
+acc += Math.sin(6480) + Math.cos(6481) * 78;
+acc += Math.sin(6481) + Math.cos(6482) * 79;
+acc += Math.sin(6482) + Math.cos(6483) * 80;
+acc += Math.sin(6483) + Math.cos(6484) * 81;
+acc += Math.sin(6484) + Math.cos(6485) * 82;
+acc += Math.sin(6485) + Math.cos(6486) * 83;
+acc += Math.sin(6486) + Math.cos(6487) * 84;
+acc += Math.sin(6487) + Math.cos(6488) * 85;
+acc += Math.sin(6488) + Math.cos(6489) * 86;
+acc += Math.sin(6489) + Math.cos(6490) * 87;
+acc += Math.sin(6490) + Math.cos(6491) * 88;
+acc += Math.sin(6491) + Math.cos(6492) * 89;
+acc += Math.sin(6492) + Math.cos(6493) * 90;
+acc += Math.sin(6493) + Math.cos(6494) * 91;
+acc += Math.sin(6494) + Math.cos(6495) * 92;
+acc += Math.sin(6495) + Math.cos(6496) * 93;
+acc += Math.sin(6496) + Math.cos(6497) * 94;
+acc += Math.sin(6497) + Math.cos(6498) * 95;
+acc += Math.sin(6498) + Math.cos(6499) * 96;
+acc += Math.sin(6499) + Math.cos(6500) * 0;
+acc += Math.sin(6500) + Math.cos(6501) * 1;
+acc += Math.sin(6501) + Math.cos(6502) * 2;
+acc += Math.sin(6502) + Math.cos(6503) * 3;
+acc += Math.sin(6503) + Math.cos(6504) * 4;
+acc += Math.sin(6504) + Math.cos(6505) * 5;
+acc += Math.sin(6505) + Math.cos(6506) * 6;
+acc += Math.sin(6506) + Math.cos(6507) * 7;
+acc += Math.sin(6507) + Math.cos(6508) * 8;
+acc += Math.sin(6508) + Math.cos(6509) * 9;
+acc += Math.sin(6509) + Math.cos(6510) * 10;
+acc += Math.sin(6510) + Math.cos(6511) * 11;
+acc += Math.sin(6511) + Math.cos(6512) * 12;
+acc += Math.sin(6512) + Math.cos(6513) * 13;
+acc += Math.sin(6513) + Math.cos(6514) * 14;
+acc += Math.sin(6514) + Math.cos(6515) * 15;
+acc += Math.sin(6515) + Math.cos(6516) * 16;
+acc += Math.sin(6516) + Math.cos(6517) * 17;
+acc += Math.sin(6517) + Math.cos(6518) * 18;
+acc += Math.sin(6518) + Math.cos(6519) * 19;
+acc += Math.sin(6519) + Math.cos(6520) * 20;
+acc += Math.sin(6520) + Math.cos(6521) * 21;
+acc += Math.sin(6521) + Math.cos(6522) * 22;
+acc += Math.sin(6522) + Math.cos(6523) * 23;
+acc += Math.sin(6523) + Math.cos(6524) * 24;
+acc += Math.sin(6524) + Math.cos(6525) * 25;
+acc += Math.sin(6525) + Math.cos(6526) * 26;
+acc += Math.sin(6526) + Math.cos(6527) * 27;
+acc += Math.sin(6527) + Math.cos(6528) * 28;
+acc += Math.sin(6528) + Math.cos(6529) * 29;
+acc += Math.sin(6529) + Math.cos(6530) * 30;
+acc += Math.sin(6530) + Math.cos(6531) * 31;
+acc += Math.sin(6531) + Math.cos(6532) * 32;
+acc += Math.sin(6532) + Math.cos(6533) * 33;
+acc += Math.sin(6533) + Math.cos(6534) * 34;
+acc += Math.sin(6534) + Math.cos(6535) * 35;
+acc += Math.sin(6535) + Math.cos(6536) * 36;
+acc += Math.sin(6536) + Math.cos(6537) * 37;
+acc += Math.sin(6537) + Math.cos(6538) * 38;
+acc += Math.sin(6538) + Math.cos(6539) * 39;
+acc += Math.sin(6539) + Math.cos(6540) * 40;
+acc += Math.sin(6540) + Math.cos(6541) * 41;
+acc += Math.sin(6541) + Math.cos(6542) * 42;
+acc += Math.sin(6542) + Math.cos(6543) * 43;
+acc += Math.sin(6543) + Math.cos(6544) * 44;
+acc += Math.sin(6544) + Math.cos(6545) * 45;
+acc += Math.sin(6545) + Math.cos(6546) * 46;
+acc += Math.sin(6546) + Math.cos(6547) * 47;
+acc += Math.sin(6547) + Math.cos(6548) * 48;
+acc += Math.sin(6548) + Math.cos(6549) * 49;
+acc += Math.sin(6549) + Math.cos(6550) * 50;
+acc += Math.sin(6550) + Math.cos(6551) * 51;
+acc += Math.sin(6551) + Math.cos(6552) * 52;
+acc += Math.sin(6552) + Math.cos(6553) * 53;
+acc += Math.sin(6553) + Math.cos(6554) * 54;
+acc += Math.sin(6554) + Math.cos(6555) * 55;
+acc += Math.sin(6555) + Math.cos(6556) * 56;
+acc += Math.sin(6556) + Math.cos(6557) * 57;
+acc += Math.sin(6557) + Math.cos(6558) * 58;
+acc += Math.sin(6558) + Math.cos(6559) * 59;
+acc += Math.sin(6559) + Math.cos(6560) * 60;
+acc += Math.sin(6560) + Math.cos(6561) * 61;
+acc += Math.sin(6561) + Math.cos(6562) * 62;
+acc += Math.sin(6562) + Math.cos(6563) * 63;
+acc += Math.sin(6563) + Math.cos(6564) * 64;
+acc += Math.sin(6564) + Math.cos(6565) * 65;
+acc += Math.sin(6565) + Math.cos(6566) * 66;
+acc += Math.sin(6566) + Math.cos(6567) * 67;
+acc += Math.sin(6567) + Math.cos(6568) * 68;
+acc += Math.sin(6568) + Math.cos(6569) * 69;
+acc += Math.sin(6569) + Math.cos(6570) * 70;
+acc += Math.sin(6570) + Math.cos(6571) * 71;
+acc += Math.sin(6571) + Math.cos(6572) * 72;
+acc += Math.sin(6572) + Math.cos(6573) * 73;
+acc += Math.sin(6573) + Math.cos(6574) * 74;
+acc += Math.sin(6574) + Math.cos(6575) * 75;
+acc += Math.sin(6575) + Math.cos(6576) * 76;
+acc += Math.sin(6576) + Math.cos(6577) * 77;
+acc += Math.sin(6577) + Math.cos(6578) * 78;
+acc += Math.sin(6578) + Math.cos(6579) * 79;
+acc += Math.sin(6579) + Math.cos(6580) * 80;
+acc += Math.sin(6580) + Math.cos(6581) * 81;
+acc += Math.sin(6581) + Math.cos(6582) * 82;
+acc += Math.sin(6582) + Math.cos(6583) * 83;
+acc += Math.sin(6583) + Math.cos(6584) * 84;
+acc += Math.sin(6584) + Math.cos(6585) * 85;
+acc += Math.sin(6585) + Math.cos(6586) * 86;
+acc += Math.sin(6586) + Math.cos(6587) * 87;
+acc += Math.sin(6587) + Math.cos(6588) * 88;
+acc += Math.sin(6588) + Math.cos(6589) * 89;
+acc += Math.sin(6589) + Math.cos(6590) * 90;
+acc += Math.sin(6590) + Math.cos(6591) * 91;
+acc += Math.sin(6591) + Math.cos(6592) * 92;
+acc += Math.sin(6592) + Math.cos(6593) * 93;
+acc += Math.sin(6593) + Math.cos(6594) * 94;
+acc += Math.sin(6594) + Math.cos(6595) * 95;
+acc += Math.sin(6595) + Math.cos(6596) * 96;
+acc += Math.sin(6596) + Math.cos(6597) * 0;
+acc += Math.sin(6597) + Math.cos(6598) * 1;
+acc += Math.sin(6598) + Math.cos(6599) * 2;
+acc += Math.sin(6599) + Math.cos(6600) * 3;
+acc += Math.sin(6600) + Math.cos(6601) * 4;
+acc += Math.sin(6601) + Math.cos(6602) * 5;
+acc += Math.sin(6602) + Math.cos(6603) * 6;
+acc += Math.sin(6603) + Math.cos(6604) * 7;
+acc += Math.sin(6604) + Math.cos(6605) * 8;
+acc += Math.sin(6605) + Math.cos(6606) * 9;
+acc += Math.sin(6606) + Math.cos(6607) * 10;
+acc += Math.sin(6607) + Math.cos(6608) * 11;
+acc += Math.sin(6608) + Math.cos(6609) * 12;
+acc += Math.sin(6609) + Math.cos(6610) * 13;
+acc += Math.sin(6610) + Math.cos(6611) * 14;
+acc += Math.sin(6611) + Math.cos(6612) * 15;
+acc += Math.sin(6612) + Math.cos(6613) * 16;
+acc += Math.sin(6613) + Math.cos(6614) * 17;
+acc += Math.sin(6614) + Math.cos(6615) * 18;
+acc += Math.sin(6615) + Math.cos(6616) * 19;
+acc += Math.sin(6616) + Math.cos(6617) * 20;
+acc += Math.sin(6617) + Math.cos(6618) * 21;
+acc += Math.sin(6618) + Math.cos(6619) * 22;
+acc += Math.sin(6619) + Math.cos(6620) * 23;
+acc += Math.sin(6620) + Math.cos(6621) * 24;
+acc += Math.sin(6621) + Math.cos(6622) * 25;
+acc += Math.sin(6622) + Math.cos(6623) * 26;
+acc += Math.sin(6623) + Math.cos(6624) * 27;
+acc += Math.sin(6624) + Math.cos(6625) * 28;
+acc += Math.sin(6625) + Math.cos(6626) * 29;
+acc += Math.sin(6626) + Math.cos(6627) * 30;
+acc += Math.sin(6627) + Math.cos(6628) * 31;
+acc += Math.sin(6628) + Math.cos(6629) * 32;
+acc += Math.sin(6629) + Math.cos(6630) * 33;
+acc += Math.sin(6630) + Math.cos(6631) * 34;
+acc += Math.sin(6631) + Math.cos(6632) * 35;
+acc += Math.sin(6632) + Math.cos(6633) * 36;
+acc += Math.sin(6633) + Math.cos(6634) * 37;
+acc += Math.sin(6634) + Math.cos(6635) * 38;
+acc += Math.sin(6635) + Math.cos(6636) * 39;
+acc += Math.sin(6636) + Math.cos(6637) * 40;
+acc += Math.sin(6637) + Math.cos(6638) * 41;
+acc += Math.sin(6638) + Math.cos(6639) * 42;
+acc += Math.sin(6639) + Math.cos(6640) * 43;
+acc += Math.sin(6640) + Math.cos(6641) * 44;
+acc += Math.sin(6641) + Math.cos(6642) * 45;
+acc += Math.sin(6642) + Math.cos(6643) * 46;
+acc += Math.sin(6643) + Math.cos(6644) * 47;
+acc += Math.sin(6644) + Math.cos(6645) * 48;
+acc += Math.sin(6645) + Math.cos(6646) * 49;
+acc += Math.sin(6646) + Math.cos(6647) * 50;
+acc += Math.sin(6647) + Math.cos(6648) * 51;
+acc += Math.sin(6648) + Math.cos(6649) * 52;
+acc += Math.sin(6649) + Math.cos(6650) * 53;
+acc += Math.sin(6650) + Math.cos(6651) * 54;
+acc += Math.sin(6651) + Math.cos(6652) * 55;
+acc += Math.sin(6652) + Math.cos(6653) * 56;
+acc += Math.sin(6653) + Math.cos(6654) * 57;
+acc += Math.sin(6654) + Math.cos(6655) * 58;
+acc += Math.sin(6655) + Math.cos(6656) * 59;
+acc += Math.sin(6656) + Math.cos(6657) * 60;
+acc += Math.sin(6657) + Math.cos(6658) * 61;
+acc += Math.sin(6658) + Math.cos(6659) * 62;
+acc += Math.sin(6659) + Math.cos(6660) * 63;
+acc += Math.sin(6660) + Math.cos(6661) * 64;
+acc += Math.sin(6661) + Math.cos(6662) * 65;
+acc += Math.sin(6662) + Math.cos(6663) * 66;
+acc += Math.sin(6663) + Math.cos(6664) * 67;
+acc += Math.sin(6664) + Math.cos(6665) * 68;
+acc += Math.sin(6665) + Math.cos(6666) * 69;
+acc += Math.sin(6666) + Math.cos(6667) * 70;
+acc += Math.sin(6667) + Math.cos(6668) * 71;
+acc += Math.sin(6668) + Math.cos(6669) * 72;
+acc += Math.sin(6669) + Math.cos(6670) * 73;
+acc += Math.sin(6670) + Math.cos(6671) * 74;
+acc += Math.sin(6671) + Math.cos(6672) * 75;
+acc += Math.sin(6672) + Math.cos(6673) * 76;
+acc += Math.sin(6673) + Math.cos(6674) * 77;
+acc += Math.sin(6674) + Math.cos(6675) * 78;
+acc += Math.sin(6675) + Math.cos(6676) * 79;
+acc += Math.sin(6676) + Math.cos(6677) * 80;
+acc += Math.sin(6677) + Math.cos(6678) * 81;
+acc += Math.sin(6678) + Math.cos(6679) * 82;
+acc += Math.sin(6679) + Math.cos(6680) * 83;
+acc += Math.sin(6680) + Math.cos(6681) * 84;
+acc += Math.sin(6681) + Math.cos(6682) * 85;
+acc += Math.sin(6682) + Math.cos(6683) * 86;
+acc += Math.sin(6683) + Math.cos(6684) * 87;
+acc += Math.sin(6684) + Math.cos(6685) * 88;
+acc += Math.sin(6685) + Math.cos(6686) * 89;
+acc += Math.sin(6686) + Math.cos(6687) * 90;
+acc += Math.sin(6687) + Math.cos(6688) * 91;
+acc += Math.sin(6688) + Math.cos(6689) * 92;
+acc += Math.sin(6689) + Math.cos(6690) * 93;
+acc += Math.sin(6690) + Math.cos(6691) * 94;
+acc += Math.sin(6691) + Math.cos(6692) * 95;
+acc += Math.sin(6692) + Math.cos(6693) * 96;
+acc += Math.sin(6693) + Math.cos(6694) * 0;
+acc += Math.sin(6694) + Math.cos(6695) * 1;
+acc += Math.sin(6695) + Math.cos(6696) * 2;
+acc += Math.sin(6696) + Math.cos(6697) * 3;
+acc += Math.sin(6697) + Math.cos(6698) * 4;
+acc += Math.sin(6698) + Math.cos(6699) * 5;
+acc += Math.sin(6699) + Math.cos(6700) * 6;
+acc += Math.sin(6700) + Math.cos(6701) * 7;
+acc += Math.sin(6701) + Math.cos(6702) * 8;
+acc += Math.sin(6702) + Math.cos(6703) * 9;
+acc += Math.sin(6703) + Math.cos(6704) * 10;
+acc += Math.sin(6704) + Math.cos(6705) * 11;
+acc += Math.sin(6705) + Math.cos(6706) * 12;
+acc += Math.sin(6706) + Math.cos(6707) * 13;
+acc += Math.sin(6707) + Math.cos(6708) * 14;
+acc += Math.sin(6708) + Math.cos(6709) * 15;
+acc += Math.sin(6709) + Math.cos(6710) * 16;
+acc += Math.sin(6710) + Math.cos(6711) * 17;
+acc += Math.sin(6711) + Math.cos(6712) * 18;
+acc += Math.sin(6712) + Math.cos(6713) * 19;
+acc += Math.sin(6713) + Math.cos(6714) * 20;
+acc += Math.sin(6714) + Math.cos(6715) * 21;
+acc += Math.sin(6715) + Math.cos(6716) * 22;
+acc += Math.sin(6716) + Math.cos(6717) * 23;
+acc += Math.sin(6717) + Math.cos(6718) * 24;
+acc += Math.sin(6718) + Math.cos(6719) * 25;
+acc += Math.sin(6719) + Math.cos(6720) * 26;
+acc += Math.sin(6720) + Math.cos(6721) * 27;
+acc += Math.sin(6721) + Math.cos(6722) * 28;
+acc += Math.sin(6722) + Math.cos(6723) * 29;
+acc += Math.sin(6723) + Math.cos(6724) * 30;
+acc += Math.sin(6724) + Math.cos(6725) * 31;
+acc += Math.sin(6725) + Math.cos(6726) * 32;
+acc += Math.sin(6726) + Math.cos(6727) * 33;
+acc += Math.sin(6727) + Math.cos(6728) * 34;
+acc += Math.sin(6728) + Math.cos(6729) * 35;
+acc += Math.sin(6729) + Math.cos(6730) * 36;
+acc += Math.sin(6730) + Math.cos(6731) * 37;
+acc += Math.sin(6731) + Math.cos(6732) * 38;
+acc += Math.sin(6732) + Math.cos(6733) * 39;
+acc += Math.sin(6733) + Math.cos(6734) * 40;
+acc += Math.sin(6734) + Math.cos(6735) * 41;
+acc += Math.sin(6735) + Math.cos(6736) * 42;
+acc += Math.sin(6736) + Math.cos(6737) * 43;
+acc += Math.sin(6737) + Math.cos(6738) * 44;
+acc += Math.sin(6738) + Math.cos(6739) * 45;
+acc += Math.sin(6739) + Math.cos(6740) * 46;
+acc += Math.sin(6740) + Math.cos(6741) * 47;
+acc += Math.sin(6741) + Math.cos(6742) * 48;
+acc += Math.sin(6742) + Math.cos(6743) * 49;
+acc += Math.sin(6743) + Math.cos(6744) * 50;
+acc += Math.sin(6744) + Math.cos(6745) * 51;
+acc += Math.sin(6745) + Math.cos(6746) * 52;
+acc += Math.sin(6746) + Math.cos(6747) * 53;
+acc += Math.sin(6747) + Math.cos(6748) * 54;
+acc += Math.sin(6748) + Math.cos(6749) * 55;
+acc += Math.sin(6749) + Math.cos(6750) * 56;
+acc += Math.sin(6750) + Math.cos(6751) * 57;
+acc += Math.sin(6751) + Math.cos(6752) * 58;
+acc += Math.sin(6752) + Math.cos(6753) * 59;
+acc += Math.sin(6753) + Math.cos(6754) * 60;
+acc += Math.sin(6754) + Math.cos(6755) * 61;
+acc += Math.sin(6755) + Math.cos(6756) * 62;
+acc += Math.sin(6756) + Math.cos(6757) * 63;
+acc += Math.sin(6757) + Math.cos(6758) * 64;
+acc += Math.sin(6758) + Math.cos(6759) * 65;
+acc += Math.sin(6759) + Math.cos(6760) * 66;
+acc += Math.sin(6760) + Math.cos(6761) * 67;
+acc += Math.sin(6761) + Math.cos(6762) * 68;
+acc += Math.sin(6762) + Math.cos(6763) * 69;
+acc += Math.sin(6763) + Math.cos(6764) * 70;
+acc += Math.sin(6764) + Math.cos(6765) * 71;
+acc += Math.sin(6765) + Math.cos(6766) * 72;
+acc += Math.sin(6766) + Math.cos(6767) * 73;
+acc += Math.sin(6767) + Math.cos(6768) * 74;
+acc += Math.sin(6768) + Math.cos(6769) * 75;
+acc += Math.sin(6769) + Math.cos(6770) * 76;
+acc += Math.sin(6770) + Math.cos(6771) * 77;
+acc += Math.sin(6771) + Math.cos(6772) * 78;
+acc += Math.sin(6772) + Math.cos(6773) * 79;
+acc += Math.sin(6773) + Math.cos(6774) * 80;
+acc += Math.sin(6774) + Math.cos(6775) * 81;
+acc += Math.sin(6775) + Math.cos(6776) * 82;
+acc += Math.sin(6776) + Math.cos(6777) * 83;
+acc += Math.sin(6777) + Math.cos(6778) * 84;
+acc += Math.sin(6778) + Math.cos(6779) * 85;
+acc += Math.sin(6779) + Math.cos(6780) * 86;
+acc += Math.sin(6780) + Math.cos(6781) * 87;
+acc += Math.sin(6781) + Math.cos(6782) * 88;
+acc += Math.sin(6782) + Math.cos(6783) * 89;
+acc += Math.sin(6783) + Math.cos(6784) * 90;
+acc += Math.sin(6784) + Math.cos(6785) * 91;
+acc += Math.sin(6785) + Math.cos(6786) * 92;
+acc += Math.sin(6786) + Math.cos(6787) * 93;
+acc += Math.sin(6787) + Math.cos(6788) * 94;
+acc += Math.sin(6788) + Math.cos(6789) * 95;
+acc += Math.sin(6789) + Math.cos(6790) * 96;
+acc += Math.sin(6790) + Math.cos(6791) * 0;
+acc += Math.sin(6791) + Math.cos(6792) * 1;
+acc += Math.sin(6792) + Math.cos(6793) * 2;
+acc += Math.sin(6793) + Math.cos(6794) * 3;
+acc += Math.sin(6794) + Math.cos(6795) * 4;
+acc += Math.sin(6795) + Math.cos(6796) * 5;
+acc += Math.sin(6796) + Math.cos(6797) * 6;
+acc += Math.sin(6797) + Math.cos(6798) * 7;
+acc += Math.sin(6798) + Math.cos(6799) * 8;
+acc += Math.sin(6799) + Math.cos(6800) * 9;
+acc += Math.sin(6800) + Math.cos(6801) * 10;
+acc += Math.sin(6801) + Math.cos(6802) * 11;
+acc += Math.sin(6802) + Math.cos(6803) * 12;
+acc += Math.sin(6803) + Math.cos(6804) * 13;
+acc += Math.sin(6804) + Math.cos(6805) * 14;
+acc += Math.sin(6805) + Math.cos(6806) * 15;
+acc += Math.sin(6806) + Math.cos(6807) * 16;
+acc += Math.sin(6807) + Math.cos(6808) * 17;
+acc += Math.sin(6808) + Math.cos(6809) * 18;
+acc += Math.sin(6809) + Math.cos(6810) * 19;
+acc += Math.sin(6810) + Math.cos(6811) * 20;
+acc += Math.sin(6811) + Math.cos(6812) * 21;
+acc += Math.sin(6812) + Math.cos(6813) * 22;
+acc += Math.sin(6813) + Math.cos(6814) * 23;
+acc += Math.sin(6814) + Math.cos(6815) * 24;
+acc += Math.sin(6815) + Math.cos(6816) * 25;
+acc += Math.sin(6816) + Math.cos(6817) * 26;
+acc += Math.sin(6817) + Math.cos(6818) * 27;
+acc += Math.sin(6818) + Math.cos(6819) * 28;
+acc += Math.sin(6819) + Math.cos(6820) * 29;
+acc += Math.sin(6820) + Math.cos(6821) * 30;
+acc += Math.sin(6821) + Math.cos(6822) * 31;
+acc += Math.sin(6822) + Math.cos(6823) * 32;
+acc += Math.sin(6823) + Math.cos(6824) * 33;
+acc += Math.sin(6824) + Math.cos(6825) * 34;
+acc += Math.sin(6825) + Math.cos(6826) * 35;
+acc += Math.sin(6826) + Math.cos(6827) * 36;
+acc += Math.sin(6827) + Math.cos(6828) * 37;
+acc += Math.sin(6828) + Math.cos(6829) * 38;
+acc += Math.sin(6829) + Math.cos(6830) * 39;
+acc += Math.sin(6830) + Math.cos(6831) * 40;
+acc += Math.sin(6831) + Math.cos(6832) * 41;
+acc += Math.sin(6832) + Math.cos(6833) * 42;
+acc += Math.sin(6833) + Math.cos(6834) * 43;
+acc += Math.sin(6834) + Math.cos(6835) * 44;
+acc += Math.sin(6835) + Math.cos(6836) * 45;
+acc += Math.sin(6836) + Math.cos(6837) * 46;
+acc += Math.sin(6837) + Math.cos(6838) * 47;
+acc += Math.sin(6838) + Math.cos(6839) * 48;
+acc += Math.sin(6839) + Math.cos(6840) * 49;
+acc += Math.sin(6840) + Math.cos(6841) * 50;
+acc += Math.sin(6841) + Math.cos(6842) * 51;
+acc += Math.sin(6842) + Math.cos(6843) * 52;
+acc += Math.sin(6843) + Math.cos(6844) * 53;
+acc += Math.sin(6844) + Math.cos(6845) * 54;
+acc += Math.sin(6845) + Math.cos(6846) * 55;
+acc += Math.sin(6846) + Math.cos(6847) * 56;
+acc += Math.sin(6847) + Math.cos(6848) * 57;
+acc += Math.sin(6848) + Math.cos(6849) * 58;
+acc += Math.sin(6849) + Math.cos(6850) * 59;
+acc += Math.sin(6850) + Math.cos(6851) * 60;
+acc += Math.sin(6851) + Math.cos(6852) * 61;
+acc += Math.sin(6852) + Math.cos(6853) * 62;
+acc += Math.sin(6853) + Math.cos(6854) * 63;
+acc += Math.sin(6854) + Math.cos(6855) * 64;
+acc += Math.sin(6855) + Math.cos(6856) * 65;
+acc += Math.sin(6856) + Math.cos(6857) * 66;
+acc += Math.sin(6857) + Math.cos(6858) * 67;
+acc += Math.sin(6858) + Math.cos(6859) * 68;
+acc += Math.sin(6859) + Math.cos(6860) * 69;
+acc += Math.sin(6860) + Math.cos(6861) * 70;
+acc += Math.sin(6861) + Math.cos(6862) * 71;
+acc += Math.sin(6862) + Math.cos(6863) * 72;
+acc += Math.sin(6863) + Math.cos(6864) * 73;
+acc += Math.sin(6864) + Math.cos(6865) * 74;
+acc += Math.sin(6865) + Math.cos(6866) * 75;
+acc += Math.sin(6866) + Math.cos(6867) * 76;
+acc += Math.sin(6867) + Math.cos(6868) * 77;
+acc += Math.sin(6868) + Math.cos(6869) * 78;
+acc += Math.sin(6869) + Math.cos(6870) * 79;
+acc += Math.sin(6870) + Math.cos(6871) * 80;
+acc += Math.sin(6871) + Math.cos(6872) * 81;
+acc += Math.sin(6872) + Math.cos(6873) * 82;
+acc += Math.sin(6873) + Math.cos(6874) * 83;
+acc += Math.sin(6874) + Math.cos(6875) * 84;
+acc += Math.sin(6875) + Math.cos(6876) * 85;
+acc += Math.sin(6876) + Math.cos(6877) * 86;
+acc += Math.sin(6877) + Math.cos(6878) * 87;
+acc += Math.sin(6878) + Math.cos(6879) * 88;
+acc += Math.sin(6879) + Math.cos(6880) * 89;
+acc += Math.sin(6880) + Math.cos(6881) * 90;
+acc += Math.sin(6881) + Math.cos(6882) * 91;
+acc += Math.sin(6882) + Math.cos(6883) * 92;
+acc += Math.sin(6883) + Math.cos(6884) * 93;
+acc += Math.sin(6884) + Math.cos(6885) * 94;
+acc += Math.sin(6885) + Math.cos(6886) * 95;
+acc += Math.sin(6886) + Math.cos(6887) * 96;
+acc += Math.sin(6887) + Math.cos(6888) * 0;
+acc += Math.sin(6888) + Math.cos(6889) * 1;
+acc += Math.sin(6889) + Math.cos(6890) * 2;
+acc += Math.sin(6890) + Math.cos(6891) * 3;
+acc += Math.sin(6891) + Math.cos(6892) * 4;
+acc += Math.sin(6892) + Math.cos(6893) * 5;
+acc += Math.sin(6893) + Math.cos(6894) * 6;
+acc += Math.sin(6894) + Math.cos(6895) * 7;
+acc += Math.sin(6895) + Math.cos(6896) * 8;
+acc += Math.sin(6896) + Math.cos(6897) * 9;
+acc += Math.sin(6897) + Math.cos(6898) * 10;
+acc += Math.sin(6898) + Math.cos(6899) * 11;
+acc += Math.sin(6899) + Math.cos(6900) * 12;
+acc += Math.sin(6900) + Math.cos(6901) * 13;
+acc += Math.sin(6901) + Math.cos(6902) * 14;
+acc += Math.sin(6902) + Math.cos(6903) * 15;
+acc += Math.sin(6903) + Math.cos(6904) * 16;
+acc += Math.sin(6904) + Math.cos(6905) * 17;
+acc += Math.sin(6905) + Math.cos(6906) * 18;
+acc += Math.sin(6906) + Math.cos(6907) * 19;
+acc += Math.sin(6907) + Math.cos(6908) * 20;
+acc += Math.sin(6908) + Math.cos(6909) * 21;
+acc += Math.sin(6909) + Math.cos(6910) * 22;
+acc += Math.sin(6910) + Math.cos(6911) * 23;
+acc += Math.sin(6911) + Math.cos(6912) * 24;
+acc += Math.sin(6912) + Math.cos(6913) * 25;
+acc += Math.sin(6913) + Math.cos(6914) * 26;
+acc += Math.sin(6914) + Math.cos(6915) * 27;
+acc += Math.sin(6915) + Math.cos(6916) * 28;
+acc += Math.sin(6916) + Math.cos(6917) * 29;
+acc += Math.sin(6917) + Math.cos(6918) * 30;
+acc += Math.sin(6918) + Math.cos(6919) * 31;
+acc += Math.sin(6919) + Math.cos(6920) * 32;
+acc += Math.sin(6920) + Math.cos(6921) * 33;
+acc += Math.sin(6921) + Math.cos(6922) * 34;
+acc += Math.sin(6922) + Math.cos(6923) * 35;
+acc += Math.sin(6923) + Math.cos(6924) * 36;
+acc += Math.sin(6924) + Math.cos(6925) * 37;
+acc += Math.sin(6925) + Math.cos(6926) * 38;
+acc += Math.sin(6926) + Math.cos(6927) * 39;
+acc += Math.sin(6927) + Math.cos(6928) * 40;
+acc += Math.sin(6928) + Math.cos(6929) * 41;
+acc += Math.sin(6929) + Math.cos(6930) * 42;
+acc += Math.sin(6930) + Math.cos(6931) * 43;
+acc += Math.sin(6931) + Math.cos(6932) * 44;
+acc += Math.sin(6932) + Math.cos(6933) * 45;
+acc += Math.sin(6933) + Math.cos(6934) * 46;
+acc += Math.sin(6934) + Math.cos(6935) * 47;
+acc += Math.sin(6935) + Math.cos(6936) * 48;
+acc += Math.sin(6936) + Math.cos(6937) * 49;
+acc += Math.sin(6937) + Math.cos(6938) * 50;
+acc += Math.sin(6938) + Math.cos(6939) * 51;
+acc += Math.sin(6939) + Math.cos(6940) * 52;
+acc += Math.sin(6940) + Math.cos(6941) * 53;
+acc += Math.sin(6941) + Math.cos(6942) * 54;
+acc += Math.sin(6942) + Math.cos(6943) * 55;
+acc += Math.sin(6943) + Math.cos(6944) * 56;
+acc += Math.sin(6944) + Math.cos(6945) * 57;
+acc += Math.sin(6945) + Math.cos(6946) * 58;
+acc += Math.sin(6946) + Math.cos(6947) * 59;
+acc += Math.sin(6947) + Math.cos(6948) * 60;
+acc += Math.sin(6948) + Math.cos(6949) * 61;
+acc += Math.sin(6949) + Math.cos(6950) * 62;
+acc += Math.sin(6950) + Math.cos(6951) * 63;
+acc += Math.sin(6951) + Math.cos(6952) * 64;
+acc += Math.sin(6952) + Math.cos(6953) * 65;
+acc += Math.sin(6953) + Math.cos(6954) * 66;
+acc += Math.sin(6954) + Math.cos(6955) * 67;
+acc += Math.sin(6955) + Math.cos(6956) * 68;
+acc += Math.sin(6956) + Math.cos(6957) * 69;
+acc += Math.sin(6957) + Math.cos(6958) * 70;
+acc += Math.sin(6958) + Math.cos(6959) * 71;
+acc += Math.sin(6959) + Math.cos(6960) * 72;
+acc += Math.sin(6960) + Math.cos(6961) * 73;
+acc += Math.sin(6961) + Math.cos(6962) * 74;
+acc += Math.sin(6962) + Math.cos(6963) * 75;
+acc += Math.sin(6963) + Math.cos(6964) * 76;
+acc += Math.sin(6964) + Math.cos(6965) * 77;
+acc += Math.sin(6965) + Math.cos(6966) * 78;
+acc += Math.sin(6966) + Math.cos(6967) * 79;
+acc += Math.sin(6967) + Math.cos(6968) * 80;
+acc += Math.sin(6968) + Math.cos(6969) * 81;
+acc += Math.sin(6969) + Math.cos(6970) * 82;
+acc += Math.sin(6970) + Math.cos(6971) * 83;
+acc += Math.sin(6971) + Math.cos(6972) * 84;
+acc += Math.sin(6972) + Math.cos(6973) * 85;
+acc += Math.sin(6973) + Math.cos(6974) * 86;
+acc += Math.sin(6974) + Math.cos(6975) * 87;
+acc += Math.sin(6975) + Math.cos(6976) * 88;
+acc += Math.sin(6976) + Math.cos(6977) * 89;
+acc += Math.sin(6977) + Math.cos(6978) * 90;
+acc += Math.sin(6978) + Math.cos(6979) * 91;
+acc += Math.sin(6979) + Math.cos(6980) * 92;
+acc += Math.sin(6980) + Math.cos(6981) * 93;
+acc += Math.sin(6981) + Math.cos(6982) * 94;
+acc += Math.sin(6982) + Math.cos(6983) * 95;
+acc += Math.sin(6983) + Math.cos(6984) * 96;
+acc += Math.sin(6984) + Math.cos(6985) * 0;
+acc += Math.sin(6985) + Math.cos(6986) * 1;
+acc += Math.sin(6986) + Math.cos(6987) * 2;
+acc += Math.sin(6987) + Math.cos(6988) * 3;
+acc += Math.sin(6988) + Math.cos(6989) * 4;
+acc += Math.sin(6989) + Math.cos(6990) * 5;
+acc += Math.sin(6990) + Math.cos(6991) * 6;
+acc += Math.sin(6991) + Math.cos(6992) * 7;
+acc += Math.sin(6992) + Math.cos(6993) * 8;
+acc += Math.sin(6993) + Math.cos(6994) * 9;
+acc += Math.sin(6994) + Math.cos(6995) * 10;
+acc += Math.sin(6995) + Math.cos(6996) * 11;
+acc += Math.sin(6996) + Math.cos(6997) * 12;
+acc += Math.sin(6997) + Math.cos(6998) * 13;
+acc += Math.sin(6998) + Math.cos(6999) * 14;
+acc += Math.sin(6999) + Math.cos(7000) * 15;
+acc += Math.sin(7000) + Math.cos(7001) * 16;
+acc += Math.sin(7001) + Math.cos(7002) * 17;
+acc += Math.sin(7002) + Math.cos(7003) * 18;
+acc += Math.sin(7003) + Math.cos(7004) * 19;
+acc += Math.sin(7004) + Math.cos(7005) * 20;
+acc += Math.sin(7005) + Math.cos(7006) * 21;
+acc += Math.sin(7006) + Math.cos(7007) * 22;
+acc += Math.sin(7007) + Math.cos(7008) * 23;
+acc += Math.sin(7008) + Math.cos(7009) * 24;
+acc += Math.sin(7009) + Math.cos(7010) * 25;
+acc += Math.sin(7010) + Math.cos(7011) * 26;
+acc += Math.sin(7011) + Math.cos(7012) * 27;
+acc += Math.sin(7012) + Math.cos(7013) * 28;
+acc += Math.sin(7013) + Math.cos(7014) * 29;
+acc += Math.sin(7014) + Math.cos(7015) * 30;
+acc += Math.sin(7015) + Math.cos(7016) * 31;
+acc += Math.sin(7016) + Math.cos(7017) * 32;
+acc += Math.sin(7017) + Math.cos(7018) * 33;
+acc += Math.sin(7018) + Math.cos(7019) * 34;
+acc += Math.sin(7019) + Math.cos(7020) * 35;
+acc += Math.sin(7020) + Math.cos(7021) * 36;
+acc += Math.sin(7021) + Math.cos(7022) * 37;
+acc += Math.sin(7022) + Math.cos(7023) * 38;
+acc += Math.sin(7023) + Math.cos(7024) * 39;
+acc += Math.sin(7024) + Math.cos(7025) * 40;
+acc += Math.sin(7025) + Math.cos(7026) * 41;
+acc += Math.sin(7026) + Math.cos(7027) * 42;
+acc += Math.sin(7027) + Math.cos(7028) * 43;
+acc += Math.sin(7028) + Math.cos(7029) * 44;
+acc += Math.sin(7029) + Math.cos(7030) * 45;
+acc += Math.sin(7030) + Math.cos(7031) * 46;
+acc += Math.sin(7031) + Math.cos(7032) * 47;
+acc += Math.sin(7032) + Math.cos(7033) * 48;
+acc += Math.sin(7033) + Math.cos(7034) * 49;
+acc += Math.sin(7034) + Math.cos(7035) * 50;
+acc += Math.sin(7035) + Math.cos(7036) * 51;
+acc += Math.sin(7036) + Math.cos(7037) * 52;
+acc += Math.sin(7037) + Math.cos(7038) * 53;
+acc += Math.sin(7038) + Math.cos(7039) * 54;
+acc += Math.sin(7039) + Math.cos(7040) * 55;
+acc += Math.sin(7040) + Math.cos(7041) * 56;
+acc += Math.sin(7041) + Math.cos(7042) * 57;
+acc += Math.sin(7042) + Math.cos(7043) * 58;
+acc += Math.sin(7043) + Math.cos(7044) * 59;
+acc += Math.sin(7044) + Math.cos(7045) * 60;
+acc += Math.sin(7045) + Math.cos(7046) * 61;
+acc += Math.sin(7046) + Math.cos(7047) * 62;
+acc += Math.sin(7047) + Math.cos(7048) * 63;
+acc += Math.sin(7048) + Math.cos(7049) * 64;
+acc += Math.sin(7049) + Math.cos(7050) * 65;
+acc += Math.sin(7050) + Math.cos(7051) * 66;
+acc += Math.sin(7051) + Math.cos(7052) * 67;
+acc += Math.sin(7052) + Math.cos(7053) * 68;
+acc += Math.sin(7053) + Math.cos(7054) * 69;
+acc += Math.sin(7054) + Math.cos(7055) * 70;
+acc += Math.sin(7055) + Math.cos(7056) * 71;
+acc += Math.sin(7056) + Math.cos(7057) * 72;
+acc += Math.sin(7057) + Math.cos(7058) * 73;
+acc += Math.sin(7058) + Math.cos(7059) * 74;
+acc += Math.sin(7059) + Math.cos(7060) * 75;
+acc += Math.sin(7060) + Math.cos(7061) * 76;
+acc += Math.sin(7061) + Math.cos(7062) * 77;
+acc += Math.sin(7062) + Math.cos(7063) * 78;
+acc += Math.sin(7063) + Math.cos(7064) * 79;
+acc += Math.sin(7064) + Math.cos(7065) * 80;
+acc += Math.sin(7065) + Math.cos(7066) * 81;
+acc += Math.sin(7066) + Math.cos(7067) * 82;
+acc += Math.sin(7067) + Math.cos(7068) * 83;
+acc += Math.sin(7068) + Math.cos(7069) * 84;
+acc += Math.sin(7069) + Math.cos(7070) * 85;
+acc += Math.sin(7070) + Math.cos(7071) * 86;
+acc += Math.sin(7071) + Math.cos(7072) * 87;
+acc += Math.sin(7072) + Math.cos(7073) * 88;
+acc += Math.sin(7073) + Math.cos(7074) * 89;
+acc += Math.sin(7074) + Math.cos(7075) * 90;
+acc += Math.sin(7075) + Math.cos(7076) * 91;
+acc += Math.sin(7076) + Math.cos(7077) * 92;
+acc += Math.sin(7077) + Math.cos(7078) * 93;
+acc += Math.sin(7078) + Math.cos(7079) * 94;
+acc += Math.sin(7079) + Math.cos(7080) * 95;
+acc += Math.sin(7080) + Math.cos(7081) * 96;
+acc += Math.sin(7081) + Math.cos(7082) * 0;
+acc += Math.sin(7082) + Math.cos(7083) * 1;
+acc += Math.sin(7083) + Math.cos(7084) * 2;
+acc += Math.sin(7084) + Math.cos(7085) * 3;
+acc += Math.sin(7085) + Math.cos(7086) * 4;
+acc += Math.sin(7086) + Math.cos(7087) * 5;
+acc += Math.sin(7087) + Math.cos(7088) * 6;
+acc += Math.sin(7088) + Math.cos(7089) * 7;
+acc += Math.sin(7089) + Math.cos(7090) * 8;
+acc += Math.sin(7090) + Math.cos(7091) * 9;
+acc += Math.sin(7091) + Math.cos(7092) * 10;
+acc += Math.sin(7092) + Math.cos(7093) * 11;
+acc += Math.sin(7093) + Math.cos(7094) * 12;
+acc += Math.sin(7094) + Math.cos(7095) * 13;
+acc += Math.sin(7095) + Math.cos(7096) * 14;
+acc += Math.sin(7096) + Math.cos(7097) * 15;
+acc += Math.sin(7097) + Math.cos(7098) * 16;
+acc += Math.sin(7098) + Math.cos(7099) * 17;
+acc += Math.sin(7099) + Math.cos(7100) * 18;
+acc += Math.sin(7100) + Math.cos(7101) * 19;
+acc += Math.sin(7101) + Math.cos(7102) * 20;
+acc += Math.sin(7102) + Math.cos(7103) * 21;
+acc += Math.sin(7103) + Math.cos(7104) * 22;
+acc += Math.sin(7104) + Math.cos(7105) * 23;
+acc += Math.sin(7105) + Math.cos(7106) * 24;
+acc += Math.sin(7106) + Math.cos(7107) * 25;
+acc += Math.sin(7107) + Math.cos(7108) * 26;
+acc += Math.sin(7108) + Math.cos(7109) * 27;
+acc += Math.sin(7109) + Math.cos(7110) * 28;
+acc += Math.sin(7110) + Math.cos(7111) * 29;
+acc += Math.sin(7111) + Math.cos(7112) * 30;
+acc += Math.sin(7112) + Math.cos(7113) * 31;
+acc += Math.sin(7113) + Math.cos(7114) * 32;
+acc += Math.sin(7114) + Math.cos(7115) * 33;
+acc += Math.sin(7115) + Math.cos(7116) * 34;
+acc += Math.sin(7116) + Math.cos(7117) * 35;
+acc += Math.sin(7117) + Math.cos(7118) * 36;
+acc += Math.sin(7118) + Math.cos(7119) * 37;
+acc += Math.sin(7119) + Math.cos(7120) * 38;
+acc += Math.sin(7120) + Math.cos(7121) * 39;
+acc += Math.sin(7121) + Math.cos(7122) * 40;
+acc += Math.sin(7122) + Math.cos(7123) * 41;
+acc += Math.sin(7123) + Math.cos(7124) * 42;
+acc += Math.sin(7124) + Math.cos(7125) * 43;
+acc += Math.sin(7125) + Math.cos(7126) * 44;
+acc += Math.sin(7126) + Math.cos(7127) * 45;
+acc += Math.sin(7127) + Math.cos(7128) * 46;
+acc += Math.sin(7128) + Math.cos(7129) * 47;
+acc += Math.sin(7129) + Math.cos(7130) * 48;
+acc += Math.sin(7130) + Math.cos(7131) * 49;
+acc += Math.sin(7131) + Math.cos(7132) * 50;
+acc += Math.sin(7132) + Math.cos(7133) * 51;
+acc += Math.sin(7133) + Math.cos(7134) * 52;
+acc += Math.sin(7134) + Math.cos(7135) * 53;
+acc += Math.sin(7135) + Math.cos(7136) * 54;
+acc += Math.sin(7136) + Math.cos(7137) * 55;
+acc += Math.sin(7137) + Math.cos(7138) * 56;
+acc += Math.sin(7138) + Math.cos(7139) * 57;
+acc += Math.sin(7139) + Math.cos(7140) * 58;
+acc += Math.sin(7140) + Math.cos(7141) * 59;
+acc += Math.sin(7141) + Math.cos(7142) * 60;
+acc += Math.sin(7142) + Math.cos(7143) * 61;
+acc += Math.sin(7143) + Math.cos(7144) * 62;
+acc += Math.sin(7144) + Math.cos(7145) * 63;
+acc += Math.sin(7145) + Math.cos(7146) * 64;
+acc += Math.sin(7146) + Math.cos(7147) * 65;
+acc += Math.sin(7147) + Math.cos(7148) * 66;
+acc += Math.sin(7148) + Math.cos(7149) * 67;
+acc += Math.sin(7149) + Math.cos(7150) * 68;
+acc += Math.sin(7150) + Math.cos(7151) * 69;
+acc += Math.sin(7151) + Math.cos(7152) * 70;
+acc += Math.sin(7152) + Math.cos(7153) * 71;
+acc += Math.sin(7153) + Math.cos(7154) * 72;
+acc += Math.sin(7154) + Math.cos(7155) * 73;
+acc += Math.sin(7155) + Math.cos(7156) * 74;
+acc += Math.sin(7156) + Math.cos(7157) * 75;
+acc += Math.sin(7157) + Math.cos(7158) * 76;
+acc += Math.sin(7158) + Math.cos(7159) * 77;
+acc += Math.sin(7159) + Math.cos(7160) * 78;
+acc += Math.sin(7160) + Math.cos(7161) * 79;
+acc += Math.sin(7161) + Math.cos(7162) * 80;
+acc += Math.sin(7162) + Math.cos(7163) * 81;
+acc += Math.sin(7163) + Math.cos(7164) * 82;
+acc += Math.sin(7164) + Math.cos(7165) * 83;
+acc += Math.sin(7165) + Math.cos(7166) * 84;
+acc += Math.sin(7166) + Math.cos(7167) * 85;
+acc += Math.sin(7167) + Math.cos(7168) * 86;
+acc += Math.sin(7168) + Math.cos(7169) * 87;
+acc += Math.sin(7169) + Math.cos(7170) * 88;
+acc += Math.sin(7170) + Math.cos(7171) * 89;
+acc += Math.sin(7171) + Math.cos(7172) * 90;
+acc += Math.sin(7172) + Math.cos(7173) * 91;
+acc += Math.sin(7173) + Math.cos(7174) * 92;
+acc += Math.sin(7174) + Math.cos(7175) * 93;
+acc += Math.sin(7175) + Math.cos(7176) * 94;
+acc += Math.sin(7176) + Math.cos(7177) * 95;
+acc += Math.sin(7177) + Math.cos(7178) * 96;
+acc += Math.sin(7178) + Math.cos(7179) * 0;
+acc += Math.sin(7179) + Math.cos(7180) * 1;
+acc += Math.sin(7180) + Math.cos(7181) * 2;
+acc += Math.sin(7181) + Math.cos(7182) * 3;
+acc += Math.sin(7182) + Math.cos(7183) * 4;
+acc += Math.sin(7183) + Math.cos(7184) * 5;
+acc += Math.sin(7184) + Math.cos(7185) * 6;
+acc += Math.sin(7185) + Math.cos(7186) * 7;
+acc += Math.sin(7186) + Math.cos(7187) * 8;
+acc += Math.sin(7187) + Math.cos(7188) * 9;
+acc += Math.sin(7188) + Math.cos(7189) * 10;
+acc += Math.sin(7189) + Math.cos(7190) * 11;
+acc += Math.sin(7190) + Math.cos(7191) * 12;
+acc += Math.sin(7191) + Math.cos(7192) * 13;
+acc += Math.sin(7192) + Math.cos(7193) * 14;
+acc += Math.sin(7193) + Math.cos(7194) * 15;
+acc += Math.sin(7194) + Math.cos(7195) * 16;
+acc += Math.sin(7195) + Math.cos(7196) * 17;
+acc += Math.sin(7196) + Math.cos(7197) * 18;
+acc += Math.sin(7197) + Math.cos(7198) * 19;
+acc += Math.sin(7198) + Math.cos(7199) * 20;
+acc += Math.sin(7199) + Math.cos(7200) * 21;
+acc += Math.sin(7200) + Math.cos(7201) * 22;
+acc += Math.sin(7201) + Math.cos(7202) * 23;
+acc += Math.sin(7202) + Math.cos(7203) * 24;
+acc += Math.sin(7203) + Math.cos(7204) * 25;
+acc += Math.sin(7204) + Math.cos(7205) * 26;
+acc += Math.sin(7205) + Math.cos(7206) * 27;
+acc += Math.sin(7206) + Math.cos(7207) * 28;
+acc += Math.sin(7207) + Math.cos(7208) * 29;
+acc += Math.sin(7208) + Math.cos(7209) * 30;
+acc += Math.sin(7209) + Math.cos(7210) * 31;
+acc += Math.sin(7210) + Math.cos(7211) * 32;
+acc += Math.sin(7211) + Math.cos(7212) * 33;
+acc += Math.sin(7212) + Math.cos(7213) * 34;
+acc += Math.sin(7213) + Math.cos(7214) * 35;
+acc += Math.sin(7214) + Math.cos(7215) * 36;
+acc += Math.sin(7215) + Math.cos(7216) * 37;
+acc += Math.sin(7216) + Math.cos(7217) * 38;
+acc += Math.sin(7217) + Math.cos(7218) * 39;
+acc += Math.sin(7218) + Math.cos(7219) * 40;
+acc += Math.sin(7219) + Math.cos(7220) * 41;
+acc += Math.sin(7220) + Math.cos(7221) * 42;
+acc += Math.sin(7221) + Math.cos(7222) * 43;
+acc += Math.sin(7222) + Math.cos(7223) * 44;
+acc += Math.sin(7223) + Math.cos(7224) * 45;
+acc += Math.sin(7224) + Math.cos(7225) * 46;
+acc += Math.sin(7225) + Math.cos(7226) * 47;
+acc += Math.sin(7226) + Math.cos(7227) * 48;
+acc += Math.sin(7227) + Math.cos(7228) * 49;
+acc += Math.sin(7228) + Math.cos(7229) * 50;
+acc += Math.sin(7229) + Math.cos(7230) * 51;
+acc += Math.sin(7230) + Math.cos(7231) * 52;
+acc += Math.sin(7231) + Math.cos(7232) * 53;
+acc += Math.sin(7232) + Math.cos(7233) * 54;
+acc += Math.sin(7233) + Math.cos(7234) * 55;
+acc += Math.sin(7234) + Math.cos(7235) * 56;
+acc += Math.sin(7235) + Math.cos(7236) * 57;
+acc += Math.sin(7236) + Math.cos(7237) * 58;
+acc += Math.sin(7237) + Math.cos(7238) * 59;
+acc += Math.sin(7238) + Math.cos(7239) * 60;
+acc += Math.sin(7239) + Math.cos(7240) * 61;
+acc += Math.sin(7240) + Math.cos(7241) * 62;
+acc += Math.sin(7241) + Math.cos(7242) * 63;
+acc += Math.sin(7242) + Math.cos(7243) * 64;
+acc += Math.sin(7243) + Math.cos(7244) * 65;
+acc += Math.sin(7244) + Math.cos(7245) * 66;
+acc += Math.sin(7245) + Math.cos(7246) * 67;
+acc += Math.sin(7246) + Math.cos(7247) * 68;
+acc += Math.sin(7247) + Math.cos(7248) * 69;
+acc += Math.sin(7248) + Math.cos(7249) * 70;
+acc += Math.sin(7249) + Math.cos(7250) * 71;
+acc += Math.sin(7250) + Math.cos(7251) * 72;
+acc += Math.sin(7251) + Math.cos(7252) * 73;
+acc += Math.sin(7252) + Math.cos(7253) * 74;
+acc += Math.sin(7253) + Math.cos(7254) * 75;
+acc += Math.sin(7254) + Math.cos(7255) * 76;
+acc += Math.sin(7255) + Math.cos(7256) * 77;
+acc += Math.sin(7256) + Math.cos(7257) * 78;
+acc += Math.sin(7257) + Math.cos(7258) * 79;
+acc += Math.sin(7258) + Math.cos(7259) * 80;
+acc += Math.sin(7259) + Math.cos(7260) * 81;
+acc += Math.sin(7260) + Math.cos(7261) * 82;
+acc += Math.sin(7261) + Math.cos(7262) * 83;
+acc += Math.sin(7262) + Math.cos(7263) * 84;
+acc += Math.sin(7263) + Math.cos(7264) * 85;
+acc += Math.sin(7264) + Math.cos(7265) * 86;
+acc += Math.sin(7265) + Math.cos(7266) * 87;
+acc += Math.sin(7266) + Math.cos(7267) * 88;
+acc += Math.sin(7267) + Math.cos(7268) * 89;
+acc += Math.sin(7268) + Math.cos(7269) * 90;
+acc += Math.sin(7269) + Math.cos(7270) * 91;
+acc += Math.sin(7270) + Math.cos(7271) * 92;
+acc += Math.sin(7271) + Math.cos(7272) * 93;
+acc += Math.sin(7272) + Math.cos(7273) * 94;
+acc += Math.sin(7273) + Math.cos(7274) * 95;
+acc += Math.sin(7274) + Math.cos(7275) * 96;
+acc += Math.sin(7275) + Math.cos(7276) * 0;
+acc += Math.sin(7276) + Math.cos(7277) * 1;
+acc += Math.sin(7277) + Math.cos(7278) * 2;
+acc += Math.sin(7278) + Math.cos(7279) * 3;
+acc += Math.sin(7279) + Math.cos(7280) * 4;
+acc += Math.sin(7280) + Math.cos(7281) * 5;
+acc += Math.sin(7281) + Math.cos(7282) * 6;
+acc += Math.sin(7282) + Math.cos(7283) * 7;
+acc += Math.sin(7283) + Math.cos(7284) * 8;
+acc += Math.sin(7284) + Math.cos(7285) * 9;
+acc += Math.sin(7285) + Math.cos(7286) * 10;
+acc += Math.sin(7286) + Math.cos(7287) * 11;
+acc += Math.sin(7287) + Math.cos(7288) * 12;
+acc += Math.sin(7288) + Math.cos(7289) * 13;
+acc += Math.sin(7289) + Math.cos(7290) * 14;
+acc += Math.sin(7290) + Math.cos(7291) * 15;
+acc += Math.sin(7291) + Math.cos(7292) * 16;
+acc += Math.sin(7292) + Math.cos(7293) * 17;
+acc += Math.sin(7293) + Math.cos(7294) * 18;
+acc += Math.sin(7294) + Math.cos(7295) * 19;
+acc += Math.sin(7295) + Math.cos(7296) * 20;
+acc += Math.sin(7296) + Math.cos(7297) * 21;
+acc += Math.sin(7297) + Math.cos(7298) * 22;
+acc += Math.sin(7298) + Math.cos(7299) * 23;
+acc += Math.sin(7299) + Math.cos(7300) * 24;
+acc += Math.sin(7300) + Math.cos(7301) * 25;
+acc += Math.sin(7301) + Math.cos(7302) * 26;
+acc += Math.sin(7302) + Math.cos(7303) * 27;
+acc += Math.sin(7303) + Math.cos(7304) * 28;
+acc += Math.sin(7304) + Math.cos(7305) * 29;
+acc += Math.sin(7305) + Math.cos(7306) * 30;
+acc += Math.sin(7306) + Math.cos(7307) * 31;
+acc += Math.sin(7307) + Math.cos(7308) * 32;
+acc += Math.sin(7308) + Math.cos(7309) * 33;
+acc += Math.sin(7309) + Math.cos(7310) * 34;
+acc += Math.sin(7310) + Math.cos(7311) * 35;
+acc += Math.sin(7311) + Math.cos(7312) * 36;
+acc += Math.sin(7312) + Math.cos(7313) * 37;
+acc += Math.sin(7313) + Math.cos(7314) * 38;
+acc += Math.sin(7314) + Math.cos(7315) * 39;
+acc += Math.sin(7315) + Math.cos(7316) * 40;
+acc += Math.sin(7316) + Math.cos(7317) * 41;
+acc += Math.sin(7317) + Math.cos(7318) * 42;
+acc += Math.sin(7318) + Math.cos(7319) * 43;
+acc += Math.sin(7319) + Math.cos(7320) * 44;
+acc += Math.sin(7320) + Math.cos(7321) * 45;
+acc += Math.sin(7321) + Math.cos(7322) * 46;
+acc += Math.sin(7322) + Math.cos(7323) * 47;
+acc += Math.sin(7323) + Math.cos(7324) * 48;
+acc += Math.sin(7324) + Math.cos(7325) * 49;
+acc += Math.sin(7325) + Math.cos(7326) * 50;
+acc += Math.sin(7326) + Math.cos(7327) * 51;
+acc += Math.sin(7327) + Math.cos(7328) * 52;
+acc += Math.sin(7328) + Math.cos(7329) * 53;
+acc += Math.sin(7329) + Math.cos(7330) * 54;
+acc += Math.sin(7330) + Math.cos(7331) * 55;
+acc += Math.sin(7331) + Math.cos(7332) * 56;
+acc += Math.sin(7332) + Math.cos(7333) * 57;
+acc += Math.sin(7333) + Math.cos(7334) * 58;
+acc += Math.sin(7334) + Math.cos(7335) * 59;
+acc += Math.sin(7335) + Math.cos(7336) * 60;
+acc += Math.sin(7336) + Math.cos(7337) * 61;
+acc += Math.sin(7337) + Math.cos(7338) * 62;
+acc += Math.sin(7338) + Math.cos(7339) * 63;
+acc += Math.sin(7339) + Math.cos(7340) * 64;
+acc += Math.sin(7340) + Math.cos(7341) * 65;
+acc += Math.sin(7341) + Math.cos(7342) * 66;
+acc += Math.sin(7342) + Math.cos(7343) * 67;
+acc += Math.sin(7343) + Math.cos(7344) * 68;
+acc += Math.sin(7344) + Math.cos(7345) * 69;
+acc += Math.sin(7345) + Math.cos(7346) * 70;
+acc += Math.sin(7346) + Math.cos(7347) * 71;
+acc += Math.sin(7347) + Math.cos(7348) * 72;
+acc += Math.sin(7348) + Math.cos(7349) * 73;
+acc += Math.sin(7349) + Math.cos(7350) * 74;
+acc += Math.sin(7350) + Math.cos(7351) * 75;
+acc += Math.sin(7351) + Math.cos(7352) * 76;
+acc += Math.sin(7352) + Math.cos(7353) * 77;
+acc += Math.sin(7353) + Math.cos(7354) * 78;
+acc += Math.sin(7354) + Math.cos(7355) * 79;
+acc += Math.sin(7355) + Math.cos(7356) * 80;
+acc += Math.sin(7356) + Math.cos(7357) * 81;
+acc += Math.sin(7357) + Math.cos(7358) * 82;
+acc += Math.sin(7358) + Math.cos(7359) * 83;
+acc += Math.sin(7359) + Math.cos(7360) * 84;
+acc += Math.sin(7360) + Math.cos(7361) * 85;
+acc += Math.sin(7361) + Math.cos(7362) * 86;
+acc += Math.sin(7362) + Math.cos(7363) * 87;
+acc += Math.sin(7363) + Math.cos(7364) * 88;
+acc += Math.sin(7364) + Math.cos(7365) * 89;
+acc += Math.sin(7365) + Math.cos(7366) * 90;
+acc += Math.sin(7366) + Math.cos(7367) * 91;
+acc += Math.sin(7367) + Math.cos(7368) * 92;
+acc += Math.sin(7368) + Math.cos(7369) * 93;
+acc += Math.sin(7369) + Math.cos(7370) * 94;
+acc += Math.sin(7370) + Math.cos(7371) * 95;
+acc += Math.sin(7371) + Math.cos(7372) * 96;
+acc += Math.sin(7372) + Math.cos(7373) * 0;
+acc += Math.sin(7373) + Math.cos(7374) * 1;
+acc += Math.sin(7374) + Math.cos(7375) * 2;
+acc += Math.sin(7375) + Math.cos(7376) * 3;
+acc += Math.sin(7376) + Math.cos(7377) * 4;
+acc += Math.sin(7377) + Math.cos(7378) * 5;
+acc += Math.sin(7378) + Math.cos(7379) * 6;
+acc += Math.sin(7379) + Math.cos(7380) * 7;
+acc += Math.sin(7380) + Math.cos(7381) * 8;
+acc += Math.sin(7381) + Math.cos(7382) * 9;
+acc += Math.sin(7382) + Math.cos(7383) * 10;
+acc += Math.sin(7383) + Math.cos(7384) * 11;
+acc += Math.sin(7384) + Math.cos(7385) * 12;
+acc += Math.sin(7385) + Math.cos(7386) * 13;
+acc += Math.sin(7386) + Math.cos(7387) * 14;
+acc += Math.sin(7387) + Math.cos(7388) * 15;
+acc += Math.sin(7388) + Math.cos(7389) * 16;
+acc += Math.sin(7389) + Math.cos(7390) * 17;
+acc += Math.sin(7390) + Math.cos(7391) * 18;
+acc += Math.sin(7391) + Math.cos(7392) * 19;
+acc += Math.sin(7392) + Math.cos(7393) * 20;
+acc += Math.sin(7393) + Math.cos(7394) * 21;
+acc += Math.sin(7394) + Math.cos(7395) * 22;
+acc += Math.sin(7395) + Math.cos(7396) * 23;
+acc += Math.sin(7396) + Math.cos(7397) * 24;
+acc += Math.sin(7397) + Math.cos(7398) * 25;
+acc += Math.sin(7398) + Math.cos(7399) * 26;
+acc += Math.sin(7399) + Math.cos(7400) * 27;
+acc += Math.sin(7400) + Math.cos(7401) * 28;
+acc += Math.sin(7401) + Math.cos(7402) * 29;
+acc += Math.sin(7402) + Math.cos(7403) * 30;
+acc += Math.sin(7403) + Math.cos(7404) * 31;
+acc += Math.sin(7404) + Math.cos(7405) * 32;
+acc += Math.sin(7405) + Math.cos(7406) * 33;
+acc += Math.sin(7406) + Math.cos(7407) * 34;
+acc += Math.sin(7407) + Math.cos(7408) * 35;
+acc += Math.sin(7408) + Math.cos(7409) * 36;
+acc += Math.sin(7409) + Math.cos(7410) * 37;
+acc += Math.sin(7410) + Math.cos(7411) * 38;
+acc += Math.sin(7411) + Math.cos(7412) * 39;
+acc += Math.sin(7412) + Math.cos(7413) * 40;
+acc += Math.sin(7413) + Math.cos(7414) * 41;
+acc += Math.sin(7414) + Math.cos(7415) * 42;
+acc += Math.sin(7415) + Math.cos(7416) * 43;
+acc += Math.sin(7416) + Math.cos(7417) * 44;
+acc += Math.sin(7417) + Math.cos(7418) * 45;
+acc += Math.sin(7418) + Math.cos(7419) * 46;
+acc += Math.sin(7419) + Math.cos(7420) * 47;
+acc += Math.sin(7420) + Math.cos(7421) * 48;
+acc += Math.sin(7421) + Math.cos(7422) * 49;
+acc += Math.sin(7422) + Math.cos(7423) * 50;
+acc += Math.sin(7423) + Math.cos(7424) * 51;
+acc += Math.sin(7424) + Math.cos(7425) * 52;
+acc += Math.sin(7425) + Math.cos(7426) * 53;
+acc += Math.sin(7426) + Math.cos(7427) * 54;
+acc += Math.sin(7427) + Math.cos(7428) * 55;
+acc += Math.sin(7428) + Math.cos(7429) * 56;
+acc += Math.sin(7429) + Math.cos(7430) * 57;
+acc += Math.sin(7430) + Math.cos(7431) * 58;
+acc += Math.sin(7431) + Math.cos(7432) * 59;
+acc += Math.sin(7432) + Math.cos(7433) * 60;
+acc += Math.sin(7433) + Math.cos(7434) * 61;
+acc += Math.sin(7434) + Math.cos(7435) * 62;
+acc += Math.sin(7435) + Math.cos(7436) * 63;
+acc += Math.sin(7436) + Math.cos(7437) * 64;
+acc += Math.sin(7437) + Math.cos(7438) * 65;
+acc += Math.sin(7438) + Math.cos(7439) * 66;
+acc += Math.sin(7439) + Math.cos(7440) * 67;
+acc += Math.sin(7440) + Math.cos(7441) * 68;
+acc += Math.sin(7441) + Math.cos(7442) * 69;
+acc += Math.sin(7442) + Math.cos(7443) * 70;
+acc += Math.sin(7443) + Math.cos(7444) * 71;
+acc += Math.sin(7444) + Math.cos(7445) * 72;
+acc += Math.sin(7445) + Math.cos(7446) * 73;
+acc += Math.sin(7446) + Math.cos(7447) * 74;
+acc += Math.sin(7447) + Math.cos(7448) * 75;
+acc += Math.sin(7448) + Math.cos(7449) * 76;
+acc += Math.sin(7449) + Math.cos(7450) * 77;
+acc += Math.sin(7450) + Math.cos(7451) * 78;
+acc += Math.sin(7451) + Math.cos(7452) * 79;
+acc += Math.sin(7452) + Math.cos(7453) * 80;
+acc += Math.sin(7453) + Math.cos(7454) * 81;
+acc += Math.sin(7454) + Math.cos(7455) * 82;
+acc += Math.sin(7455) + Math.cos(7456) * 83;
+acc += Math.sin(7456) + Math.cos(7457) * 84;
+acc += Math.sin(7457) + Math.cos(7458) * 85;
+acc += Math.sin(7458) + Math.cos(7459) * 86;
+acc += Math.sin(7459) + Math.cos(7460) * 87;
+acc += Math.sin(7460) + Math.cos(7461) * 88;
+acc += Math.sin(7461) + Math.cos(7462) * 89;
+acc += Math.sin(7462) + Math.cos(7463) * 90;
+acc += Math.sin(7463) + Math.cos(7464) * 91;
+acc += Math.sin(7464) + Math.cos(7465) * 92;
+acc += Math.sin(7465) + Math.cos(7466) * 93;
+acc += Math.sin(7466) + Math.cos(7467) * 94;
+acc += Math.sin(7467) + Math.cos(7468) * 95;
+acc += Math.sin(7468) + Math.cos(7469) * 96;
+acc += Math.sin(7469) + Math.cos(7470) * 0;
+acc += Math.sin(7470) + Math.cos(7471) * 1;
+acc += Math.sin(7471) + Math.cos(7472) * 2;
+acc += Math.sin(7472) + Math.cos(7473) * 3;
+acc += Math.sin(7473) + Math.cos(7474) * 4;
+acc += Math.sin(7474) + Math.cos(7475) * 5;
+acc += Math.sin(7475) + Math.cos(7476) * 6;
+acc += Math.sin(7476) + Math.cos(7477) * 7;
+acc += Math.sin(7477) + Math.cos(7478) * 8;
+acc += Math.sin(7478) + Math.cos(7479) * 9;
+acc += Math.sin(7479) + Math.cos(7480) * 10;
+acc += Math.sin(7480) + Math.cos(7481) * 11;
+acc += Math.sin(7481) + Math.cos(7482) * 12;
+acc += Math.sin(7482) + Math.cos(7483) * 13;
+acc += Math.sin(7483) + Math.cos(7484) * 14;
+acc += Math.sin(7484) + Math.cos(7485) * 15;
+acc += Math.sin(7485) + Math.cos(7486) * 16;
+acc += Math.sin(7486) + Math.cos(7487) * 17;
+acc += Math.sin(7487) + Math.cos(7488) * 18;
+acc += Math.sin(7488) + Math.cos(7489) * 19;
+acc += Math.sin(7489) + Math.cos(7490) * 20;
+acc += Math.sin(7490) + Math.cos(7491) * 21;
+acc += Math.sin(7491) + Math.cos(7492) * 22;
+acc += Math.sin(7492) + Math.cos(7493) * 23;
+acc += Math.sin(7493) + Math.cos(7494) * 24;
+acc += Math.sin(7494) + Math.cos(7495) * 25;
+acc += Math.sin(7495) + Math.cos(7496) * 26;
+acc += Math.sin(7496) + Math.cos(7497) * 27;
+acc += Math.sin(7497) + Math.cos(7498) * 28;
+acc += Math.sin(7498) + Math.cos(7499) * 29;
+acc += Math.sin(7499) + Math.cos(7500) * 30;
+acc += Math.sin(7500) + Math.cos(7501) * 31;
+acc += Math.sin(7501) + Math.cos(7502) * 32;
+acc += Math.sin(7502) + Math.cos(7503) * 33;
+acc += Math.sin(7503) + Math.cos(7504) * 34;
+acc += Math.sin(7504) + Math.cos(7505) * 35;
+acc += Math.sin(7505) + Math.cos(7506) * 36;
+acc += Math.sin(7506) + Math.cos(7507) * 37;
+acc += Math.sin(7507) + Math.cos(7508) * 38;
+acc += Math.sin(7508) + Math.cos(7509) * 39;
+acc += Math.sin(7509) + Math.cos(7510) * 40;
+acc += Math.sin(7510) + Math.cos(7511) * 41;
+acc += Math.sin(7511) + Math.cos(7512) * 42;
+acc += Math.sin(7512) + Math.cos(7513) * 43;
+acc += Math.sin(7513) + Math.cos(7514) * 44;
+acc += Math.sin(7514) + Math.cos(7515) * 45;
+acc += Math.sin(7515) + Math.cos(7516) * 46;
+acc += Math.sin(7516) + Math.cos(7517) * 47;
+acc += Math.sin(7517) + Math.cos(7518) * 48;
+acc += Math.sin(7518) + Math.cos(7519) * 49;
+acc += Math.sin(7519) + Math.cos(7520) * 50;
+acc += Math.sin(7520) + Math.cos(7521) * 51;
+acc += Math.sin(7521) + Math.cos(7522) * 52;
+acc += Math.sin(7522) + Math.cos(7523) * 53;
+acc += Math.sin(7523) + Math.cos(7524) * 54;
+acc += Math.sin(7524) + Math.cos(7525) * 55;
+acc += Math.sin(7525) + Math.cos(7526) * 56;
+acc += Math.sin(7526) + Math.cos(7527) * 57;
+acc += Math.sin(7527) + Math.cos(7528) * 58;
+acc += Math.sin(7528) + Math.cos(7529) * 59;
+acc += Math.sin(7529) + Math.cos(7530) * 60;
+acc += Math.sin(7530) + Math.cos(7531) * 61;
+acc += Math.sin(7531) + Math.cos(7532) * 62;
+acc += Math.sin(7532) + Math.cos(7533) * 63;
+acc += Math.sin(7533) + Math.cos(7534) * 64;
+acc += Math.sin(7534) + Math.cos(7535) * 65;
+acc += Math.sin(7535) + Math.cos(7536) * 66;
+acc += Math.sin(7536) + Math.cos(7537) * 67;
+acc += Math.sin(7537) + Math.cos(7538) * 68;
+acc += Math.sin(7538) + Math.cos(7539) * 69;
+acc += Math.sin(7539) + Math.cos(7540) * 70;
+acc += Math.sin(7540) + Math.cos(7541) * 71;
+acc += Math.sin(7541) + Math.cos(7542) * 72;
+acc += Math.sin(7542) + Math.cos(7543) * 73;
+acc += Math.sin(7543) + Math.cos(7544) * 74;
+acc += Math.sin(7544) + Math.cos(7545) * 75;
+acc += Math.sin(7545) + Math.cos(7546) * 76;
+acc += Math.sin(7546) + Math.cos(7547) * 77;
+acc += Math.sin(7547) + Math.cos(7548) * 78;
+acc += Math.sin(7548) + Math.cos(7549) * 79;
+acc += Math.sin(7549) + Math.cos(7550) * 80;
+acc += Math.sin(7550) + Math.cos(7551) * 81;
+acc += Math.sin(7551) + Math.cos(7552) * 82;
+acc += Math.sin(7552) + Math.cos(7553) * 83;
+acc += Math.sin(7553) + Math.cos(7554) * 84;
+acc += Math.sin(7554) + Math.cos(7555) * 85;
+acc += Math.sin(7555) + Math.cos(7556) * 86;
+acc += Math.sin(7556) + Math.cos(7557) * 87;
+acc += Math.sin(7557) + Math.cos(7558) * 88;
+acc += Math.sin(7558) + Math.cos(7559) * 89;
+acc += Math.sin(7559) + Math.cos(7560) * 90;
+acc += Math.sin(7560) + Math.cos(7561) * 91;
+acc += Math.sin(7561) + Math.cos(7562) * 92;
+acc += Math.sin(7562) + Math.cos(7563) * 93;
+acc += Math.sin(7563) + Math.cos(7564) * 94;
+acc += Math.sin(7564) + Math.cos(7565) * 95;
+acc += Math.sin(7565) + Math.cos(7566) * 96;
+acc += Math.sin(7566) + Math.cos(7567) * 0;
+acc += Math.sin(7567) + Math.cos(7568) * 1;
+acc += Math.sin(7568) + Math.cos(7569) * 2;
+acc += Math.sin(7569) + Math.cos(7570) * 3;
+acc += Math.sin(7570) + Math.cos(7571) * 4;
+acc += Math.sin(7571) + Math.cos(7572) * 5;
+acc += Math.sin(7572) + Math.cos(7573) * 6;
+acc += Math.sin(7573) + Math.cos(7574) * 7;
+acc += Math.sin(7574) + Math.cos(7575) * 8;
+acc += Math.sin(7575) + Math.cos(7576) * 9;
+acc += Math.sin(7576) + Math.cos(7577) * 10;
+acc += Math.sin(7577) + Math.cos(7578) * 11;
+acc += Math.sin(7578) + Math.cos(7579) * 12;
+acc += Math.sin(7579) + Math.cos(7580) * 13;
+acc += Math.sin(7580) + Math.cos(7581) * 14;
+acc += Math.sin(7581) + Math.cos(7582) * 15;
+acc += Math.sin(7582) + Math.cos(7583) * 16;
+acc += Math.sin(7583) + Math.cos(7584) * 17;
+acc += Math.sin(7584) + Math.cos(7585) * 18;
+acc += Math.sin(7585) + Math.cos(7586) * 19;
+acc += Math.sin(7586) + Math.cos(7587) * 20;
+acc += Math.sin(7587) + Math.cos(7588) * 21;
+acc += Math.sin(7588) + Math.cos(7589) * 22;
+acc += Math.sin(7589) + Math.cos(7590) * 23;
+acc += Math.sin(7590) + Math.cos(7591) * 24;
+acc += Math.sin(7591) + Math.cos(7592) * 25;
+acc += Math.sin(7592) + Math.cos(7593) * 26;
+acc += Math.sin(7593) + Math.cos(7594) * 27;
+acc += Math.sin(7594) + Math.cos(7595) * 28;
+acc += Math.sin(7595) + Math.cos(7596) * 29;
+acc += Math.sin(7596) + Math.cos(7597) * 30;
+acc += Math.sin(7597) + Math.cos(7598) * 31;
+acc += Math.sin(7598) + Math.cos(7599) * 32;
+acc += Math.sin(7599) + Math.cos(7600) * 33;
+acc += Math.sin(7600) + Math.cos(7601) * 34;
+acc += Math.sin(7601) + Math.cos(7602) * 35;
+acc += Math.sin(7602) + Math.cos(7603) * 36;
+acc += Math.sin(7603) + Math.cos(7604) * 37;
+acc += Math.sin(7604) + Math.cos(7605) * 38;
+acc += Math.sin(7605) + Math.cos(7606) * 39;
+acc += Math.sin(7606) + Math.cos(7607) * 40;
+acc += Math.sin(7607) + Math.cos(7608) * 41;
+acc += Math.sin(7608) + Math.cos(7609) * 42;
+acc += Math.sin(7609) + Math.cos(7610) * 43;
+acc += Math.sin(7610) + Math.cos(7611) * 44;
+acc += Math.sin(7611) + Math.cos(7612) * 45;
+acc += Math.sin(7612) + Math.cos(7613) * 46;
+acc += Math.sin(7613) + Math.cos(7614) * 47;
+acc += Math.sin(7614) + Math.cos(7615) * 48;
+acc += Math.sin(7615) + Math.cos(7616) * 49;
+acc += Math.sin(7616) + Math.cos(7617) * 50;
+acc += Math.sin(7617) + Math.cos(7618) * 51;
+acc += Math.sin(7618) + Math.cos(7619) * 52;
+acc += Math.sin(7619) + Math.cos(7620) * 53;
+acc += Math.sin(7620) + Math.cos(7621) * 54;
+acc += Math.sin(7621) + Math.cos(7622) * 55;
+acc += Math.sin(7622) + Math.cos(7623) * 56;
+acc += Math.sin(7623) + Math.cos(7624) * 57;
+acc += Math.sin(7624) + Math.cos(7625) * 58;
+acc += Math.sin(7625) + Math.cos(7626) * 59;
+acc += Math.sin(7626) + Math.cos(7627) * 60;
+acc += Math.sin(7627) + Math.cos(7628) * 61;
+acc += Math.sin(7628) + Math.cos(7629) * 62;
+acc += Math.sin(7629) + Math.cos(7630) * 63;
+acc += Math.sin(7630) + Math.cos(7631) * 64;
+acc += Math.sin(7631) + Math.cos(7632) * 65;
+acc += Math.sin(7632) + Math.cos(7633) * 66;
+acc += Math.sin(7633) + Math.cos(7634) * 67;
+acc += Math.sin(7634) + Math.cos(7635) * 68;
+acc += Math.sin(7635) + Math.cos(7636) * 69;
+acc += Math.sin(7636) + Math.cos(7637) * 70;
+acc += Math.sin(7637) + Math.cos(7638) * 71;
+acc += Math.sin(7638) + Math.cos(7639) * 72;
+acc += Math.sin(7639) + Math.cos(7640) * 73;
+acc += Math.sin(7640) + Math.cos(7641) * 74;
+acc += Math.sin(7641) + Math.cos(7642) * 75;
+acc += Math.sin(7642) + Math.cos(7643) * 76;
+acc += Math.sin(7643) + Math.cos(7644) * 77;
+acc += Math.sin(7644) + Math.cos(7645) * 78;
+acc += Math.sin(7645) + Math.cos(7646) * 79;
+acc += Math.sin(7646) + Math.cos(7647) * 80;
+acc += Math.sin(7647) + Math.cos(7648) * 81;
+acc += Math.sin(7648) + Math.cos(7649) * 82;
+acc += Math.sin(7649) + Math.cos(7650) * 83;
+acc += Math.sin(7650) + Math.cos(7651) * 84;
+acc += Math.sin(7651) + Math.cos(7652) * 85;
+acc += Math.sin(7652) + Math.cos(7653) * 86;
+acc += Math.sin(7653) + Math.cos(7654) * 87;
+acc += Math.sin(7654) + Math.cos(7655) * 88;
+acc += Math.sin(7655) + Math.cos(7656) * 89;
+acc += Math.sin(7656) + Math.cos(7657) * 90;
+acc += Math.sin(7657) + Math.cos(7658) * 91;
+acc += Math.sin(7658) + Math.cos(7659) * 92;
+acc += Math.sin(7659) + Math.cos(7660) * 93;
+acc += Math.sin(7660) + Math.cos(7661) * 94;
+acc += Math.sin(7661) + Math.cos(7662) * 95;
+acc += Math.sin(7662) + Math.cos(7663) * 96;
+acc += Math.sin(7663) + Math.cos(7664) * 0;
+acc += Math.sin(7664) + Math.cos(7665) * 1;
+acc += Math.sin(7665) + Math.cos(7666) * 2;
+acc += Math.sin(7666) + Math.cos(7667) * 3;
+acc += Math.sin(7667) + Math.cos(7668) * 4;
+acc += Math.sin(7668) + Math.cos(7669) * 5;
+acc += Math.sin(7669) + Math.cos(7670) * 6;
+acc += Math.sin(7670) + Math.cos(7671) * 7;
+acc += Math.sin(7671) + Math.cos(7672) * 8;
+acc += Math.sin(7672) + Math.cos(7673) * 9;
+acc += Math.sin(7673) + Math.cos(7674) * 10;
+acc += Math.sin(7674) + Math.cos(7675) * 11;
+acc += Math.sin(7675) + Math.cos(7676) * 12;
+acc += Math.sin(7676) + Math.cos(7677) * 13;
+acc += Math.sin(7677) + Math.cos(7678) * 14;
+acc += Math.sin(7678) + Math.cos(7679) * 15;
+acc += Math.sin(7679) + Math.cos(7680) * 16;
+acc += Math.sin(7680) + Math.cos(7681) * 17;
+acc += Math.sin(7681) + Math.cos(7682) * 18;
+acc += Math.sin(7682) + Math.cos(7683) * 19;
+acc += Math.sin(7683) + Math.cos(7684) * 20;
+acc += Math.sin(7684) + Math.cos(7685) * 21;
+acc += Math.sin(7685) + Math.cos(7686) * 22;
+acc += Math.sin(7686) + Math.cos(7687) * 23;
+acc += Math.sin(7687) + Math.cos(7688) * 24;
+acc += Math.sin(7688) + Math.cos(7689) * 25;
+acc += Math.sin(7689) + Math.cos(7690) * 26;
+acc += Math.sin(7690) + Math.cos(7691) * 27;
+acc += Math.sin(7691) + Math.cos(7692) * 28;
+acc += Math.sin(7692) + Math.cos(7693) * 29;
+acc += Math.sin(7693) + Math.cos(7694) * 30;
+acc += Math.sin(7694) + Math.cos(7695) * 31;
+acc += Math.sin(7695) + Math.cos(7696) * 32;
+acc += Math.sin(7696) + Math.cos(7697) * 33;
+acc += Math.sin(7697) + Math.cos(7698) * 34;
+acc += Math.sin(7698) + Math.cos(7699) * 35;
+acc += Math.sin(7699) + Math.cos(7700) * 36;
+acc += Math.sin(7700) + Math.cos(7701) * 37;
+acc += Math.sin(7701) + Math.cos(7702) * 38;
+acc += Math.sin(7702) + Math.cos(7703) * 39;
+acc += Math.sin(7703) + Math.cos(7704) * 40;
+acc += Math.sin(7704) + Math.cos(7705) * 41;
+acc += Math.sin(7705) + Math.cos(7706) * 42;
+acc += Math.sin(7706) + Math.cos(7707) * 43;
+acc += Math.sin(7707) + Math.cos(7708) * 44;
+acc += Math.sin(7708) + Math.cos(7709) * 45;
+acc += Math.sin(7709) + Math.cos(7710) * 46;
+acc += Math.sin(7710) + Math.cos(7711) * 47;
+acc += Math.sin(7711) + Math.cos(7712) * 48;
+acc += Math.sin(7712) + Math.cos(7713) * 49;
+acc += Math.sin(7713) + Math.cos(7714) * 50;
+acc += Math.sin(7714) + Math.cos(7715) * 51;
+acc += Math.sin(7715) + Math.cos(7716) * 52;
+acc += Math.sin(7716) + Math.cos(7717) * 53;
+acc += Math.sin(7717) + Math.cos(7718) * 54;
+acc += Math.sin(7718) + Math.cos(7719) * 55;
+acc += Math.sin(7719) + Math.cos(7720) * 56;
+acc += Math.sin(7720) + Math.cos(7721) * 57;
+acc += Math.sin(7721) + Math.cos(7722) * 58;
+acc += Math.sin(7722) + Math.cos(7723) * 59;
+acc += Math.sin(7723) + Math.cos(7724) * 60;
+acc += Math.sin(7724) + Math.cos(7725) * 61;
+acc += Math.sin(7725) + Math.cos(7726) * 62;
+acc += Math.sin(7726) + Math.cos(7727) * 63;
+acc += Math.sin(7727) + Math.cos(7728) * 64;
+acc += Math.sin(7728) + Math.cos(7729) * 65;
+acc += Math.sin(7729) + Math.cos(7730) * 66;
+acc += Math.sin(7730) + Math.cos(7731) * 67;
+acc += Math.sin(7731) + Math.cos(7732) * 68;
+acc += Math.sin(7732) + Math.cos(7733) * 69;
+acc += Math.sin(7733) + Math.cos(7734) * 70;
+acc += Math.sin(7734) + Math.cos(7735) * 71;
+acc += Math.sin(7735) + Math.cos(7736) * 72;
+acc += Math.sin(7736) + Math.cos(7737) * 73;
+acc += Math.sin(7737) + Math.cos(7738) * 74;
+acc += Math.sin(7738) + Math.cos(7739) * 75;
+acc += Math.sin(7739) + Math.cos(7740) * 76;
+acc += Math.sin(7740) + Math.cos(7741) * 77;
+acc += Math.sin(7741) + Math.cos(7742) * 78;
+acc += Math.sin(7742) + Math.cos(7743) * 79;
+acc += Math.sin(7743) + Math.cos(7744) * 80;
+acc += Math.sin(7744) + Math.cos(7745) * 81;
+acc += Math.sin(7745) + Math.cos(7746) * 82;
+acc += Math.sin(7746) + Math.cos(7747) * 83;
+acc += Math.sin(7747) + Math.cos(7748) * 84;
+acc += Math.sin(7748) + Math.cos(7749) * 85;
+acc += Math.sin(7749) + Math.cos(7750) * 86;
+acc += Math.sin(7750) + Math.cos(7751) * 87;
+acc += Math.sin(7751) + Math.cos(7752) * 88;
+acc += Math.sin(7752) + Math.cos(7753) * 89;
+acc += Math.sin(7753) + Math.cos(7754) * 90;
+acc += Math.sin(7754) + Math.cos(7755) * 91;
+acc += Math.sin(7755) + Math.cos(7756) * 92;
+acc += Math.sin(7756) + Math.cos(7757) * 93;
+acc += Math.sin(7757) + Math.cos(7758) * 94;
+acc += Math.sin(7758) + Math.cos(7759) * 95;
+acc += Math.sin(7759) + Math.cos(7760) * 96;
+acc += Math.sin(7760) + Math.cos(7761) * 0;
+acc += Math.sin(7761) + Math.cos(7762) * 1;
+acc += Math.sin(7762) + Math.cos(7763) * 2;
+acc += Math.sin(7763) + Math.cos(7764) * 3;
+acc += Math.sin(7764) + Math.cos(7765) * 4;
+acc += Math.sin(7765) + Math.cos(7766) * 5;
+acc += Math.sin(7766) + Math.cos(7767) * 6;
+acc += Math.sin(7767) + Math.cos(7768) * 7;
+acc += Math.sin(7768) + Math.cos(7769) * 8;
+acc += Math.sin(7769) + Math.cos(7770) * 9;
+acc += Math.sin(7770) + Math.cos(7771) * 10;
+acc += Math.sin(7771) + Math.cos(7772) * 11;
+acc += Math.sin(7772) + Math.cos(7773) * 12;
+acc += Math.sin(7773) + Math.cos(7774) * 13;
+acc += Math.sin(7774) + Math.cos(7775) * 14;
+acc += Math.sin(7775) + Math.cos(7776) * 15;
+acc += Math.sin(7776) + Math.cos(7777) * 16;
+acc += Math.sin(7777) + Math.cos(7778) * 17;
+acc += Math.sin(7778) + Math.cos(7779) * 18;
+acc += Math.sin(7779) + Math.cos(7780) * 19;
+acc += Math.sin(7780) + Math.cos(7781) * 20;
+acc += Math.sin(7781) + Math.cos(7782) * 21;
+acc += Math.sin(7782) + Math.cos(7783) * 22;
+acc += Math.sin(7783) + Math.cos(7784) * 23;
+acc += Math.sin(7784) + Math.cos(7785) * 24;
+acc += Math.sin(7785) + Math.cos(7786) * 25;
+acc += Math.sin(7786) + Math.cos(7787) * 26;
+acc += Math.sin(7787) + Math.cos(7788) * 27;
+acc += Math.sin(7788) + Math.cos(7789) * 28;
+acc += Math.sin(7789) + Math.cos(7790) * 29;
+acc += Math.sin(7790) + Math.cos(7791) * 30;
+acc += Math.sin(7791) + Math.cos(7792) * 31;
+acc += Math.sin(7792) + Math.cos(7793) * 32;
+acc += Math.sin(7793) + Math.cos(7794) * 33;
+acc += Math.sin(7794) + Math.cos(7795) * 34;
+acc += Math.sin(7795) + Math.cos(7796) * 35;
+acc += Math.sin(7796) + Math.cos(7797) * 36;
+acc += Math.sin(7797) + Math.cos(7798) * 37;
+acc += Math.sin(7798) + Math.cos(7799) * 38;
+acc += Math.sin(7799) + Math.cos(7800) * 39;
+acc += Math.sin(7800) + Math.cos(7801) * 40;
+acc += Math.sin(7801) + Math.cos(7802) * 41;
+acc += Math.sin(7802) + Math.cos(7803) * 42;
+acc += Math.sin(7803) + Math.cos(7804) * 43;
+acc += Math.sin(7804) + Math.cos(7805) * 44;
+acc += Math.sin(7805) + Math.cos(7806) * 45;
+acc += Math.sin(7806) + Math.cos(7807) * 46;
+acc += Math.sin(7807) + Math.cos(7808) * 47;
+acc += Math.sin(7808) + Math.cos(7809) * 48;
+acc += Math.sin(7809) + Math.cos(7810) * 49;
+acc += Math.sin(7810) + Math.cos(7811) * 50;
+acc += Math.sin(7811) + Math.cos(7812) * 51;
+acc += Math.sin(7812) + Math.cos(7813) * 52;
+acc += Math.sin(7813) + Math.cos(7814) * 53;
+acc += Math.sin(7814) + Math.cos(7815) * 54;
+acc += Math.sin(7815) + Math.cos(7816) * 55;
+acc += Math.sin(7816) + Math.cos(7817) * 56;
+acc += Math.sin(7817) + Math.cos(7818) * 57;
+acc += Math.sin(7818) + Math.cos(7819) * 58;
+acc += Math.sin(7819) + Math.cos(7820) * 59;
+acc += Math.sin(7820) + Math.cos(7821) * 60;
+acc += Math.sin(7821) + Math.cos(7822) * 61;
+acc += Math.sin(7822) + Math.cos(7823) * 62;
+acc += Math.sin(7823) + Math.cos(7824) * 63;
+acc += Math.sin(7824) + Math.cos(7825) * 64;
+acc += Math.sin(7825) + Math.cos(7826) * 65;
+acc += Math.sin(7826) + Math.cos(7827) * 66;
+acc += Math.sin(7827) + Math.cos(7828) * 67;
+acc += Math.sin(7828) + Math.cos(7829) * 68;
+acc += Math.sin(7829) + Math.cos(7830) * 69;
+acc += Math.sin(7830) + Math.cos(7831) * 70;
+acc += Math.sin(7831) + Math.cos(7832) * 71;
+acc += Math.sin(7832) + Math.cos(7833) * 72;
+acc += Math.sin(7833) + Math.cos(7834) * 73;
+acc += Math.sin(7834) + Math.cos(7835) * 74;
+acc += Math.sin(7835) + Math.cos(7836) * 75;
+acc += Math.sin(7836) + Math.cos(7837) * 76;
+acc += Math.sin(7837) + Math.cos(7838) * 77;
+acc += Math.sin(7838) + Math.cos(7839) * 78;
+acc += Math.sin(7839) + Math.cos(7840) * 79;
+acc += Math.sin(7840) + Math.cos(7841) * 80;
+acc += Math.sin(7841) + Math.cos(7842) * 81;
+acc += Math.sin(7842) + Math.cos(7843) * 82;
+acc += Math.sin(7843) + Math.cos(7844) * 83;
+acc += Math.sin(7844) + Math.cos(7845) * 84;
+acc += Math.sin(7845) + Math.cos(7846) * 85;
+acc += Math.sin(7846) + Math.cos(7847) * 86;
+acc += Math.sin(7847) + Math.cos(7848) * 87;
+acc += Math.sin(7848) + Math.cos(7849) * 88;
+acc += Math.sin(7849) + Math.cos(7850) * 89;
+acc += Math.sin(7850) + Math.cos(7851) * 90;
+acc += Math.sin(7851) + Math.cos(7852) * 91;
+acc += Math.sin(7852) + Math.cos(7853) * 92;
+acc += Math.sin(7853) + Math.cos(7854) * 93;
+acc += Math.sin(7854) + Math.cos(7855) * 94;
+acc += Math.sin(7855) + Math.cos(7856) * 95;
+acc += Math.sin(7856) + Math.cos(7857) * 96;
+acc += Math.sin(7857) + Math.cos(7858) * 0;
+acc += Math.sin(7858) + Math.cos(7859) * 1;
+acc += Math.sin(7859) + Math.cos(7860) * 2;
+acc += Math.sin(7860) + Math.cos(7861) * 3;
+acc += Math.sin(7861) + Math.cos(7862) * 4;
+acc += Math.sin(7862) + Math.cos(7863) * 5;
+acc += Math.sin(7863) + Math.cos(7864) * 6;
+acc += Math.sin(7864) + Math.cos(7865) * 7;
+acc += Math.sin(7865) + Math.cos(7866) * 8;
+acc += Math.sin(7866) + Math.cos(7867) * 9;
+acc += Math.sin(7867) + Math.cos(7868) * 10;
+acc += Math.sin(7868) + Math.cos(7869) * 11;
+acc += Math.sin(7869) + Math.cos(7870) * 12;
+acc += Math.sin(7870) + Math.cos(7871) * 13;
+acc += Math.sin(7871) + Math.cos(7872) * 14;
+acc += Math.sin(7872) + Math.cos(7873) * 15;
+acc += Math.sin(7873) + Math.cos(7874) * 16;
+acc += Math.sin(7874) + Math.cos(7875) * 17;
+acc += Math.sin(7875) + Math.cos(7876) * 18;
+acc += Math.sin(7876) + Math.cos(7877) * 19;
+acc += Math.sin(7877) + Math.cos(7878) * 20;
+acc += Math.sin(7878) + Math.cos(7879) * 21;
+acc += Math.sin(7879) + Math.cos(7880) * 22;
+acc += Math.sin(7880) + Math.cos(7881) * 23;
+acc += Math.sin(7881) + Math.cos(7882) * 24;
+acc += Math.sin(7882) + Math.cos(7883) * 25;
+acc += Math.sin(7883) + Math.cos(7884) * 26;
+acc += Math.sin(7884) + Math.cos(7885) * 27;
+acc += Math.sin(7885) + Math.cos(7886) * 28;
+acc += Math.sin(7886) + Math.cos(7887) * 29;
+acc += Math.sin(7887) + Math.cos(7888) * 30;
+acc += Math.sin(7888) + Math.cos(7889) * 31;
+acc += Math.sin(7889) + Math.cos(7890) * 32;
+acc += Math.sin(7890) + Math.cos(7891) * 33;
+acc += Math.sin(7891) + Math.cos(7892) * 34;
+acc += Math.sin(7892) + Math.cos(7893) * 35;
+acc += Math.sin(7893) + Math.cos(7894) * 36;
+acc += Math.sin(7894) + Math.cos(7895) * 37;
+acc += Math.sin(7895) + Math.cos(7896) * 38;
+acc += Math.sin(7896) + Math.cos(7897) * 39;
+acc += Math.sin(7897) + Math.cos(7898) * 40;
+acc += Math.sin(7898) + Math.cos(7899) * 41;
+acc += Math.sin(7899) + Math.cos(7900) * 42;
+acc += Math.sin(7900) + Math.cos(7901) * 43;
+acc += Math.sin(7901) + Math.cos(7902) * 44;
+acc += Math.sin(7902) + Math.cos(7903) * 45;
+acc += Math.sin(7903) + Math.cos(7904) * 46;
+acc += Math.sin(7904) + Math.cos(7905) * 47;
+acc += Math.sin(7905) + Math.cos(7906) * 48;
+acc += Math.sin(7906) + Math.cos(7907) * 49;
+acc += Math.sin(7907) + Math.cos(7908) * 50;
+acc += Math.sin(7908) + Math.cos(7909) * 51;
+acc += Math.sin(7909) + Math.cos(7910) * 52;
+acc += Math.sin(7910) + Math.cos(7911) * 53;
+acc += Math.sin(7911) + Math.cos(7912) * 54;
+acc += Math.sin(7912) + Math.cos(7913) * 55;
+acc += Math.sin(7913) + Math.cos(7914) * 56;
+acc += Math.sin(7914) + Math.cos(7915) * 57;
+acc += Math.sin(7915) + Math.cos(7916) * 58;
+acc += Math.sin(7916) + Math.cos(7917) * 59;
+acc += Math.sin(7917) + Math.cos(7918) * 60;
+acc += Math.sin(7918) + Math.cos(7919) * 61;
+acc += Math.sin(7919) + Math.cos(7920) * 62;
+acc += Math.sin(7920) + Math.cos(7921) * 63;
+acc += Math.sin(7921) + Math.cos(7922) * 64;
+acc += Math.sin(7922) + Math.cos(7923) * 65;
+acc += Math.sin(7923) + Math.cos(7924) * 66;
+acc += Math.sin(7924) + Math.cos(7925) * 67;
+acc += Math.sin(7925) + Math.cos(7926) * 68;
+acc += Math.sin(7926) + Math.cos(7927) * 69;
+acc += Math.sin(7927) + Math.cos(7928) * 70;
+acc += Math.sin(7928) + Math.cos(7929) * 71;
+acc += Math.sin(7929) + Math.cos(7930) * 72;
+acc += Math.sin(7930) + Math.cos(7931) * 73;
+acc += Math.sin(7931) + Math.cos(7932) * 74;
+acc += Math.sin(7932) + Math.cos(7933) * 75;
+acc += Math.sin(7933) + Math.cos(7934) * 76;
+acc += Math.sin(7934) + Math.cos(7935) * 77;
+acc += Math.sin(7935) + Math.cos(7936) * 78;
+acc += Math.sin(7936) + Math.cos(7937) * 79;
+acc += Math.sin(7937) + Math.cos(7938) * 80;
+acc += Math.sin(7938) + Math.cos(7939) * 81;
+acc += Math.sin(7939) + Math.cos(7940) * 82;
+acc += Math.sin(7940) + Math.cos(7941) * 83;
+acc += Math.sin(7941) + Math.cos(7942) * 84;
+acc += Math.sin(7942) + Math.cos(7943) * 85;
+acc += Math.sin(7943) + Math.cos(7944) * 86;
+acc += Math.sin(7944) + Math.cos(7945) * 87;
+acc += Math.sin(7945) + Math.cos(7946) * 88;
+acc += Math.sin(7946) + Math.cos(7947) * 89;
+acc += Math.sin(7947) + Math.cos(7948) * 90;
+acc += Math.sin(7948) + Math.cos(7949) * 91;
+acc += Math.sin(7949) + Math.cos(7950) * 92;
+acc += Math.sin(7950) + Math.cos(7951) * 93;
+acc += Math.sin(7951) + Math.cos(7952) * 94;
+acc += Math.sin(7952) + Math.cos(7953) * 95;
+acc += Math.sin(7953) + Math.cos(7954) * 96;
+acc += Math.sin(7954) + Math.cos(7955) * 0;
+acc += Math.sin(7955) + Math.cos(7956) * 1;
+acc += Math.sin(7956) + Math.cos(7957) * 2;
+acc += Math.sin(7957) + Math.cos(7958) * 3;
+acc += Math.sin(7958) + Math.cos(7959) * 4;
+acc += Math.sin(7959) + Math.cos(7960) * 5;
+acc += Math.sin(7960) + Math.cos(7961) * 6;
+acc += Math.sin(7961) + Math.cos(7962) * 7;
+acc += Math.sin(7962) + Math.cos(7963) * 8;
+acc += Math.sin(7963) + Math.cos(7964) * 9;
+acc += Math.sin(7964) + Math.cos(7965) * 10;
+acc += Math.sin(7965) + Math.cos(7966) * 11;
+acc += Math.sin(7966) + Math.cos(7967) * 12;
+acc += Math.sin(7967) + Math.cos(7968) * 13;
+acc += Math.sin(7968) + Math.cos(7969) * 14;
+acc += Math.sin(7969) + Math.cos(7970) * 15;
+acc += Math.sin(7970) + Math.cos(7971) * 16;
+acc += Math.sin(7971) + Math.cos(7972) * 17;
+acc += Math.sin(7972) + Math.cos(7973) * 18;
+acc += Math.sin(7973) + Math.cos(7974) * 19;
+acc += Math.sin(7974) + Math.cos(7975) * 20;
+acc += Math.sin(7975) + Math.cos(7976) * 21;
+acc += Math.sin(7976) + Math.cos(7977) * 22;
+acc += Math.sin(7977) + Math.cos(7978) * 23;
+acc += Math.sin(7978) + Math.cos(7979) * 24;
+acc += Math.sin(7979) + Math.cos(7980) * 25;
+acc += Math.sin(7980) + Math.cos(7981) * 26;
+acc += Math.sin(7981) + Math.cos(7982) * 27;
+acc += Math.sin(7982) + Math.cos(7983) * 28;
+acc += Math.sin(7983) + Math.cos(7984) * 29;
+acc += Math.sin(7984) + Math.cos(7985) * 30;
+acc += Math.sin(7985) + Math.cos(7986) * 31;
+acc += Math.sin(7986) + Math.cos(7987) * 32;
+acc += Math.sin(7987) + Math.cos(7988) * 33;
+acc += Math.sin(7988) + Math.cos(7989) * 34;
+acc += Math.sin(7989) + Math.cos(7990) * 35;
+acc += Math.sin(7990) + Math.cos(7991) * 36;
+acc += Math.sin(7991) + Math.cos(7992) * 37;
+acc += Math.sin(7992) + Math.cos(7993) * 38;
+acc += Math.sin(7993) + Math.cos(7994) * 39;
+acc += Math.sin(7994) + Math.cos(7995) * 40;
+acc += Math.sin(7995) + Math.cos(7996) * 41;
+acc += Math.sin(7996) + Math.cos(7997) * 42;
+acc += Math.sin(7997) + Math.cos(7998) * 43;
+acc += Math.sin(7998) + Math.cos(7999) * 44;
+acc += Math.sin(7999) + Math.cos(8000) * 45;
+acc += Math.sin(8000) + Math.cos(8001) * 46;
+acc += Math.sin(8001) + Math.cos(8002) * 47;
+acc += Math.sin(8002) + Math.cos(8003) * 48;
+acc += Math.sin(8003) + Math.cos(8004) * 49;
+acc += Math.sin(8004) + Math.cos(8005) * 50;
+acc += Math.sin(8005) + Math.cos(8006) * 51;
+acc += Math.sin(8006) + Math.cos(8007) * 52;
+acc += Math.sin(8007) + Math.cos(8008) * 53;
+acc += Math.sin(8008) + Math.cos(8009) * 54;
+acc += Math.sin(8009) + Math.cos(8010) * 55;
+acc += Math.sin(8010) + Math.cos(8011) * 56;
+acc += Math.sin(8011) + Math.cos(8012) * 57;
+acc += Math.sin(8012) + Math.cos(8013) * 58;
+acc += Math.sin(8013) + Math.cos(8014) * 59;
+acc += Math.sin(8014) + Math.cos(8015) * 60;
+acc += Math.sin(8015) + Math.cos(8016) * 61;
+acc += Math.sin(8016) + Math.cos(8017) * 62;
+acc += Math.sin(8017) + Math.cos(8018) * 63;
+acc += Math.sin(8018) + Math.cos(8019) * 64;
+acc += Math.sin(8019) + Math.cos(8020) * 65;
+acc += Math.sin(8020) + Math.cos(8021) * 66;
+acc += Math.sin(8021) + Math.cos(8022) * 67;
+acc += Math.sin(8022) + Math.cos(8023) * 68;
+acc += Math.sin(8023) + Math.cos(8024) * 69;
+acc += Math.sin(8024) + Math.cos(8025) * 70;
+acc += Math.sin(8025) + Math.cos(8026) * 71;
+acc += Math.sin(8026) + Math.cos(8027) * 72;
+acc += Math.sin(8027) + Math.cos(8028) * 73;
+acc += Math.sin(8028) + Math.cos(8029) * 74;
+acc += Math.sin(8029) + Math.cos(8030) * 75;
+acc += Math.sin(8030) + Math.cos(8031) * 76;
+acc += Math.sin(8031) + Math.cos(8032) * 77;
+acc += Math.sin(8032) + Math.cos(8033) * 78;
+acc += Math.sin(8033) + Math.cos(8034) * 79;
+acc += Math.sin(8034) + Math.cos(8035) * 80;
+acc += Math.sin(8035) + Math.cos(8036) * 81;
+acc += Math.sin(8036) + Math.cos(8037) * 82;
+acc += Math.sin(8037) + Math.cos(8038) * 83;
+acc += Math.sin(8038) + Math.cos(8039) * 84;
+acc += Math.sin(8039) + Math.cos(8040) * 85;
+acc += Math.sin(8040) + Math.cos(8041) * 86;
+acc += Math.sin(8041) + Math.cos(8042) * 87;
+acc += Math.sin(8042) + Math.cos(8043) * 88;
+acc += Math.sin(8043) + Math.cos(8044) * 89;
+acc += Math.sin(8044) + Math.cos(8045) * 90;
+acc += Math.sin(8045) + Math.cos(8046) * 91;
+acc += Math.sin(8046) + Math.cos(8047) * 92;
+acc += Math.sin(8047) + Math.cos(8048) * 93;
+acc += Math.sin(8048) + Math.cos(8049) * 94;
+acc += Math.sin(8049) + Math.cos(8050) * 95;
+acc += Math.sin(8050) + Math.cos(8051) * 96;
+acc += Math.sin(8051) + Math.cos(8052) * 0;
+acc += Math.sin(8052) + Math.cos(8053) * 1;
+acc += Math.sin(8053) + Math.cos(8054) * 2;
+acc += Math.sin(8054) + Math.cos(8055) * 3;
+acc += Math.sin(8055) + Math.cos(8056) * 4;
+acc += Math.sin(8056) + Math.cos(8057) * 5;
+acc += Math.sin(8057) + Math.cos(8058) * 6;
+acc += Math.sin(8058) + Math.cos(8059) * 7;
+acc += Math.sin(8059) + Math.cos(8060) * 8;
+acc += Math.sin(8060) + Math.cos(8061) * 9;
+acc += Math.sin(8061) + Math.cos(8062) * 10;
+acc += Math.sin(8062) + Math.cos(8063) * 11;
+acc += Math.sin(8063) + Math.cos(8064) * 12;
+acc += Math.sin(8064) + Math.cos(8065) * 13;
+acc += Math.sin(8065) + Math.cos(8066) * 14;
+acc += Math.sin(8066) + Math.cos(8067) * 15;
+acc += Math.sin(8067) + Math.cos(8068) * 16;
+acc += Math.sin(8068) + Math.cos(8069) * 17;
+acc += Math.sin(8069) + Math.cos(8070) * 18;
+acc += Math.sin(8070) + Math.cos(8071) * 19;
+acc += Math.sin(8071) + Math.cos(8072) * 20;
+acc += Math.sin(8072) + Math.cos(8073) * 21;
+acc += Math.sin(8073) + Math.cos(8074) * 22;
+acc += Math.sin(8074) + Math.cos(8075) * 23;
+acc += Math.sin(8075) + Math.cos(8076) * 24;
+acc += Math.sin(8076) + Math.cos(8077) * 25;
+acc += Math.sin(8077) + Math.cos(8078) * 26;
+acc += Math.sin(8078) + Math.cos(8079) * 27;
+acc += Math.sin(8079) + Math.cos(8080) * 28;
+acc += Math.sin(8080) + Math.cos(8081) * 29;
+acc += Math.sin(8081) + Math.cos(8082) * 30;
+acc += Math.sin(8082) + Math.cos(8083) * 31;
+acc += Math.sin(8083) + Math.cos(8084) * 32;
+acc += Math.sin(8084) + Math.cos(8085) * 33;
+acc += Math.sin(8085) + Math.cos(8086) * 34;
+acc += Math.sin(8086) + Math.cos(8087) * 35;
+acc += Math.sin(8087) + Math.cos(8088) * 36;
+acc += Math.sin(8088) + Math.cos(8089) * 37;
+acc += Math.sin(8089) + Math.cos(8090) * 38;
+acc += Math.sin(8090) + Math.cos(8091) * 39;
+acc += Math.sin(8091) + Math.cos(8092) * 40;
+acc += Math.sin(8092) + Math.cos(8093) * 41;
+acc += Math.sin(8093) + Math.cos(8094) * 42;
+acc += Math.sin(8094) + Math.cos(8095) * 43;
+acc += Math.sin(8095) + Math.cos(8096) * 44;
+acc += Math.sin(8096) + Math.cos(8097) * 45;
+acc += Math.sin(8097) + Math.cos(8098) * 46;
+acc += Math.sin(8098) + Math.cos(8099) * 47;
+acc += Math.sin(8099) + Math.cos(8100) * 48;
+acc += Math.sin(8100) + Math.cos(8101) * 49;
+acc += Math.sin(8101) + Math.cos(8102) * 50;
+acc += Math.sin(8102) + Math.cos(8103) * 51;
+acc += Math.sin(8103) + Math.cos(8104) * 52;
+acc += Math.sin(8104) + Math.cos(8105) * 53;
+acc += Math.sin(8105) + Math.cos(8106) * 54;
+acc += Math.sin(8106) + Math.cos(8107) * 55;
+acc += Math.sin(8107) + Math.cos(8108) * 56;
+acc += Math.sin(8108) + Math.cos(8109) * 57;
+acc += Math.sin(8109) + Math.cos(8110) * 58;
+acc += Math.sin(8110) + Math.cos(8111) * 59;
+acc += Math.sin(8111) + Math.cos(8112) * 60;
+acc += Math.sin(8112) + Math.cos(8113) * 61;
+acc += Math.sin(8113) + Math.cos(8114) * 62;
+acc += Math.sin(8114) + Math.cos(8115) * 63;
+acc += Math.sin(8115) + Math.cos(8116) * 64;
+acc += Math.sin(8116) + Math.cos(8117) * 65;
+acc += Math.sin(8117) + Math.cos(8118) * 66;
+acc += Math.sin(8118) + Math.cos(8119) * 67;
+acc += Math.sin(8119) + Math.cos(8120) * 68;
+acc += Math.sin(8120) + Math.cos(8121) * 69;
+acc += Math.sin(8121) + Math.cos(8122) * 70;
+acc += Math.sin(8122) + Math.cos(8123) * 71;
+acc += Math.sin(8123) + Math.cos(8124) * 72;
+acc += Math.sin(8124) + Math.cos(8125) * 73;
+acc += Math.sin(8125) + Math.cos(8126) * 74;
+acc += Math.sin(8126) + Math.cos(8127) * 75;
+acc += Math.sin(8127) + Math.cos(8128) * 76;
+acc += Math.sin(8128) + Math.cos(8129) * 77;
+acc += Math.sin(8129) + Math.cos(8130) * 78;
+acc += Math.sin(8130) + Math.cos(8131) * 79;
+acc += Math.sin(8131) + Math.cos(8132) * 80;
+acc += Math.sin(8132) + Math.cos(8133) * 81;
+acc += Math.sin(8133) + Math.cos(8134) * 82;
+acc += Math.sin(8134) + Math.cos(8135) * 83;
+acc += Math.sin(8135) + Math.cos(8136) * 84;
+acc += Math.sin(8136) + Math.cos(8137) * 85;
+acc += Math.sin(8137) + Math.cos(8138) * 86;
+acc += Math.sin(8138) + Math.cos(8139) * 87;
+acc += Math.sin(8139) + Math.cos(8140) * 88;
+acc += Math.sin(8140) + Math.cos(8141) * 89;
+acc += Math.sin(8141) + Math.cos(8142) * 90;
+acc += Math.sin(8142) + Math.cos(8143) * 91;
+acc += Math.sin(8143) + Math.cos(8144) * 92;
+acc += Math.sin(8144) + Math.cos(8145) * 93;
+acc += Math.sin(8145) + Math.cos(8146) * 94;
+acc += Math.sin(8146) + Math.cos(8147) * 95;
+acc += Math.sin(8147) + Math.cos(8148) * 96;
+acc += Math.sin(8148) + Math.cos(8149) * 0;
+acc += Math.sin(8149) + Math.cos(8150) * 1;
+acc += Math.sin(8150) + Math.cos(8151) * 2;
+acc += Math.sin(8151) + Math.cos(8152) * 3;
+acc += Math.sin(8152) + Math.cos(8153) * 4;
+acc += Math.sin(8153) + Math.cos(8154) * 5;
+acc += Math.sin(8154) + Math.cos(8155) * 6;
+acc += Math.sin(8155) + Math.cos(8156) * 7;
+acc += Math.sin(8156) + Math.cos(8157) * 8;
+acc += Math.sin(8157) + Math.cos(8158) * 9;
+acc += Math.sin(8158) + Math.cos(8159) * 10;
+acc += Math.sin(8159) + Math.cos(8160) * 11;
+acc += Math.sin(8160) + Math.cos(8161) * 12;
+acc += Math.sin(8161) + Math.cos(8162) * 13;
+acc += Math.sin(8162) + Math.cos(8163) * 14;
+acc += Math.sin(8163) + Math.cos(8164) * 15;
+acc += Math.sin(8164) + Math.cos(8165) * 16;
+acc += Math.sin(8165) + Math.cos(8166) * 17;
+acc += Math.sin(8166) + Math.cos(8167) * 18;
+acc += Math.sin(8167) + Math.cos(8168) * 19;
+acc += Math.sin(8168) + Math.cos(8169) * 20;
+acc += Math.sin(8169) + Math.cos(8170) * 21;
+acc += Math.sin(8170) + Math.cos(8171) * 22;
+acc += Math.sin(8171) + Math.cos(8172) * 23;
+acc += Math.sin(8172) + Math.cos(8173) * 24;
+acc += Math.sin(8173) + Math.cos(8174) * 25;
+acc += Math.sin(8174) + Math.cos(8175) * 26;
+acc += Math.sin(8175) + Math.cos(8176) * 27;
+acc += Math.sin(8176) + Math.cos(8177) * 28;
+acc += Math.sin(8177) + Math.cos(8178) * 29;
+acc += Math.sin(8178) + Math.cos(8179) * 30;
+acc += Math.sin(8179) + Math.cos(8180) * 31;
+acc += Math.sin(8180) + Math.cos(8181) * 32;
+acc += Math.sin(8181) + Math.cos(8182) * 33;
+acc += Math.sin(8182) + Math.cos(8183) * 34;
+acc += Math.sin(8183) + Math.cos(8184) * 35;
+acc += Math.sin(8184) + Math.cos(8185) * 36;
+acc += Math.sin(8185) + Math.cos(8186) * 37;
+acc += Math.sin(8186) + Math.cos(8187) * 38;
+acc += Math.sin(8187) + Math.cos(8188) * 39;
+acc += Math.sin(8188) + Math.cos(8189) * 40;
+acc += Math.sin(8189) + Math.cos(8190) * 41;
+acc += Math.sin(8190) + Math.cos(8191) * 42;
+acc += Math.sin(8191) + Math.cos(8192) * 43;
+acc += Math.sin(8192) + Math.cos(8193) * 44;
+acc += Math.sin(8193) + Math.cos(8194) * 45;
+acc += Math.sin(8194) + Math.cos(8195) * 46;
+acc += Math.sin(8195) + Math.cos(8196) * 47;
+acc += Math.sin(8196) + Math.cos(8197) * 48;
+acc += Math.sin(8197) + Math.cos(8198) * 49;
+acc += Math.sin(8198) + Math.cos(8199) * 50;
+acc += Math.sin(8199) + Math.cos(8200) * 51;
+acc += Math.sin(8200) + Math.cos(8201) * 52;
+acc += Math.sin(8201) + Math.cos(8202) * 53;
+acc += Math.sin(8202) + Math.cos(8203) * 54;
+acc += Math.sin(8203) + Math.cos(8204) * 55;
+acc += Math.sin(8204) + Math.cos(8205) * 56;
+acc += Math.sin(8205) + Math.cos(8206) * 57;
+acc += Math.sin(8206) + Math.cos(8207) * 58;
+acc += Math.sin(8207) + Math.cos(8208) * 59;
+acc += Math.sin(8208) + Math.cos(8209) * 60;
+acc += Math.sin(8209) + Math.cos(8210) * 61;
+acc += Math.sin(8210) + Math.cos(8211) * 62;
+acc += Math.sin(8211) + Math.cos(8212) * 63;
+acc += Math.sin(8212) + Math.cos(8213) * 64;
+acc += Math.sin(8213) + Math.cos(8214) * 65;
+acc += Math.sin(8214) + Math.cos(8215) * 66;
+acc += Math.sin(8215) + Math.cos(8216) * 67;
+acc += Math.sin(8216) + Math.cos(8217) * 68;
+acc += Math.sin(8217) + Math.cos(8218) * 69;
+acc += Math.sin(8218) + Math.cos(8219) * 70;
+acc += Math.sin(8219) + Math.cos(8220) * 71;
+acc += Math.sin(8220) + Math.cos(8221) * 72;
+acc += Math.sin(8221) + Math.cos(8222) * 73;
+acc += Math.sin(8222) + Math.cos(8223) * 74;
+acc += Math.sin(8223) + Math.cos(8224) * 75;
+acc += Math.sin(8224) + Math.cos(8225) * 76;
+acc += Math.sin(8225) + Math.cos(8226) * 77;
+acc += Math.sin(8226) + Math.cos(8227) * 78;
+acc += Math.sin(8227) + Math.cos(8228) * 79;
+acc += Math.sin(8228) + Math.cos(8229) * 80;
+acc += Math.sin(8229) + Math.cos(8230) * 81;
+acc += Math.sin(8230) + Math.cos(8231) * 82;
+acc += Math.sin(8231) + Math.cos(8232) * 83;
+acc += Math.sin(8232) + Math.cos(8233) * 84;
+acc += Math.sin(8233) + Math.cos(8234) * 85;
+acc += Math.sin(8234) + Math.cos(8235) * 86;
+acc += Math.sin(8235) + Math.cos(8236) * 87;
+acc += Math.sin(8236) + Math.cos(8237) * 88;
+acc += Math.sin(8237) + Math.cos(8238) * 89;
+acc += Math.sin(8238) + Math.cos(8239) * 90;
+acc += Math.sin(8239) + Math.cos(8240) * 91;
+acc += Math.sin(8240) + Math.cos(8241) * 92;
+acc += Math.sin(8241) + Math.cos(8242) * 93;
+acc += Math.sin(8242) + Math.cos(8243) * 94;
+acc += Math.sin(8243) + Math.cos(8244) * 95;
+acc += Math.sin(8244) + Math.cos(8245) * 96;
+acc += Math.sin(8245) + Math.cos(8246) * 0;
+acc += Math.sin(8246) + Math.cos(8247) * 1;
+acc += Math.sin(8247) + Math.cos(8248) * 2;
+acc += Math.sin(8248) + Math.cos(8249) * 3;
+acc += Math.sin(8249) + Math.cos(8250) * 4;
+acc += Math.sin(8250) + Math.cos(8251) * 5;
+acc += Math.sin(8251) + Math.cos(8252) * 6;
+acc += Math.sin(8252) + Math.cos(8253) * 7;
+acc += Math.sin(8253) + Math.cos(8254) * 8;
+acc += Math.sin(8254) + Math.cos(8255) * 9;
+acc += Math.sin(8255) + Math.cos(8256) * 10;
+acc += Math.sin(8256) + Math.cos(8257) * 11;
+acc += Math.sin(8257) + Math.cos(8258) * 12;
+acc += Math.sin(8258) + Math.cos(8259) * 13;
+acc += Math.sin(8259) + Math.cos(8260) * 14;
+acc += Math.sin(8260) + Math.cos(8261) * 15;
+acc += Math.sin(8261) + Math.cos(8262) * 16;
+acc += Math.sin(8262) + Math.cos(8263) * 17;
+acc += Math.sin(8263) + Math.cos(8264) * 18;
+acc += Math.sin(8264) + Math.cos(8265) * 19;
+acc += Math.sin(8265) + Math.cos(8266) * 20;
+acc += Math.sin(8266) + Math.cos(8267) * 21;
+acc += Math.sin(8267) + Math.cos(8268) * 22;
+acc += Math.sin(8268) + Math.cos(8269) * 23;
+acc += Math.sin(8269) + Math.cos(8270) * 24;
+acc += Math.sin(8270) + Math.cos(8271) * 25;
+acc += Math.sin(8271) + Math.cos(8272) * 26;
+acc += Math.sin(8272) + Math.cos(8273) * 27;
+acc += Math.sin(8273) + Math.cos(8274) * 28;
+acc += Math.sin(8274) + Math.cos(8275) * 29;
+acc += Math.sin(8275) + Math.cos(8276) * 30;
+acc += Math.sin(8276) + Math.cos(8277) * 31;
+acc += Math.sin(8277) + Math.cos(8278) * 32;
+acc += Math.sin(8278) + Math.cos(8279) * 33;
+acc += Math.sin(8279) + Math.cos(8280) * 34;
+acc += Math.sin(8280) + Math.cos(8281) * 35;
+acc += Math.sin(8281) + Math.cos(8282) * 36;
+acc += Math.sin(8282) + Math.cos(8283) * 37;
+acc += Math.sin(8283) + Math.cos(8284) * 38;
+acc += Math.sin(8284) + Math.cos(8285) * 39;
+acc += Math.sin(8285) + Math.cos(8286) * 40;
+acc += Math.sin(8286) + Math.cos(8287) * 41;
+acc += Math.sin(8287) + Math.cos(8288) * 42;
+acc += Math.sin(8288) + Math.cos(8289) * 43;
+acc += Math.sin(8289) + Math.cos(8290) * 44;
+acc += Math.sin(8290) + Math.cos(8291) * 45;
+acc += Math.sin(8291) + Math.cos(8292) * 46;
+acc += Math.sin(8292) + Math.cos(8293) * 47;
+acc += Math.sin(8293) + Math.cos(8294) * 48;
+acc += Math.sin(8294) + Math.cos(8295) * 49;
+acc += Math.sin(8295) + Math.cos(8296) * 50;
+acc += Math.sin(8296) + Math.cos(8297) * 51;
+acc += Math.sin(8297) + Math.cos(8298) * 52;
+acc += Math.sin(8298) + Math.cos(8299) * 53;
+acc += Math.sin(8299) + Math.cos(8300) * 54;
+acc += Math.sin(8300) + Math.cos(8301) * 55;
+acc += Math.sin(8301) + Math.cos(8302) * 56;
+acc += Math.sin(8302) + Math.cos(8303) * 57;
+acc += Math.sin(8303) + Math.cos(8304) * 58;
+acc += Math.sin(8304) + Math.cos(8305) * 59;
+acc += Math.sin(8305) + Math.cos(8306) * 60;
+acc += Math.sin(8306) + Math.cos(8307) * 61;
+acc += Math.sin(8307) + Math.cos(8308) * 62;
+acc += Math.sin(8308) + Math.cos(8309) * 63;
+acc += Math.sin(8309) + Math.cos(8310) * 64;
+acc += Math.sin(8310) + Math.cos(8311) * 65;
+acc += Math.sin(8311) + Math.cos(8312) * 66;
+acc += Math.sin(8312) + Math.cos(8313) * 67;
+acc += Math.sin(8313) + Math.cos(8314) * 68;
+acc += Math.sin(8314) + Math.cos(8315) * 69;
+acc += Math.sin(8315) + Math.cos(8316) * 70;
+acc += Math.sin(8316) + Math.cos(8317) * 71;
+acc += Math.sin(8317) + Math.cos(8318) * 72;
+acc += Math.sin(8318) + Math.cos(8319) * 73;
+acc += Math.sin(8319) + Math.cos(8320) * 74;
+acc += Math.sin(8320) + Math.cos(8321) * 75;
+acc += Math.sin(8321) + Math.cos(8322) * 76;
+acc += Math.sin(8322) + Math.cos(8323) * 77;
+acc += Math.sin(8323) + Math.cos(8324) * 78;
+acc += Math.sin(8324) + Math.cos(8325) * 79;
+acc += Math.sin(8325) + Math.cos(8326) * 80;
+acc += Math.sin(8326) + Math.cos(8327) * 81;
+acc += Math.sin(8327) + Math.cos(8328) * 82;
+acc += Math.sin(8328) + Math.cos(8329) * 83;
+acc += Math.sin(8329) + Math.cos(8330) * 84;
+acc += Math.sin(8330) + Math.cos(8331) * 85;
+acc += Math.sin(8331) + Math.cos(8332) * 86;
+acc += Math.sin(8332) + Math.cos(8333) * 87;
+acc += Math.sin(8333) + Math.cos(8334) * 88;
+acc += Math.sin(8334) + Math.cos(8335) * 89;
+acc += Math.sin(8335) + Math.cos(8336) * 90;
+acc += Math.sin(8336) + Math.cos(8337) * 91;
+acc += Math.sin(8337) + Math.cos(8338) * 92;
+acc += Math.sin(8338) + Math.cos(8339) * 93;
+acc += Math.sin(8339) + Math.cos(8340) * 94;
+acc += Math.sin(8340) + Math.cos(8341) * 95;
+acc += Math.sin(8341) + Math.cos(8342) * 96;
+acc += Math.sin(8342) + Math.cos(8343) * 0;
+acc += Math.sin(8343) + Math.cos(8344) * 1;
+acc += Math.sin(8344) + Math.cos(8345) * 2;
+acc += Math.sin(8345) + Math.cos(8346) * 3;
+acc += Math.sin(8346) + Math.cos(8347) * 4;
+acc += Math.sin(8347) + Math.cos(8348) * 5;
+acc += Math.sin(8348) + Math.cos(8349) * 6;
+acc += Math.sin(8349) + Math.cos(8350) * 7;
+acc += Math.sin(8350) + Math.cos(8351) * 8;
+acc += Math.sin(8351) + Math.cos(8352) * 9;
+acc += Math.sin(8352) + Math.cos(8353) * 10;
+acc += Math.sin(8353) + Math.cos(8354) * 11;
+acc += Math.sin(8354) + Math.cos(8355) * 12;
+acc += Math.sin(8355) + Math.cos(8356) * 13;
+acc += Math.sin(8356) + Math.cos(8357) * 14;
+acc += Math.sin(8357) + Math.cos(8358) * 15;
+acc += Math.sin(8358) + Math.cos(8359) * 16;
+acc += Math.sin(8359) + Math.cos(8360) * 17;
+acc += Math.sin(8360) + Math.cos(8361) * 18;
+acc += Math.sin(8361) + Math.cos(8362) * 19;
+acc += Math.sin(8362) + Math.cos(8363) * 20;
+acc += Math.sin(8363) + Math.cos(8364) * 21;
+acc += Math.sin(8364) + Math.cos(8365) * 22;
+acc += Math.sin(8365) + Math.cos(8366) * 23;
+acc += Math.sin(8366) + Math.cos(8367) * 24;
+acc += Math.sin(8367) + Math.cos(8368) * 25;
+acc += Math.sin(8368) + Math.cos(8369) * 26;
+acc += Math.sin(8369) + Math.cos(8370) * 27;
+acc += Math.sin(8370) + Math.cos(8371) * 28;
+acc += Math.sin(8371) + Math.cos(8372) * 29;
+acc += Math.sin(8372) + Math.cos(8373) * 30;
+acc += Math.sin(8373) + Math.cos(8374) * 31;
+acc += Math.sin(8374) + Math.cos(8375) * 32;
+acc += Math.sin(8375) + Math.cos(8376) * 33;
+acc += Math.sin(8376) + Math.cos(8377) * 34;
+acc += Math.sin(8377) + Math.cos(8378) * 35;
+acc += Math.sin(8378) + Math.cos(8379) * 36;
+acc += Math.sin(8379) + Math.cos(8380) * 37;
+acc += Math.sin(8380) + Math.cos(8381) * 38;
+acc += Math.sin(8381) + Math.cos(8382) * 39;
+acc += Math.sin(8382) + Math.cos(8383) * 40;
+acc += Math.sin(8383) + Math.cos(8384) * 41;
+acc += Math.sin(8384) + Math.cos(8385) * 42;
+acc += Math.sin(8385) + Math.cos(8386) * 43;
+acc += Math.sin(8386) + Math.cos(8387) * 44;
+acc += Math.sin(8387) + Math.cos(8388) * 45;
+acc += Math.sin(8388) + Math.cos(8389) * 46;
+acc += Math.sin(8389) + Math.cos(8390) * 47;
+acc += Math.sin(8390) + Math.cos(8391) * 48;
+acc += Math.sin(8391) + Math.cos(8392) * 49;
+acc += Math.sin(8392) + Math.cos(8393) * 50;
+acc += Math.sin(8393) + Math.cos(8394) * 51;
+acc += Math.sin(8394) + Math.cos(8395) * 52;
+acc += Math.sin(8395) + Math.cos(8396) * 53;
+acc += Math.sin(8396) + Math.cos(8397) * 54;
+acc += Math.sin(8397) + Math.cos(8398) * 55;
+acc += Math.sin(8398) + Math.cos(8399) * 56;
+acc += Math.sin(8399) + Math.cos(8400) * 57;
+acc += Math.sin(8400) + Math.cos(8401) * 58;
+acc += Math.sin(8401) + Math.cos(8402) * 59;
+acc += Math.sin(8402) + Math.cos(8403) * 60;
+acc += Math.sin(8403) + Math.cos(8404) * 61;
+acc += Math.sin(8404) + Math.cos(8405) * 62;
+acc += Math.sin(8405) + Math.cos(8406) * 63;
+acc += Math.sin(8406) + Math.cos(8407) * 64;
+acc += Math.sin(8407) + Math.cos(8408) * 65;
+acc += Math.sin(8408) + Math.cos(8409) * 66;
+acc += Math.sin(8409) + Math.cos(8410) * 67;
+acc += Math.sin(8410) + Math.cos(8411) * 68;
+acc += Math.sin(8411) + Math.cos(8412) * 69;
+acc += Math.sin(8412) + Math.cos(8413) * 70;
+acc += Math.sin(8413) + Math.cos(8414) * 71;
+acc += Math.sin(8414) + Math.cos(8415) * 72;
+acc += Math.sin(8415) + Math.cos(8416) * 73;
+acc += Math.sin(8416) + Math.cos(8417) * 74;
+acc += Math.sin(8417) + Math.cos(8418) * 75;
+acc += Math.sin(8418) + Math.cos(8419) * 76;
+acc += Math.sin(8419) + Math.cos(8420) * 77;
+acc += Math.sin(8420) + Math.cos(8421) * 78;
+acc += Math.sin(8421) + Math.cos(8422) * 79;
+acc += Math.sin(8422) + Math.cos(8423) * 80;
+acc += Math.sin(8423) + Math.cos(8424) * 81;
+acc += Math.sin(8424) + Math.cos(8425) * 82;
+acc += Math.sin(8425) + Math.cos(8426) * 83;
+acc += Math.sin(8426) + Math.cos(8427) * 84;
+acc += Math.sin(8427) + Math.cos(8428) * 85;
+acc += Math.sin(8428) + Math.cos(8429) * 86;
+acc += Math.sin(8429) + Math.cos(8430) * 87;
+acc += Math.sin(8430) + Math.cos(8431) * 88;
+acc += Math.sin(8431) + Math.cos(8432) * 89;
+acc += Math.sin(8432) + Math.cos(8433) * 90;
+acc += Math.sin(8433) + Math.cos(8434) * 91;
+acc += Math.sin(8434) + Math.cos(8435) * 92;
+acc += Math.sin(8435) + Math.cos(8436) * 93;
+acc += Math.sin(8436) + Math.cos(8437) * 94;
+acc += Math.sin(8437) + Math.cos(8438) * 95;
+acc += Math.sin(8438) + Math.cos(8439) * 96;
+acc += Math.sin(8439) + Math.cos(8440) * 0;
+acc += Math.sin(8440) + Math.cos(8441) * 1;
+acc += Math.sin(8441) + Math.cos(8442) * 2;
+acc += Math.sin(8442) + Math.cos(8443) * 3;
+acc += Math.sin(8443) + Math.cos(8444) * 4;
+acc += Math.sin(8444) + Math.cos(8445) * 5;
+acc += Math.sin(8445) + Math.cos(8446) * 6;
+acc += Math.sin(8446) + Math.cos(8447) * 7;
+acc += Math.sin(8447) + Math.cos(8448) * 8;
+acc += Math.sin(8448) + Math.cos(8449) * 9;
+acc += Math.sin(8449) + Math.cos(8450) * 10;
+acc += Math.sin(8450) + Math.cos(8451) * 11;
+acc += Math.sin(8451) + Math.cos(8452) * 12;
+acc += Math.sin(8452) + Math.cos(8453) * 13;
+acc += Math.sin(8453) + Math.cos(8454) * 14;
+acc += Math.sin(8454) + Math.cos(8455) * 15;
+acc += Math.sin(8455) + Math.cos(8456) * 16;
+acc += Math.sin(8456) + Math.cos(8457) * 17;
+acc += Math.sin(8457) + Math.cos(8458) * 18;
+acc += Math.sin(8458) + Math.cos(8459) * 19;
+acc += Math.sin(8459) + Math.cos(8460) * 20;
+acc += Math.sin(8460) + Math.cos(8461) * 21;
+acc += Math.sin(8461) + Math.cos(8462) * 22;
+acc += Math.sin(8462) + Math.cos(8463) * 23;
+acc += Math.sin(8463) + Math.cos(8464) * 24;
+acc += Math.sin(8464) + Math.cos(8465) * 25;
+acc += Math.sin(8465) + Math.cos(8466) * 26;
+acc += Math.sin(8466) + Math.cos(8467) * 27;
+acc += Math.sin(8467) + Math.cos(8468) * 28;
+acc += Math.sin(8468) + Math.cos(8469) * 29;
+acc += Math.sin(8469) + Math.cos(8470) * 30;
+acc += Math.sin(8470) + Math.cos(8471) * 31;
+acc += Math.sin(8471) + Math.cos(8472) * 32;
+acc += Math.sin(8472) + Math.cos(8473) * 33;
+acc += Math.sin(8473) + Math.cos(8474) * 34;
+acc += Math.sin(8474) + Math.cos(8475) * 35;
+acc += Math.sin(8475) + Math.cos(8476) * 36;
+acc += Math.sin(8476) + Math.cos(8477) * 37;
+acc += Math.sin(8477) + Math.cos(8478) * 38;
+acc += Math.sin(8478) + Math.cos(8479) * 39;
+acc += Math.sin(8479) + Math.cos(8480) * 40;
+acc += Math.sin(8480) + Math.cos(8481) * 41;
+acc += Math.sin(8481) + Math.cos(8482) * 42;
+acc += Math.sin(8482) + Math.cos(8483) * 43;
+acc += Math.sin(8483) + Math.cos(8484) * 44;
+acc += Math.sin(8484) + Math.cos(8485) * 45;
+acc += Math.sin(8485) + Math.cos(8486) * 46;
+acc += Math.sin(8486) + Math.cos(8487) * 47;
+acc += Math.sin(8487) + Math.cos(8488) * 48;
+acc += Math.sin(8488) + Math.cos(8489) * 49;
+acc += Math.sin(8489) + Math.cos(8490) * 50;
+acc += Math.sin(8490) + Math.cos(8491) * 51;
+acc += Math.sin(8491) + Math.cos(8492) * 52;
+acc += Math.sin(8492) + Math.cos(8493) * 53;
+acc += Math.sin(8493) + Math.cos(8494) * 54;
+acc += Math.sin(8494) + Math.cos(8495) * 55;
+acc += Math.sin(8495) + Math.cos(8496) * 56;
+acc += Math.sin(8496) + Math.cos(8497) * 57;
+acc += Math.sin(8497) + Math.cos(8498) * 58;
+acc += Math.sin(8498) + Math.cos(8499) * 59;
+acc += Math.sin(8499) + Math.cos(8500) * 60;
+acc += Math.sin(8500) + Math.cos(8501) * 61;
+acc += Math.sin(8501) + Math.cos(8502) * 62;
+acc += Math.sin(8502) + Math.cos(8503) * 63;
+acc += Math.sin(8503) + Math.cos(8504) * 64;
+acc += Math.sin(8504) + Math.cos(8505) * 65;
+acc += Math.sin(8505) + Math.cos(8506) * 66;
+acc += Math.sin(8506) + Math.cos(8507) * 67;
+acc += Math.sin(8507) + Math.cos(8508) * 68;
+acc += Math.sin(8508) + Math.cos(8509) * 69;
+acc += Math.sin(8509) + Math.cos(8510) * 70;
+acc += Math.sin(8510) + Math.cos(8511) * 71;
+acc += Math.sin(8511) + Math.cos(8512) * 72;
+acc += Math.sin(8512) + Math.cos(8513) * 73;
+acc += Math.sin(8513) + Math.cos(8514) * 74;
+acc += Math.sin(8514) + Math.cos(8515) * 75;
+acc += Math.sin(8515) + Math.cos(8516) * 76;
+acc += Math.sin(8516) + Math.cos(8517) * 77;
+acc += Math.sin(8517) + Math.cos(8518) * 78;
+acc += Math.sin(8518) + Math.cos(8519) * 79;
+acc += Math.sin(8519) + Math.cos(8520) * 80;
+acc += Math.sin(8520) + Math.cos(8521) * 81;
+acc += Math.sin(8521) + Math.cos(8522) * 82;
+acc += Math.sin(8522) + Math.cos(8523) * 83;
+acc += Math.sin(8523) + Math.cos(8524) * 84;
+acc += Math.sin(8524) + Math.cos(8525) * 85;
+acc += Math.sin(8525) + Math.cos(8526) * 86;
+acc += Math.sin(8526) + Math.cos(8527) * 87;
+acc += Math.sin(8527) + Math.cos(8528) * 88;
+acc += Math.sin(8528) + Math.cos(8529) * 89;
+acc += Math.sin(8529) + Math.cos(8530) * 90;
+acc += Math.sin(8530) + Math.cos(8531) * 91;
+acc += Math.sin(8531) + Math.cos(8532) * 92;
+acc += Math.sin(8532) + Math.cos(8533) * 93;
+acc += Math.sin(8533) + Math.cos(8534) * 94;
+acc += Math.sin(8534) + Math.cos(8535) * 95;
+acc += Math.sin(8535) + Math.cos(8536) * 96;
+acc += Math.sin(8536) + Math.cos(8537) * 0;
+acc += Math.sin(8537) + Math.cos(8538) * 1;
+acc += Math.sin(8538) + Math.cos(8539) * 2;
+acc += Math.sin(8539) + Math.cos(8540) * 3;
+acc += Math.sin(8540) + Math.cos(8541) * 4;
+acc += Math.sin(8541) + Math.cos(8542) * 5;
+acc += Math.sin(8542) + Math.cos(8543) * 6;
+acc += Math.sin(8543) + Math.cos(8544) * 7;
+acc += Math.sin(8544) + Math.cos(8545) * 8;
+acc += Math.sin(8545) + Math.cos(8546) * 9;
+acc += Math.sin(8546) + Math.cos(8547) * 10;
+acc += Math.sin(8547) + Math.cos(8548) * 11;
+acc += Math.sin(8548) + Math.cos(8549) * 12;
+acc += Math.sin(8549) + Math.cos(8550) * 13;
+acc += Math.sin(8550) + Math.cos(8551) * 14;
+acc += Math.sin(8551) + Math.cos(8552) * 15;
+acc += Math.sin(8552) + Math.cos(8553) * 16;
+acc += Math.sin(8553) + Math.cos(8554) * 17;
+acc += Math.sin(8554) + Math.cos(8555) * 18;
+acc += Math.sin(8555) + Math.cos(8556) * 19;
+acc += Math.sin(8556) + Math.cos(8557) * 20;
+acc += Math.sin(8557) + Math.cos(8558) * 21;
+acc += Math.sin(8558) + Math.cos(8559) * 22;
+acc += Math.sin(8559) + Math.cos(8560) * 23;
+acc += Math.sin(8560) + Math.cos(8561) * 24;
+acc += Math.sin(8561) + Math.cos(8562) * 25;
+acc += Math.sin(8562) + Math.cos(8563) * 26;
+acc += Math.sin(8563) + Math.cos(8564) * 27;
+acc += Math.sin(8564) + Math.cos(8565) * 28;
+acc += Math.sin(8565) + Math.cos(8566) * 29;
+acc += Math.sin(8566) + Math.cos(8567) * 30;
+acc += Math.sin(8567) + Math.cos(8568) * 31;
+acc += Math.sin(8568) + Math.cos(8569) * 32;
+acc += Math.sin(8569) + Math.cos(8570) * 33;
+acc += Math.sin(8570) + Math.cos(8571) * 34;
+acc += Math.sin(8571) + Math.cos(8572) * 35;
+acc += Math.sin(8572) + Math.cos(8573) * 36;
+acc += Math.sin(8573) + Math.cos(8574) * 37;
+acc += Math.sin(8574) + Math.cos(8575) * 38;
+acc += Math.sin(8575) + Math.cos(8576) * 39;
+acc += Math.sin(8576) + Math.cos(8577) * 40;
+acc += Math.sin(8577) + Math.cos(8578) * 41;
+acc += Math.sin(8578) + Math.cos(8579) * 42;
+acc += Math.sin(8579) + Math.cos(8580) * 43;
+acc += Math.sin(8580) + Math.cos(8581) * 44;
+acc += Math.sin(8581) + Math.cos(8582) * 45;
+acc += Math.sin(8582) + Math.cos(8583) * 46;
+acc += Math.sin(8583) + Math.cos(8584) * 47;
+acc += Math.sin(8584) + Math.cos(8585) * 48;
+acc += Math.sin(8585) + Math.cos(8586) * 49;
+acc += Math.sin(8586) + Math.cos(8587) * 50;
+acc += Math.sin(8587) + Math.cos(8588) * 51;
+acc += Math.sin(8588) + Math.cos(8589) * 52;
+acc += Math.sin(8589) + Math.cos(8590) * 53;
+acc += Math.sin(8590) + Math.cos(8591) * 54;
+acc += Math.sin(8591) + Math.cos(8592) * 55;
+acc += Math.sin(8592) + Math.cos(8593) * 56;
+acc += Math.sin(8593) + Math.cos(8594) * 57;
+acc += Math.sin(8594) + Math.cos(8595) * 58;
+acc += Math.sin(8595) + Math.cos(8596) * 59;
+acc += Math.sin(8596) + Math.cos(8597) * 60;
+acc += Math.sin(8597) + Math.cos(8598) * 61;
+acc += Math.sin(8598) + Math.cos(8599) * 62;
+acc += Math.sin(8599) + Math.cos(8600) * 63;
+acc += Math.sin(8600) + Math.cos(8601) * 64;
+acc += Math.sin(8601) + Math.cos(8602) * 65;
+acc += Math.sin(8602) + Math.cos(8603) * 66;
+acc += Math.sin(8603) + Math.cos(8604) * 67;
+acc += Math.sin(8604) + Math.cos(8605) * 68;
+acc += Math.sin(8605) + Math.cos(8606) * 69;
+acc += Math.sin(8606) + Math.cos(8607) * 70;
+acc += Math.sin(8607) + Math.cos(8608) * 71;
+acc += Math.sin(8608) + Math.cos(8609) * 72;
+acc += Math.sin(8609) + Math.cos(8610) * 73;
+acc += Math.sin(8610) + Math.cos(8611) * 74;
+acc += Math.sin(8611) + Math.cos(8612) * 75;
+acc += Math.sin(8612) + Math.cos(8613) * 76;
+acc += Math.sin(8613) + Math.cos(8614) * 77;
+acc += Math.sin(8614) + Math.cos(8615) * 78;
+acc += Math.sin(8615) + Math.cos(8616) * 79;
+acc += Math.sin(8616) + Math.cos(8617) * 80;
+acc += Math.sin(8617) + Math.cos(8618) * 81;
+acc += Math.sin(8618) + Math.cos(8619) * 82;
+acc += Math.sin(8619) + Math.cos(8620) * 83;
+acc += Math.sin(8620) + Math.cos(8621) * 84;
+acc += Math.sin(8621) + Math.cos(8622) * 85;
+acc += Math.sin(8622) + Math.cos(8623) * 86;
+acc += Math.sin(8623) + Math.cos(8624) * 87;
+acc += Math.sin(8624) + Math.cos(8625) * 88;
+acc += Math.sin(8625) + Math.cos(8626) * 89;
+acc += Math.sin(8626) + Math.cos(8627) * 90;
+acc += Math.sin(8627) + Math.cos(8628) * 91;
+acc += Math.sin(8628) + Math.cos(8629) * 92;
+acc += Math.sin(8629) + Math.cos(8630) * 93;
+acc += Math.sin(8630) + Math.cos(8631) * 94;
+acc += Math.sin(8631) + Math.cos(8632) * 95;
+acc += Math.sin(8632) + Math.cos(8633) * 96;
+acc += Math.sin(8633) + Math.cos(8634) * 0;
+acc += Math.sin(8634) + Math.cos(8635) * 1;
+acc += Math.sin(8635) + Math.cos(8636) * 2;
+acc += Math.sin(8636) + Math.cos(8637) * 3;
+acc += Math.sin(8637) + Math.cos(8638) * 4;
+acc += Math.sin(8638) + Math.cos(8639) * 5;
+acc += Math.sin(8639) + Math.cos(8640) * 6;
+acc += Math.sin(8640) + Math.cos(8641) * 7;
+acc += Math.sin(8641) + Math.cos(8642) * 8;
+acc += Math.sin(8642) + Math.cos(8643) * 9;
+acc += Math.sin(8643) + Math.cos(8644) * 10;
+acc += Math.sin(8644) + Math.cos(8645) * 11;
+acc += Math.sin(8645) + Math.cos(8646) * 12;
+acc += Math.sin(8646) + Math.cos(8647) * 13;
+acc += Math.sin(8647) + Math.cos(8648) * 14;
+acc += Math.sin(8648) + Math.cos(8649) * 15;
+acc += Math.sin(8649) + Math.cos(8650) * 16;
+acc += Math.sin(8650) + Math.cos(8651) * 17;
+acc += Math.sin(8651) + Math.cos(8652) * 18;
+acc += Math.sin(8652) + Math.cos(8653) * 19;
+acc += Math.sin(8653) + Math.cos(8654) * 20;
+acc += Math.sin(8654) + Math.cos(8655) * 21;
+acc += Math.sin(8655) + Math.cos(8656) * 22;
+acc += Math.sin(8656) + Math.cos(8657) * 23;
+acc += Math.sin(8657) + Math.cos(8658) * 24;
+acc += Math.sin(8658) + Math.cos(8659) * 25;
+acc += Math.sin(8659) + Math.cos(8660) * 26;
+acc += Math.sin(8660) + Math.cos(8661) * 27;
+acc += Math.sin(8661) + Math.cos(8662) * 28;
+acc += Math.sin(8662) + Math.cos(8663) * 29;
+acc += Math.sin(8663) + Math.cos(8664) * 30;
+acc += Math.sin(8664) + Math.cos(8665) * 31;
+acc += Math.sin(8665) + Math.cos(8666) * 32;
+acc += Math.sin(8666) + Math.cos(8667) * 33;
+acc += Math.sin(8667) + Math.cos(8668) * 34;
+acc += Math.sin(8668) + Math.cos(8669) * 35;
+acc += Math.sin(8669) + Math.cos(8670) * 36;
+acc += Math.sin(8670) + Math.cos(8671) * 37;
+acc += Math.sin(8671) + Math.cos(8672) * 38;
+acc += Math.sin(8672) + Math.cos(8673) * 39;
+acc += Math.sin(8673) + Math.cos(8674) * 40;
+acc += Math.sin(8674) + Math.cos(8675) * 41;
+acc += Math.sin(8675) + Math.cos(8676) * 42;
+acc += Math.sin(8676) + Math.cos(8677) * 43;
+acc += Math.sin(8677) + Math.cos(8678) * 44;
+acc += Math.sin(8678) + Math.cos(8679) * 45;
+acc += Math.sin(8679) + Math.cos(8680) * 46;
+acc += Math.sin(8680) + Math.cos(8681) * 47;
+acc += Math.sin(8681) + Math.cos(8682) * 48;
+acc += Math.sin(8682) + Math.cos(8683) * 49;
+acc += Math.sin(8683) + Math.cos(8684) * 50;
+acc += Math.sin(8684) + Math.cos(8685) * 51;
+acc += Math.sin(8685) + Math.cos(8686) * 52;
+acc += Math.sin(8686) + Math.cos(8687) * 53;
+acc += Math.sin(8687) + Math.cos(8688) * 54;
+acc += Math.sin(8688) + Math.cos(8689) * 55;
+acc += Math.sin(8689) + Math.cos(8690) * 56;
+acc += Math.sin(8690) + Math.cos(8691) * 57;
+acc += Math.sin(8691) + Math.cos(8692) * 58;
+acc += Math.sin(8692) + Math.cos(8693) * 59;
+acc += Math.sin(8693) + Math.cos(8694) * 60;
+acc += Math.sin(8694) + Math.cos(8695) * 61;
+acc += Math.sin(8695) + Math.cos(8696) * 62;
+acc += Math.sin(8696) + Math.cos(8697) * 63;
+acc += Math.sin(8697) + Math.cos(8698) * 64;
+acc += Math.sin(8698) + Math.cos(8699) * 65;
+acc += Math.sin(8699) + Math.cos(8700) * 66;
+acc += Math.sin(8700) + Math.cos(8701) * 67;
+acc += Math.sin(8701) + Math.cos(8702) * 68;
+acc += Math.sin(8702) + Math.cos(8703) * 69;
+acc += Math.sin(8703) + Math.cos(8704) * 70;
+acc += Math.sin(8704) + Math.cos(8705) * 71;
+acc += Math.sin(8705) + Math.cos(8706) * 72;
+acc += Math.sin(8706) + Math.cos(8707) * 73;
+acc += Math.sin(8707) + Math.cos(8708) * 74;
+acc += Math.sin(8708) + Math.cos(8709) * 75;
+acc += Math.sin(8709) + Math.cos(8710) * 76;
+acc += Math.sin(8710) + Math.cos(8711) * 77;
+acc += Math.sin(8711) + Math.cos(8712) * 78;
+acc += Math.sin(8712) + Math.cos(8713) * 79;
+acc += Math.sin(8713) + Math.cos(8714) * 80;
+acc += Math.sin(8714) + Math.cos(8715) * 81;
+acc += Math.sin(8715) + Math.cos(8716) * 82;
+acc += Math.sin(8716) + Math.cos(8717) * 83;
+acc += Math.sin(8717) + Math.cos(8718) * 84;
+acc += Math.sin(8718) + Math.cos(8719) * 85;
+acc += Math.sin(8719) + Math.cos(8720) * 86;
+acc += Math.sin(8720) + Math.cos(8721) * 87;
+acc += Math.sin(8721) + Math.cos(8722) * 88;
+acc += Math.sin(8722) + Math.cos(8723) * 89;
+acc += Math.sin(8723) + Math.cos(8724) * 90;
+acc += Math.sin(8724) + Math.cos(8725) * 91;
+acc += Math.sin(8725) + Math.cos(8726) * 92;
+acc += Math.sin(8726) + Math.cos(8727) * 93;
+acc += Math.sin(8727) + Math.cos(8728) * 94;
+acc += Math.sin(8728) + Math.cos(8729) * 95;
+acc += Math.sin(8729) + Math.cos(8730) * 96;
+acc += Math.sin(8730) + Math.cos(8731) * 0;
+acc += Math.sin(8731) + Math.cos(8732) * 1;
+acc += Math.sin(8732) + Math.cos(8733) * 2;
+acc += Math.sin(8733) + Math.cos(8734) * 3;
+acc += Math.sin(8734) + Math.cos(8735) * 4;
+acc += Math.sin(8735) + Math.cos(8736) * 5;
+acc += Math.sin(8736) + Math.cos(8737) * 6;
+acc += Math.sin(8737) + Math.cos(8738) * 7;
+acc += Math.sin(8738) + Math.cos(8739) * 8;
+acc += Math.sin(8739) + Math.cos(8740) * 9;
+acc += Math.sin(8740) + Math.cos(8741) * 10;
+acc += Math.sin(8741) + Math.cos(8742) * 11;
+acc += Math.sin(8742) + Math.cos(8743) * 12;
+acc += Math.sin(8743) + Math.cos(8744) * 13;
+acc += Math.sin(8744) + Math.cos(8745) * 14;
+acc += Math.sin(8745) + Math.cos(8746) * 15;
+acc += Math.sin(8746) + Math.cos(8747) * 16;
+acc += Math.sin(8747) + Math.cos(8748) * 17;
+acc += Math.sin(8748) + Math.cos(8749) * 18;
+acc += Math.sin(8749) + Math.cos(8750) * 19;
+acc += Math.sin(8750) + Math.cos(8751) * 20;
+acc += Math.sin(8751) + Math.cos(8752) * 21;
+acc += Math.sin(8752) + Math.cos(8753) * 22;
+acc += Math.sin(8753) + Math.cos(8754) * 23;
+acc += Math.sin(8754) + Math.cos(8755) * 24;
+acc += Math.sin(8755) + Math.cos(8756) * 25;
+acc += Math.sin(8756) + Math.cos(8757) * 26;
+acc += Math.sin(8757) + Math.cos(8758) * 27;
+acc += Math.sin(8758) + Math.cos(8759) * 28;
+acc += Math.sin(8759) + Math.cos(8760) * 29;
+acc += Math.sin(8760) + Math.cos(8761) * 30;
+acc += Math.sin(8761) + Math.cos(8762) * 31;
+acc += Math.sin(8762) + Math.cos(8763) * 32;
+acc += Math.sin(8763) + Math.cos(8764) * 33;
+acc += Math.sin(8764) + Math.cos(8765) * 34;
+acc += Math.sin(8765) + Math.cos(8766) * 35;
+acc += Math.sin(8766) + Math.cos(8767) * 36;
+acc += Math.sin(8767) + Math.cos(8768) * 37;
+acc += Math.sin(8768) + Math.cos(8769) * 38;
+acc += Math.sin(8769) + Math.cos(8770) * 39;
+acc += Math.sin(8770) + Math.cos(8771) * 40;
+acc += Math.sin(8771) + Math.cos(8772) * 41;
+acc += Math.sin(8772) + Math.cos(8773) * 42;
+acc += Math.sin(8773) + Math.cos(8774) * 43;
+acc += Math.sin(8774) + Math.cos(8775) * 44;
+acc += Math.sin(8775) + Math.cos(8776) * 45;
+acc += Math.sin(8776) + Math.cos(8777) * 46;
+acc += Math.sin(8777) + Math.cos(8778) * 47;
+acc += Math.sin(8778) + Math.cos(8779) * 48;
+acc += Math.sin(8779) + Math.cos(8780) * 49;
+acc += Math.sin(8780) + Math.cos(8781) * 50;
+acc += Math.sin(8781) + Math.cos(8782) * 51;
+acc += Math.sin(8782) + Math.cos(8783) * 52;
+acc += Math.sin(8783) + Math.cos(8784) * 53;
+acc += Math.sin(8784) + Math.cos(8785) * 54;
+acc += Math.sin(8785) + Math.cos(8786) * 55;
+acc += Math.sin(8786) + Math.cos(8787) * 56;
+acc += Math.sin(8787) + Math.cos(8788) * 57;
+acc += Math.sin(8788) + Math.cos(8789) * 58;
+acc += Math.sin(8789) + Math.cos(8790) * 59;
+acc += Math.sin(8790) + Math.cos(8791) * 60;
+acc += Math.sin(8791) + Math.cos(8792) * 61;
+acc += Math.sin(8792) + Math.cos(8793) * 62;
+acc += Math.sin(8793) + Math.cos(8794) * 63;
+acc += Math.sin(8794) + Math.cos(8795) * 64;
+acc += Math.sin(8795) + Math.cos(8796) * 65;
+acc += Math.sin(8796) + Math.cos(8797) * 66;
+acc += Math.sin(8797) + Math.cos(8798) * 67;
+acc += Math.sin(8798) + Math.cos(8799) * 68;
+acc += Math.sin(8799) + Math.cos(8800) * 69;
+acc += Math.sin(8800) + Math.cos(8801) * 70;
+acc += Math.sin(8801) + Math.cos(8802) * 71;
+acc += Math.sin(8802) + Math.cos(8803) * 72;
+acc += Math.sin(8803) + Math.cos(8804) * 73;
+acc += Math.sin(8804) + Math.cos(8805) * 74;
+acc += Math.sin(8805) + Math.cos(8806) * 75;
+acc += Math.sin(8806) + Math.cos(8807) * 76;
+acc += Math.sin(8807) + Math.cos(8808) * 77;
+acc += Math.sin(8808) + Math.cos(8809) * 78;
+acc += Math.sin(8809) + Math.cos(8810) * 79;
+acc += Math.sin(8810) + Math.cos(8811) * 80;
+acc += Math.sin(8811) + Math.cos(8812) * 81;
+acc += Math.sin(8812) + Math.cos(8813) * 82;
+acc += Math.sin(8813) + Math.cos(8814) * 83;
+acc += Math.sin(8814) + Math.cos(8815) * 84;
+acc += Math.sin(8815) + Math.cos(8816) * 85;
+acc += Math.sin(8816) + Math.cos(8817) * 86;
+acc += Math.sin(8817) + Math.cos(8818) * 87;
+acc += Math.sin(8818) + Math.cos(8819) * 88;
+acc += Math.sin(8819) + Math.cos(8820) * 89;
+acc += Math.sin(8820) + Math.cos(8821) * 90;
+acc += Math.sin(8821) + Math.cos(8822) * 91;
+acc += Math.sin(8822) + Math.cos(8823) * 92;
+acc += Math.sin(8823) + Math.cos(8824) * 93;
+acc += Math.sin(8824) + Math.cos(8825) * 94;
+acc += Math.sin(8825) + Math.cos(8826) * 95;
+acc += Math.sin(8826) + Math.cos(8827) * 96;
+acc += Math.sin(8827) + Math.cos(8828) * 0;
+acc += Math.sin(8828) + Math.cos(8829) * 1;
+acc += Math.sin(8829) + Math.cos(8830) * 2;
+acc += Math.sin(8830) + Math.cos(8831) * 3;
+acc += Math.sin(8831) + Math.cos(8832) * 4;
+acc += Math.sin(8832) + Math.cos(8833) * 5;
+acc += Math.sin(8833) + Math.cos(8834) * 6;
+acc += Math.sin(8834) + Math.cos(8835) * 7;
+acc += Math.sin(8835) + Math.cos(8836) * 8;
+acc += Math.sin(8836) + Math.cos(8837) * 9;
+acc += Math.sin(8837) + Math.cos(8838) * 10;
+acc += Math.sin(8838) + Math.cos(8839) * 11;
+acc += Math.sin(8839) + Math.cos(8840) * 12;
+acc += Math.sin(8840) + Math.cos(8841) * 13;
+acc += Math.sin(8841) + Math.cos(8842) * 14;
+acc += Math.sin(8842) + Math.cos(8843) * 15;
+acc += Math.sin(8843) + Math.cos(8844) * 16;
+acc += Math.sin(8844) + Math.cos(8845) * 17;
+acc += Math.sin(8845) + Math.cos(8846) * 18;
+acc += Math.sin(8846) + Math.cos(8847) * 19;
+acc += Math.sin(8847) + Math.cos(8848) * 20;
+acc += Math.sin(8848) + Math.cos(8849) * 21;
+acc += Math.sin(8849) + Math.cos(8850) * 22;
+acc += Math.sin(8850) + Math.cos(8851) * 23;
+acc += Math.sin(8851) + Math.cos(8852) * 24;
+acc += Math.sin(8852) + Math.cos(8853) * 25;
+acc += Math.sin(8853) + Math.cos(8854) * 26;
+acc += Math.sin(8854) + Math.cos(8855) * 27;
+acc += Math.sin(8855) + Math.cos(8856) * 28;
+acc += Math.sin(8856) + Math.cos(8857) * 29;
+acc += Math.sin(8857) + Math.cos(8858) * 30;
+acc += Math.sin(8858) + Math.cos(8859) * 31;
+acc += Math.sin(8859) + Math.cos(8860) * 32;
+acc += Math.sin(8860) + Math.cos(8861) * 33;
+acc += Math.sin(8861) + Math.cos(8862) * 34;
+acc += Math.sin(8862) + Math.cos(8863) * 35;
+acc += Math.sin(8863) + Math.cos(8864) * 36;
+acc += Math.sin(8864) + Math.cos(8865) * 37;
+acc += Math.sin(8865) + Math.cos(8866) * 38;
+acc += Math.sin(8866) + Math.cos(8867) * 39;
+acc += Math.sin(8867) + Math.cos(8868) * 40;
+acc += Math.sin(8868) + Math.cos(8869) * 41;
+acc += Math.sin(8869) + Math.cos(8870) * 42;
+acc += Math.sin(8870) + Math.cos(8871) * 43;
+acc += Math.sin(8871) + Math.cos(8872) * 44;
+acc += Math.sin(8872) + Math.cos(8873) * 45;
+acc += Math.sin(8873) + Math.cos(8874) * 46;
+acc += Math.sin(8874) + Math.cos(8875) * 47;
+acc += Math.sin(8875) + Math.cos(8876) * 48;
+acc += Math.sin(8876) + Math.cos(8877) * 49;
+acc += Math.sin(8877) + Math.cos(8878) * 50;
+acc += Math.sin(8878) + Math.cos(8879) * 51;
+acc += Math.sin(8879) + Math.cos(8880) * 52;
+acc += Math.sin(8880) + Math.cos(8881) * 53;
+acc += Math.sin(8881) + Math.cos(8882) * 54;
+acc += Math.sin(8882) + Math.cos(8883) * 55;
+acc += Math.sin(8883) + Math.cos(8884) * 56;
+acc += Math.sin(8884) + Math.cos(8885) * 57;
+acc += Math.sin(8885) + Math.cos(8886) * 58;
+acc += Math.sin(8886) + Math.cos(8887) * 59;
+acc += Math.sin(8887) + Math.cos(8888) * 60;
+acc += Math.sin(8888) + Math.cos(8889) * 61;
+acc += Math.sin(8889) + Math.cos(8890) * 62;
+acc += Math.sin(8890) + Math.cos(8891) * 63;
+acc += Math.sin(8891) + Math.cos(8892) * 64;
+acc += Math.sin(8892) + Math.cos(8893) * 65;
+acc += Math.sin(8893) + Math.cos(8894) * 66;
+acc += Math.sin(8894) + Math.cos(8895) * 67;
+acc += Math.sin(8895) + Math.cos(8896) * 68;
+acc += Math.sin(8896) + Math.cos(8897) * 69;
+acc += Math.sin(8897) + Math.cos(8898) * 70;
+acc += Math.sin(8898) + Math.cos(8899) * 71;
+acc += Math.sin(8899) + Math.cos(8900) * 72;
+acc += Math.sin(8900) + Math.cos(8901) * 73;
+acc += Math.sin(8901) + Math.cos(8902) * 74;
+acc += Math.sin(8902) + Math.cos(8903) * 75;
+acc += Math.sin(8903) + Math.cos(8904) * 76;
+acc += Math.sin(8904) + Math.cos(8905) * 77;
+acc += Math.sin(8905) + Math.cos(8906) * 78;
+acc += Math.sin(8906) + Math.cos(8907) * 79;
+acc += Math.sin(8907) + Math.cos(8908) * 80;
+acc += Math.sin(8908) + Math.cos(8909) * 81;
+acc += Math.sin(8909) + Math.cos(8910) * 82;
+acc += Math.sin(8910) + Math.cos(8911) * 83;
+acc += Math.sin(8911) + Math.cos(8912) * 84;
+acc += Math.sin(8912) + Math.cos(8913) * 85;
+acc += Math.sin(8913) + Math.cos(8914) * 86;
+acc += Math.sin(8914) + Math.cos(8915) * 87;
+acc += Math.sin(8915) + Math.cos(8916) * 88;
+acc += Math.sin(8916) + Math.cos(8917) * 89;
+acc += Math.sin(8917) + Math.cos(8918) * 90;
+acc += Math.sin(8918) + Math.cos(8919) * 91;
+acc += Math.sin(8919) + Math.cos(8920) * 92;
+acc += Math.sin(8920) + Math.cos(8921) * 93;
+acc += Math.sin(8921) + Math.cos(8922) * 94;
+acc += Math.sin(8922) + Math.cos(8923) * 95;
+acc += Math.sin(8923) + Math.cos(8924) * 96;
+acc += Math.sin(8924) + Math.cos(8925) * 0;
+acc += Math.sin(8925) + Math.cos(8926) * 1;
+acc += Math.sin(8926) + Math.cos(8927) * 2;
+acc += Math.sin(8927) + Math.cos(8928) * 3;
+acc += Math.sin(8928) + Math.cos(8929) * 4;
+acc += Math.sin(8929) + Math.cos(8930) * 5;
+acc += Math.sin(8930) + Math.cos(8931) * 6;
+acc += Math.sin(8931) + Math.cos(8932) * 7;
+acc += Math.sin(8932) + Math.cos(8933) * 8;
+acc += Math.sin(8933) + Math.cos(8934) * 9;
+acc += Math.sin(8934) + Math.cos(8935) * 10;
+acc += Math.sin(8935) + Math.cos(8936) * 11;
+acc += Math.sin(8936) + Math.cos(8937) * 12;
+acc += Math.sin(8937) + Math.cos(8938) * 13;
+acc += Math.sin(8938) + Math.cos(8939) * 14;
+acc += Math.sin(8939) + Math.cos(8940) * 15;
+acc += Math.sin(8940) + Math.cos(8941) * 16;
+acc += Math.sin(8941) + Math.cos(8942) * 17;
+acc += Math.sin(8942) + Math.cos(8943) * 18;
+acc += Math.sin(8943) + Math.cos(8944) * 19;
+acc += Math.sin(8944) + Math.cos(8945) * 20;
+acc += Math.sin(8945) + Math.cos(8946) * 21;
+acc += Math.sin(8946) + Math.cos(8947) * 22;
+acc += Math.sin(8947) + Math.cos(8948) * 23;
+acc += Math.sin(8948) + Math.cos(8949) * 24;
+acc += Math.sin(8949) + Math.cos(8950) * 25;
+acc += Math.sin(8950) + Math.cos(8951) * 26;
+acc += Math.sin(8951) + Math.cos(8952) * 27;
+acc += Math.sin(8952) + Math.cos(8953) * 28;
+acc += Math.sin(8953) + Math.cos(8954) * 29;
+acc += Math.sin(8954) + Math.cos(8955) * 30;
+acc += Math.sin(8955) + Math.cos(8956) * 31;
+acc += Math.sin(8956) + Math.cos(8957) * 32;
+acc += Math.sin(8957) + Math.cos(8958) * 33;
+acc += Math.sin(8958) + Math.cos(8959) * 34;
+acc += Math.sin(8959) + Math.cos(8960) * 35;
+acc += Math.sin(8960) + Math.cos(8961) * 36;
+acc += Math.sin(8961) + Math.cos(8962) * 37;
+acc += Math.sin(8962) + Math.cos(8963) * 38;
+acc += Math.sin(8963) + Math.cos(8964) * 39;
+acc += Math.sin(8964) + Math.cos(8965) * 40;
+acc += Math.sin(8965) + Math.cos(8966) * 41;
+acc += Math.sin(8966) + Math.cos(8967) * 42;
+acc += Math.sin(8967) + Math.cos(8968) * 43;
+acc += Math.sin(8968) + Math.cos(8969) * 44;
+acc += Math.sin(8969) + Math.cos(8970) * 45;
+acc += Math.sin(8970) + Math.cos(8971) * 46;
+acc += Math.sin(8971) + Math.cos(8972) * 47;
+acc += Math.sin(8972) + Math.cos(8973) * 48;
+acc += Math.sin(8973) + Math.cos(8974) * 49;
+acc += Math.sin(8974) + Math.cos(8975) * 50;
+acc += Math.sin(8975) + Math.cos(8976) * 51;
+acc += Math.sin(8976) + Math.cos(8977) * 52;
+acc += Math.sin(8977) + Math.cos(8978) * 53;
+acc += Math.sin(8978) + Math.cos(8979) * 54;
+acc += Math.sin(8979) + Math.cos(8980) * 55;
+acc += Math.sin(8980) + Math.cos(8981) * 56;
+acc += Math.sin(8981) + Math.cos(8982) * 57;
+acc += Math.sin(8982) + Math.cos(8983) * 58;
+acc += Math.sin(8983) + Math.cos(8984) * 59;
+acc += Math.sin(8984) + Math.cos(8985) * 60;
+acc += Math.sin(8985) + Math.cos(8986) * 61;
+acc += Math.sin(8986) + Math.cos(8987) * 62;
+acc += Math.sin(8987) + Math.cos(8988) * 63;
+acc += Math.sin(8988) + Math.cos(8989) * 64;
+acc += Math.sin(8989) + Math.cos(8990) * 65;
+acc += Math.sin(8990) + Math.cos(8991) * 66;
+acc += Math.sin(8991) + Math.cos(8992) * 67;
+acc += Math.sin(8992) + Math.cos(8993) * 68;
+acc += Math.sin(8993) + Math.cos(8994) * 69;
+acc += Math.sin(8994) + Math.cos(8995) * 70;
+acc += Math.sin(8995) + Math.cos(8996) * 71;
+acc += Math.sin(8996) + Math.cos(8997) * 72;
+acc += Math.sin(8997) + Math.cos(8998) * 73;
+acc += Math.sin(8998) + Math.cos(8999) * 74;
+acc += Math.sin(8999) + Math.cos(9000) * 75;
+acc += Math.sin(9000) + Math.cos(9001) * 76;
+acc += Math.sin(9001) + Math.cos(9002) * 77;
+acc += Math.sin(9002) + Math.cos(9003) * 78;
+acc += Math.sin(9003) + Math.cos(9004) * 79;
+acc += Math.sin(9004) + Math.cos(9005) * 80;
+acc += Math.sin(9005) + Math.cos(9006) * 81;
+acc += Math.sin(9006) + Math.cos(9007) * 82;
+acc += Math.sin(9007) + Math.cos(9008) * 83;
+acc += Math.sin(9008) + Math.cos(9009) * 84;
+acc += Math.sin(9009) + Math.cos(9010) * 85;
+acc += Math.sin(9010) + Math.cos(9011) * 86;
+acc += Math.sin(9011) + Math.cos(9012) * 87;
+acc += Math.sin(9012) + Math.cos(9013) * 88;
+acc += Math.sin(9013) + Math.cos(9014) * 89;
+acc += Math.sin(9014) + Math.cos(9015) * 90;
+acc += Math.sin(9015) + Math.cos(9016) * 91;
+acc += Math.sin(9016) + Math.cos(9017) * 92;
+acc += Math.sin(9017) + Math.cos(9018) * 93;
+acc += Math.sin(9018) + Math.cos(9019) * 94;
+acc += Math.sin(9019) + Math.cos(9020) * 95;
+acc += Math.sin(9020) + Math.cos(9021) * 96;
+acc += Math.sin(9021) + Math.cos(9022) * 0;
+acc += Math.sin(9022) + Math.cos(9023) * 1;
+acc += Math.sin(9023) + Math.cos(9024) * 2;
+acc += Math.sin(9024) + Math.cos(9025) * 3;
+acc += Math.sin(9025) + Math.cos(9026) * 4;
+acc += Math.sin(9026) + Math.cos(9027) * 5;
+acc += Math.sin(9027) + Math.cos(9028) * 6;
+acc += Math.sin(9028) + Math.cos(9029) * 7;
+acc += Math.sin(9029) + Math.cos(9030) * 8;
+acc += Math.sin(9030) + Math.cos(9031) * 9;
+acc += Math.sin(9031) + Math.cos(9032) * 10;
+acc += Math.sin(9032) + Math.cos(9033) * 11;
+acc += Math.sin(9033) + Math.cos(9034) * 12;
+acc += Math.sin(9034) + Math.cos(9035) * 13;
+acc += Math.sin(9035) + Math.cos(9036) * 14;
+acc += Math.sin(9036) + Math.cos(9037) * 15;
+acc += Math.sin(9037) + Math.cos(9038) * 16;
+acc += Math.sin(9038) + Math.cos(9039) * 17;
+acc += Math.sin(9039) + Math.cos(9040) * 18;
+acc += Math.sin(9040) + Math.cos(9041) * 19;
+acc += Math.sin(9041) + Math.cos(9042) * 20;
+acc += Math.sin(9042) + Math.cos(9043) * 21;
+acc += Math.sin(9043) + Math.cos(9044) * 22;
+acc += Math.sin(9044) + Math.cos(9045) * 23;
+acc += Math.sin(9045) + Math.cos(9046) * 24;
+acc += Math.sin(9046) + Math.cos(9047) * 25;
+acc += Math.sin(9047) + Math.cos(9048) * 26;
+acc += Math.sin(9048) + Math.cos(9049) * 27;
+acc += Math.sin(9049) + Math.cos(9050) * 28;
+acc += Math.sin(9050) + Math.cos(9051) * 29;
+acc += Math.sin(9051) + Math.cos(9052) * 30;
+acc += Math.sin(9052) + Math.cos(9053) * 31;
+acc += Math.sin(9053) + Math.cos(9054) * 32;
+acc += Math.sin(9054) + Math.cos(9055) * 33;
+acc += Math.sin(9055) + Math.cos(9056) * 34;
+acc += Math.sin(9056) + Math.cos(9057) * 35;
+acc += Math.sin(9057) + Math.cos(9058) * 36;
+acc += Math.sin(9058) + Math.cos(9059) * 37;
+acc += Math.sin(9059) + Math.cos(9060) * 38;
+acc += Math.sin(9060) + Math.cos(9061) * 39;
+acc += Math.sin(9061) + Math.cos(9062) * 40;
+acc += Math.sin(9062) + Math.cos(9063) * 41;
+acc += Math.sin(9063) + Math.cos(9064) * 42;
+acc += Math.sin(9064) + Math.cos(9065) * 43;
+acc += Math.sin(9065) + Math.cos(9066) * 44;
+acc += Math.sin(9066) + Math.cos(9067) * 45;
+acc += Math.sin(9067) + Math.cos(9068) * 46;
+acc += Math.sin(9068) + Math.cos(9069) * 47;
+acc += Math.sin(9069) + Math.cos(9070) * 48;
+acc += Math.sin(9070) + Math.cos(9071) * 49;
+acc += Math.sin(9071) + Math.cos(9072) * 50;
+acc += Math.sin(9072) + Math.cos(9073) * 51;
+acc += Math.sin(9073) + Math.cos(9074) * 52;
+acc += Math.sin(9074) + Math.cos(9075) * 53;
+acc += Math.sin(9075) + Math.cos(9076) * 54;
+acc += Math.sin(9076) + Math.cos(9077) * 55;
+acc += Math.sin(9077) + Math.cos(9078) * 56;
+acc += Math.sin(9078) + Math.cos(9079) * 57;
+acc += Math.sin(9079) + Math.cos(9080) * 58;
+acc += Math.sin(9080) + Math.cos(9081) * 59;
+acc += Math.sin(9081) + Math.cos(9082) * 60;
+acc += Math.sin(9082) + Math.cos(9083) * 61;
+acc += Math.sin(9083) + Math.cos(9084) * 62;
+acc += Math.sin(9084) + Math.cos(9085) * 63;
+acc += Math.sin(9085) + Math.cos(9086) * 64;
+acc += Math.sin(9086) + Math.cos(9087) * 65;
+acc += Math.sin(9087) + Math.cos(9088) * 66;
+acc += Math.sin(9088) + Math.cos(9089) * 67;
+acc += Math.sin(9089) + Math.cos(9090) * 68;
+acc += Math.sin(9090) + Math.cos(9091) * 69;
+acc += Math.sin(9091) + Math.cos(9092) * 70;
+acc += Math.sin(9092) + Math.cos(9093) * 71;
+acc += Math.sin(9093) + Math.cos(9094) * 72;
+acc += Math.sin(9094) + Math.cos(9095) * 73;
+acc += Math.sin(9095) + Math.cos(9096) * 74;
+acc += Math.sin(9096) + Math.cos(9097) * 75;
+acc += Math.sin(9097) + Math.cos(9098) * 76;
+acc += Math.sin(9098) + Math.cos(9099) * 77;
+acc += Math.sin(9099) + Math.cos(9100) * 78;
+acc += Math.sin(9100) + Math.cos(9101) * 79;
+acc += Math.sin(9101) + Math.cos(9102) * 80;
+acc += Math.sin(9102) + Math.cos(9103) * 81;
+acc += Math.sin(9103) + Math.cos(9104) * 82;
+acc += Math.sin(9104) + Math.cos(9105) * 83;
+acc += Math.sin(9105) + Math.cos(9106) * 84;
+acc += Math.sin(9106) + Math.cos(9107) * 85;
+acc += Math.sin(9107) + Math.cos(9108) * 86;
+acc += Math.sin(9108) + Math.cos(9109) * 87;
+acc += Math.sin(9109) + Math.cos(9110) * 88;
+acc += Math.sin(9110) + Math.cos(9111) * 89;
+acc += Math.sin(9111) + Math.cos(9112) * 90;
+acc += Math.sin(9112) + Math.cos(9113) * 91;
+acc += Math.sin(9113) + Math.cos(9114) * 92;
+acc += Math.sin(9114) + Math.cos(9115) * 93;
+acc += Math.sin(9115) + Math.cos(9116) * 94;
+acc += Math.sin(9116) + Math.cos(9117) * 95;
+acc += Math.sin(9117) + Math.cos(9118) * 96;
+acc += Math.sin(9118) + Math.cos(9119) * 0;
+acc += Math.sin(9119) + Math.cos(9120) * 1;
+acc += Math.sin(9120) + Math.cos(9121) * 2;
+acc += Math.sin(9121) + Math.cos(9122) * 3;
+acc += Math.sin(9122) + Math.cos(9123) * 4;
+acc += Math.sin(9123) + Math.cos(9124) * 5;
+acc += Math.sin(9124) + Math.cos(9125) * 6;
+acc += Math.sin(9125) + Math.cos(9126) * 7;
+acc += Math.sin(9126) + Math.cos(9127) * 8;
+acc += Math.sin(9127) + Math.cos(9128) * 9;
+acc += Math.sin(9128) + Math.cos(9129) * 10;
+acc += Math.sin(9129) + Math.cos(9130) * 11;
+acc += Math.sin(9130) + Math.cos(9131) * 12;
+acc += Math.sin(9131) + Math.cos(9132) * 13;
+acc += Math.sin(9132) + Math.cos(9133) * 14;
+acc += Math.sin(9133) + Math.cos(9134) * 15;
+acc += Math.sin(9134) + Math.cos(9135) * 16;
+acc += Math.sin(9135) + Math.cos(9136) * 17;
+acc += Math.sin(9136) + Math.cos(9137) * 18;
+acc += Math.sin(9137) + Math.cos(9138) * 19;
+acc += Math.sin(9138) + Math.cos(9139) * 20;
+acc += Math.sin(9139) + Math.cos(9140) * 21;
+acc += Math.sin(9140) + Math.cos(9141) * 22;
+acc += Math.sin(9141) + Math.cos(9142) * 23;
+acc += Math.sin(9142) + Math.cos(9143) * 24;
+acc += Math.sin(9143) + Math.cos(9144) * 25;
+acc += Math.sin(9144) + Math.cos(9145) * 26;
+acc += Math.sin(9145) + Math.cos(9146) * 27;
+acc += Math.sin(9146) + Math.cos(9147) * 28;
+acc += Math.sin(9147) + Math.cos(9148) * 29;
+acc += Math.sin(9148) + Math.cos(9149) * 30;
+acc += Math.sin(9149) + Math.cos(9150) * 31;
+acc += Math.sin(9150) + Math.cos(9151) * 32;
+acc += Math.sin(9151) + Math.cos(9152) * 33;
+acc += Math.sin(9152) + Math.cos(9153) * 34;
+acc += Math.sin(9153) + Math.cos(9154) * 35;
+acc += Math.sin(9154) + Math.cos(9155) * 36;
+acc += Math.sin(9155) + Math.cos(9156) * 37;
+acc += Math.sin(9156) + Math.cos(9157) * 38;
+acc += Math.sin(9157) + Math.cos(9158) * 39;
+acc += Math.sin(9158) + Math.cos(9159) * 40;
+acc += Math.sin(9159) + Math.cos(9160) * 41;
+acc += Math.sin(9160) + Math.cos(9161) * 42;
+acc += Math.sin(9161) + Math.cos(9162) * 43;
+acc += Math.sin(9162) + Math.cos(9163) * 44;
+acc += Math.sin(9163) + Math.cos(9164) * 45;
+acc += Math.sin(9164) + Math.cos(9165) * 46;
+acc += Math.sin(9165) + Math.cos(9166) * 47;
+acc += Math.sin(9166) + Math.cos(9167) * 48;
+acc += Math.sin(9167) + Math.cos(9168) * 49;
+acc += Math.sin(9168) + Math.cos(9169) * 50;
+acc += Math.sin(9169) + Math.cos(9170) * 51;
+acc += Math.sin(9170) + Math.cos(9171) * 52;
+acc += Math.sin(9171) + Math.cos(9172) * 53;
+acc += Math.sin(9172) + Math.cos(9173) * 54;
+acc += Math.sin(9173) + Math.cos(9174) * 55;
+acc += Math.sin(9174) + Math.cos(9175) * 56;
+acc += Math.sin(9175) + Math.cos(9176) * 57;
+acc += Math.sin(9176) + Math.cos(9177) * 58;
+acc += Math.sin(9177) + Math.cos(9178) * 59;
+acc += Math.sin(9178) + Math.cos(9179) * 60;
+acc += Math.sin(9179) + Math.cos(9180) * 61;
+acc += Math.sin(9180) + Math.cos(9181) * 62;
+acc += Math.sin(9181) + Math.cos(9182) * 63;
+acc += Math.sin(9182) + Math.cos(9183) * 64;
+acc += Math.sin(9183) + Math.cos(9184) * 65;
+acc += Math.sin(9184) + Math.cos(9185) * 66;
+acc += Math.sin(9185) + Math.cos(9186) * 67;
+acc += Math.sin(9186) + Math.cos(9187) * 68;
+acc += Math.sin(9187) + Math.cos(9188) * 69;
+acc += Math.sin(9188) + Math.cos(9189) * 70;
+acc += Math.sin(9189) + Math.cos(9190) * 71;
+acc += Math.sin(9190) + Math.cos(9191) * 72;
+acc += Math.sin(9191) + Math.cos(9192) * 73;
+acc += Math.sin(9192) + Math.cos(9193) * 74;
+acc += Math.sin(9193) + Math.cos(9194) * 75;
+acc += Math.sin(9194) + Math.cos(9195) * 76;
+acc += Math.sin(9195) + Math.cos(9196) * 77;
+acc += Math.sin(9196) + Math.cos(9197) * 78;
+acc += Math.sin(9197) + Math.cos(9198) * 79;
+acc += Math.sin(9198) + Math.cos(9199) * 80;
+acc += Math.sin(9199) + Math.cos(9200) * 81;
+acc += Math.sin(9200) + Math.cos(9201) * 82;
+acc += Math.sin(9201) + Math.cos(9202) * 83;
+acc += Math.sin(9202) + Math.cos(9203) * 84;
+acc += Math.sin(9203) + Math.cos(9204) * 85;
+acc += Math.sin(9204) + Math.cos(9205) * 86;
+acc += Math.sin(9205) + Math.cos(9206) * 87;
+acc += Math.sin(9206) + Math.cos(9207) * 88;
+acc += Math.sin(9207) + Math.cos(9208) * 89;
+acc += Math.sin(9208) + Math.cos(9209) * 90;
+acc += Math.sin(9209) + Math.cos(9210) * 91;
+acc += Math.sin(9210) + Math.cos(9211) * 92;
+acc += Math.sin(9211) + Math.cos(9212) * 93;
+acc += Math.sin(9212) + Math.cos(9213) * 94;
+acc += Math.sin(9213) + Math.cos(9214) * 95;
+acc += Math.sin(9214) + Math.cos(9215) * 96;
+acc += Math.sin(9215) + Math.cos(9216) * 0;
+acc += Math.sin(9216) + Math.cos(9217) * 1;
+acc += Math.sin(9217) + Math.cos(9218) * 2;
+acc += Math.sin(9218) + Math.cos(9219) * 3;
+acc += Math.sin(9219) + Math.cos(9220) * 4;
+acc += Math.sin(9220) + Math.cos(9221) * 5;
+acc += Math.sin(9221) + Math.cos(9222) * 6;
+acc += Math.sin(9222) + Math.cos(9223) * 7;
+acc += Math.sin(9223) + Math.cos(9224) * 8;
+acc += Math.sin(9224) + Math.cos(9225) * 9;
+acc += Math.sin(9225) + Math.cos(9226) * 10;
+acc += Math.sin(9226) + Math.cos(9227) * 11;
+acc += Math.sin(9227) + Math.cos(9228) * 12;
+acc += Math.sin(9228) + Math.cos(9229) * 13;
+acc += Math.sin(9229) + Math.cos(9230) * 14;
+acc += Math.sin(9230) + Math.cos(9231) * 15;
+acc += Math.sin(9231) + Math.cos(9232) * 16;
+acc += Math.sin(9232) + Math.cos(9233) * 17;
+acc += Math.sin(9233) + Math.cos(9234) * 18;
+acc += Math.sin(9234) + Math.cos(9235) * 19;
+acc += Math.sin(9235) + Math.cos(9236) * 20;
+acc += Math.sin(9236) + Math.cos(9237) * 21;
+acc += Math.sin(9237) + Math.cos(9238) * 22;
+acc += Math.sin(9238) + Math.cos(9239) * 23;
+acc += Math.sin(9239) + Math.cos(9240) * 24;
+acc += Math.sin(9240) + Math.cos(9241) * 25;
+acc += Math.sin(9241) + Math.cos(9242) * 26;
+acc += Math.sin(9242) + Math.cos(9243) * 27;
+acc += Math.sin(9243) + Math.cos(9244) * 28;
+acc += Math.sin(9244) + Math.cos(9245) * 29;
+acc += Math.sin(9245) + Math.cos(9246) * 30;
+acc += Math.sin(9246) + Math.cos(9247) * 31;
+acc += Math.sin(9247) + Math.cos(9248) * 32;
+acc += Math.sin(9248) + Math.cos(9249) * 33;
+acc += Math.sin(9249) + Math.cos(9250) * 34;
+acc += Math.sin(9250) + Math.cos(9251) * 35;
+acc += Math.sin(9251) + Math.cos(9252) * 36;
+acc += Math.sin(9252) + Math.cos(9253) * 37;
+acc += Math.sin(9253) + Math.cos(9254) * 38;
+acc += Math.sin(9254) + Math.cos(9255) * 39;
+acc += Math.sin(9255) + Math.cos(9256) * 40;
+acc += Math.sin(9256) + Math.cos(9257) * 41;
+acc += Math.sin(9257) + Math.cos(9258) * 42;
+acc += Math.sin(9258) + Math.cos(9259) * 43;
+acc += Math.sin(9259) + Math.cos(9260) * 44;
+acc += Math.sin(9260) + Math.cos(9261) * 45;
+acc += Math.sin(9261) + Math.cos(9262) * 46;
+acc += Math.sin(9262) + Math.cos(9263) * 47;
+acc += Math.sin(9263) + Math.cos(9264) * 48;
+acc += Math.sin(9264) + Math.cos(9265) * 49;
+acc += Math.sin(9265) + Math.cos(9266) * 50;
+acc += Math.sin(9266) + Math.cos(9267) * 51;
+acc += Math.sin(9267) + Math.cos(9268) * 52;
+acc += Math.sin(9268) + Math.cos(9269) * 53;
+acc += Math.sin(9269) + Math.cos(9270) * 54;
+acc += Math.sin(9270) + Math.cos(9271) * 55;
+acc += Math.sin(9271) + Math.cos(9272) * 56;
+acc += Math.sin(9272) + Math.cos(9273) * 57;
+acc += Math.sin(9273) + Math.cos(9274) * 58;
+acc += Math.sin(9274) + Math.cos(9275) * 59;
+acc += Math.sin(9275) + Math.cos(9276) * 60;
+acc += Math.sin(9276) + Math.cos(9277) * 61;
+acc += Math.sin(9277) + Math.cos(9278) * 62;
+acc += Math.sin(9278) + Math.cos(9279) * 63;
+acc += Math.sin(9279) + Math.cos(9280) * 64;
+acc += Math.sin(9280) + Math.cos(9281) * 65;
+acc += Math.sin(9281) + Math.cos(9282) * 66;
+acc += Math.sin(9282) + Math.cos(9283) * 67;
+acc += Math.sin(9283) + Math.cos(9284) * 68;
+acc += Math.sin(9284) + Math.cos(9285) * 69;
+acc += Math.sin(9285) + Math.cos(9286) * 70;
+acc += Math.sin(9286) + Math.cos(9287) * 71;
+acc += Math.sin(9287) + Math.cos(9288) * 72;
+acc += Math.sin(9288) + Math.cos(9289) * 73;
+acc += Math.sin(9289) + Math.cos(9290) * 74;
+acc += Math.sin(9290) + Math.cos(9291) * 75;
+acc += Math.sin(9291) + Math.cos(9292) * 76;
+acc += Math.sin(9292) + Math.cos(9293) * 77;
+acc += Math.sin(9293) + Math.cos(9294) * 78;
+acc += Math.sin(9294) + Math.cos(9295) * 79;
+acc += Math.sin(9295) + Math.cos(9296) * 80;
+acc += Math.sin(9296) + Math.cos(9297) * 81;
+acc += Math.sin(9297) + Math.cos(9298) * 82;
+acc += Math.sin(9298) + Math.cos(9299) * 83;
+acc += Math.sin(9299) + Math.cos(9300) * 84;
+acc += Math.sin(9300) + Math.cos(9301) * 85;
+acc += Math.sin(9301) + Math.cos(9302) * 86;
+acc += Math.sin(9302) + Math.cos(9303) * 87;
+acc += Math.sin(9303) + Math.cos(9304) * 88;
+acc += Math.sin(9304) + Math.cos(9305) * 89;
+acc += Math.sin(9305) + Math.cos(9306) * 90;
+acc += Math.sin(9306) + Math.cos(9307) * 91;
+acc += Math.sin(9307) + Math.cos(9308) * 92;
+acc += Math.sin(9308) + Math.cos(9309) * 93;
+acc += Math.sin(9309) + Math.cos(9310) * 94;
+acc += Math.sin(9310) + Math.cos(9311) * 95;
+acc += Math.sin(9311) + Math.cos(9312) * 96;
+acc += Math.sin(9312) + Math.cos(9313) * 0;
+acc += Math.sin(9313) + Math.cos(9314) * 1;
+acc += Math.sin(9314) + Math.cos(9315) * 2;
+acc += Math.sin(9315) + Math.cos(9316) * 3;
+acc += Math.sin(9316) + Math.cos(9317) * 4;
+acc += Math.sin(9317) + Math.cos(9318) * 5;
+acc += Math.sin(9318) + Math.cos(9319) * 6;
+acc += Math.sin(9319) + Math.cos(9320) * 7;
+acc += Math.sin(9320) + Math.cos(9321) * 8;
+acc += Math.sin(9321) + Math.cos(9322) * 9;
+acc += Math.sin(9322) + Math.cos(9323) * 10;
+acc += Math.sin(9323) + Math.cos(9324) * 11;
+acc += Math.sin(9324) + Math.cos(9325) * 12;
+acc += Math.sin(9325) + Math.cos(9326) * 13;
+acc += Math.sin(9326) + Math.cos(9327) * 14;
+acc += Math.sin(9327) + Math.cos(9328) * 15;
+acc += Math.sin(9328) + Math.cos(9329) * 16;
+acc += Math.sin(9329) + Math.cos(9330) * 17;
+acc += Math.sin(9330) + Math.cos(9331) * 18;
+acc += Math.sin(9331) + Math.cos(9332) * 19;
+acc += Math.sin(9332) + Math.cos(9333) * 20;
+acc += Math.sin(9333) + Math.cos(9334) * 21;
+acc += Math.sin(9334) + Math.cos(9335) * 22;
+acc += Math.sin(9335) + Math.cos(9336) * 23;
+acc += Math.sin(9336) + Math.cos(9337) * 24;
+acc += Math.sin(9337) + Math.cos(9338) * 25;
+acc += Math.sin(9338) + Math.cos(9339) * 26;
+acc += Math.sin(9339) + Math.cos(9340) * 27;
+acc += Math.sin(9340) + Math.cos(9341) * 28;
+acc += Math.sin(9341) + Math.cos(9342) * 29;
+acc += Math.sin(9342) + Math.cos(9343) * 30;
+acc += Math.sin(9343) + Math.cos(9344) * 31;
+acc += Math.sin(9344) + Math.cos(9345) * 32;
+acc += Math.sin(9345) + Math.cos(9346) * 33;
+acc += Math.sin(9346) + Math.cos(9347) * 34;
+acc += Math.sin(9347) + Math.cos(9348) * 35;
+acc += Math.sin(9348) + Math.cos(9349) * 36;
+acc += Math.sin(9349) + Math.cos(9350) * 37;
+acc += Math.sin(9350) + Math.cos(9351) * 38;
+acc += Math.sin(9351) + Math.cos(9352) * 39;
+acc += Math.sin(9352) + Math.cos(9353) * 40;
+acc += Math.sin(9353) + Math.cos(9354) * 41;
+acc += Math.sin(9354) + Math.cos(9355) * 42;
+acc += Math.sin(9355) + Math.cos(9356) * 43;
+acc += Math.sin(9356) + Math.cos(9357) * 44;
+acc += Math.sin(9357) + Math.cos(9358) * 45;
+acc += Math.sin(9358) + Math.cos(9359) * 46;
+acc += Math.sin(9359) + Math.cos(9360) * 47;
+acc += Math.sin(9360) + Math.cos(9361) * 48;
+acc += Math.sin(9361) + Math.cos(9362) * 49;
+acc += Math.sin(9362) + Math.cos(9363) * 50;
+acc += Math.sin(9363) + Math.cos(9364) * 51;
+acc += Math.sin(9364) + Math.cos(9365) * 52;
+acc += Math.sin(9365) + Math.cos(9366) * 53;
+acc += Math.sin(9366) + Math.cos(9367) * 54;
+acc += Math.sin(9367) + Math.cos(9368) * 55;
+acc += Math.sin(9368) + Math.cos(9369) * 56;
+acc += Math.sin(9369) + Math.cos(9370) * 57;
+acc += Math.sin(9370) + Math.cos(9371) * 58;
+acc += Math.sin(9371) + Math.cos(9372) * 59;
+acc += Math.sin(9372) + Math.cos(9373) * 60;
+acc += Math.sin(9373) + Math.cos(9374) * 61;
+acc += Math.sin(9374) + Math.cos(9375) * 62;
+acc += Math.sin(9375) + Math.cos(9376) * 63;
+acc += Math.sin(9376) + Math.cos(9377) * 64;
+acc += Math.sin(9377) + Math.cos(9378) * 65;
+acc += Math.sin(9378) + Math.cos(9379) * 66;
+acc += Math.sin(9379) + Math.cos(9380) * 67;
+acc += Math.sin(9380) + Math.cos(9381) * 68;
+acc += Math.sin(9381) + Math.cos(9382) * 69;
+acc += Math.sin(9382) + Math.cos(9383) * 70;
+acc += Math.sin(9383) + Math.cos(9384) * 71;
+acc += Math.sin(9384) + Math.cos(9385) * 72;
+acc += Math.sin(9385) + Math.cos(9386) * 73;
+acc += Math.sin(9386) + Math.cos(9387) * 74;
+acc += Math.sin(9387) + Math.cos(9388) * 75;
+acc += Math.sin(9388) + Math.cos(9389) * 76;
+acc += Math.sin(9389) + Math.cos(9390) * 77;
+acc += Math.sin(9390) + Math.cos(9391) * 78;
+acc += Math.sin(9391) + Math.cos(9392) * 79;
+acc += Math.sin(9392) + Math.cos(9393) * 80;
+acc += Math.sin(9393) + Math.cos(9394) * 81;
+acc += Math.sin(9394) + Math.cos(9395) * 82;
+acc += Math.sin(9395) + Math.cos(9396) * 83;
+acc += Math.sin(9396) + Math.cos(9397) * 84;
+acc += Math.sin(9397) + Math.cos(9398) * 85;
+acc += Math.sin(9398) + Math.cos(9399) * 86;
+acc += Math.sin(9399) + Math.cos(9400) * 87;
+acc += Math.sin(9400) + Math.cos(9401) * 88;
+acc += Math.sin(9401) + Math.cos(9402) * 89;
+acc += Math.sin(9402) + Math.cos(9403) * 90;
+acc += Math.sin(9403) + Math.cos(9404) * 91;
+acc += Math.sin(9404) + Math.cos(9405) * 92;
+acc += Math.sin(9405) + Math.cos(9406) * 93;
+acc += Math.sin(9406) + Math.cos(9407) * 94;
+acc += Math.sin(9407) + Math.cos(9408) * 95;
+acc += Math.sin(9408) + Math.cos(9409) * 96;
+acc += Math.sin(9409) + Math.cos(9410) * 0;
+acc += Math.sin(9410) + Math.cos(9411) * 1;
+acc += Math.sin(9411) + Math.cos(9412) * 2;
+acc += Math.sin(9412) + Math.cos(9413) * 3;
+acc += Math.sin(9413) + Math.cos(9414) * 4;
+acc += Math.sin(9414) + Math.cos(9415) * 5;
+acc += Math.sin(9415) + Math.cos(9416) * 6;
+acc += Math.sin(9416) + Math.cos(9417) * 7;
+acc += Math.sin(9417) + Math.cos(9418) * 8;
+acc += Math.sin(9418) + Math.cos(9419) * 9;
+acc += Math.sin(9419) + Math.cos(9420) * 10;
+acc += Math.sin(9420) + Math.cos(9421) * 11;
+acc += Math.sin(9421) + Math.cos(9422) * 12;
+acc += Math.sin(9422) + Math.cos(9423) * 13;
+acc += Math.sin(9423) + Math.cos(9424) * 14;
+acc += Math.sin(9424) + Math.cos(9425) * 15;
+acc += Math.sin(9425) + Math.cos(9426) * 16;
+acc += Math.sin(9426) + Math.cos(9427) * 17;
+acc += Math.sin(9427) + Math.cos(9428) * 18;
+acc += Math.sin(9428) + Math.cos(9429) * 19;
+acc += Math.sin(9429) + Math.cos(9430) * 20;
+acc += Math.sin(9430) + Math.cos(9431) * 21;
+acc += Math.sin(9431) + Math.cos(9432) * 22;
+acc += Math.sin(9432) + Math.cos(9433) * 23;
+acc += Math.sin(9433) + Math.cos(9434) * 24;
+acc += Math.sin(9434) + Math.cos(9435) * 25;
+acc += Math.sin(9435) + Math.cos(9436) * 26;
+acc += Math.sin(9436) + Math.cos(9437) * 27;
+acc += Math.sin(9437) + Math.cos(9438) * 28;
+acc += Math.sin(9438) + Math.cos(9439) * 29;
+acc += Math.sin(9439) + Math.cos(9440) * 30;
+acc += Math.sin(9440) + Math.cos(9441) * 31;
+acc += Math.sin(9441) + Math.cos(9442) * 32;
+acc += Math.sin(9442) + Math.cos(9443) * 33;
+acc += Math.sin(9443) + Math.cos(9444) * 34;
+acc += Math.sin(9444) + Math.cos(9445) * 35;
+acc += Math.sin(9445) + Math.cos(9446) * 36;
+acc += Math.sin(9446) + Math.cos(9447) * 37;
+acc += Math.sin(9447) + Math.cos(9448) * 38;
+acc += Math.sin(9448) + Math.cos(9449) * 39;
+acc += Math.sin(9449) + Math.cos(9450) * 40;
+acc += Math.sin(9450) + Math.cos(9451) * 41;
+acc += Math.sin(9451) + Math.cos(9452) * 42;
+acc += Math.sin(9452) + Math.cos(9453) * 43;
+acc += Math.sin(9453) + Math.cos(9454) * 44;
+acc += Math.sin(9454) + Math.cos(9455) * 45;
+acc += Math.sin(9455) + Math.cos(9456) * 46;
+acc += Math.sin(9456) + Math.cos(9457) * 47;
+acc += Math.sin(9457) + Math.cos(9458) * 48;
+acc += Math.sin(9458) + Math.cos(9459) * 49;
+acc += Math.sin(9459) + Math.cos(9460) * 50;
+acc += Math.sin(9460) + Math.cos(9461) * 51;
+acc += Math.sin(9461) + Math.cos(9462) * 52;
+acc += Math.sin(9462) + Math.cos(9463) * 53;
+acc += Math.sin(9463) + Math.cos(9464) * 54;
+acc += Math.sin(9464) + Math.cos(9465) * 55;
+acc += Math.sin(9465) + Math.cos(9466) * 56;
+acc += Math.sin(9466) + Math.cos(9467) * 57;
+acc += Math.sin(9467) + Math.cos(9468) * 58;
+acc += Math.sin(9468) + Math.cos(9469) * 59;
+acc += Math.sin(9469) + Math.cos(9470) * 60;
+acc += Math.sin(9470) + Math.cos(9471) * 61;
+acc += Math.sin(9471) + Math.cos(9472) * 62;
+acc += Math.sin(9472) + Math.cos(9473) * 63;
+acc += Math.sin(9473) + Math.cos(9474) * 64;
+acc += Math.sin(9474) + Math.cos(9475) * 65;
+acc += Math.sin(9475) + Math.cos(9476) * 66;
+acc += Math.sin(9476) + Math.cos(9477) * 67;
+acc += Math.sin(9477) + Math.cos(9478) * 68;
+acc += Math.sin(9478) + Math.cos(9479) * 69;
+acc += Math.sin(9479) + Math.cos(9480) * 70;
+acc += Math.sin(9480) + Math.cos(9481) * 71;
+acc += Math.sin(9481) + Math.cos(9482) * 72;
+acc += Math.sin(9482) + Math.cos(9483) * 73;
+acc += Math.sin(9483) + Math.cos(9484) * 74;
+acc += Math.sin(9484) + Math.cos(9485) * 75;
+acc += Math.sin(9485) + Math.cos(9486) * 76;
+acc += Math.sin(9486) + Math.cos(9487) * 77;
+acc += Math.sin(9487) + Math.cos(9488) * 78;
+acc += Math.sin(9488) + Math.cos(9489) * 79;
+acc += Math.sin(9489) + Math.cos(9490) * 80;
+acc += Math.sin(9490) + Math.cos(9491) * 81;
+acc += Math.sin(9491) + Math.cos(9492) * 82;
+acc += Math.sin(9492) + Math.cos(9493) * 83;
+acc += Math.sin(9493) + Math.cos(9494) * 84;
+acc += Math.sin(9494) + Math.cos(9495) * 85;
+acc += Math.sin(9495) + Math.cos(9496) * 86;
+acc += Math.sin(9496) + Math.cos(9497) * 87;
+acc += Math.sin(9497) + Math.cos(9498) * 88;
+acc += Math.sin(9498) + Math.cos(9499) * 89;
+acc += Math.sin(9499) + Math.cos(9500) * 90;
+acc += Math.sin(9500) + Math.cos(9501) * 91;
+acc += Math.sin(9501) + Math.cos(9502) * 92;
+acc += Math.sin(9502) + Math.cos(9503) * 93;
+acc += Math.sin(9503) + Math.cos(9504) * 94;
+acc += Math.sin(9504) + Math.cos(9505) * 95;
+acc += Math.sin(9505) + Math.cos(9506) * 96;
+acc += Math.sin(9506) + Math.cos(9507) * 0;
+acc += Math.sin(9507) + Math.cos(9508) * 1;
+acc += Math.sin(9508) + Math.cos(9509) * 2;
+acc += Math.sin(9509) + Math.cos(9510) * 3;
+acc += Math.sin(9510) + Math.cos(9511) * 4;
+acc += Math.sin(9511) + Math.cos(9512) * 5;
+acc += Math.sin(9512) + Math.cos(9513) * 6;
+acc += Math.sin(9513) + Math.cos(9514) * 7;
+acc += Math.sin(9514) + Math.cos(9515) * 8;
+acc += Math.sin(9515) + Math.cos(9516) * 9;
+acc += Math.sin(9516) + Math.cos(9517) * 10;
+acc += Math.sin(9517) + Math.cos(9518) * 11;
+acc += Math.sin(9518) + Math.cos(9519) * 12;
+acc += Math.sin(9519) + Math.cos(9520) * 13;
+acc += Math.sin(9520) + Math.cos(9521) * 14;
+acc += Math.sin(9521) + Math.cos(9522) * 15;
+acc += Math.sin(9522) + Math.cos(9523) * 16;
+acc += Math.sin(9523) + Math.cos(9524) * 17;
+acc += Math.sin(9524) + Math.cos(9525) * 18;
+acc += Math.sin(9525) + Math.cos(9526) * 19;
+acc += Math.sin(9526) + Math.cos(9527) * 20;
+acc += Math.sin(9527) + Math.cos(9528) * 21;
+acc += Math.sin(9528) + Math.cos(9529) * 22;
+acc += Math.sin(9529) + Math.cos(9530) * 23;
+acc += Math.sin(9530) + Math.cos(9531) * 24;
+acc += Math.sin(9531) + Math.cos(9532) * 25;
+acc += Math.sin(9532) + Math.cos(9533) * 26;
+acc += Math.sin(9533) + Math.cos(9534) * 27;
+acc += Math.sin(9534) + Math.cos(9535) * 28;
+acc += Math.sin(9535) + Math.cos(9536) * 29;
+acc += Math.sin(9536) + Math.cos(9537) * 30;
+acc += Math.sin(9537) + Math.cos(9538) * 31;
+acc += Math.sin(9538) + Math.cos(9539) * 32;
+acc += Math.sin(9539) + Math.cos(9540) * 33;
+acc += Math.sin(9540) + Math.cos(9541) * 34;
+acc += Math.sin(9541) + Math.cos(9542) * 35;
+acc += Math.sin(9542) + Math.cos(9543) * 36;
+acc += Math.sin(9543) + Math.cos(9544) * 37;
+acc += Math.sin(9544) + Math.cos(9545) * 38;
+acc += Math.sin(9545) + Math.cos(9546) * 39;
+acc += Math.sin(9546) + Math.cos(9547) * 40;
+acc += Math.sin(9547) + Math.cos(9548) * 41;
+acc += Math.sin(9548) + Math.cos(9549) * 42;
+acc += Math.sin(9549) + Math.cos(9550) * 43;
+acc += Math.sin(9550) + Math.cos(9551) * 44;
+acc += Math.sin(9551) + Math.cos(9552) * 45;
+acc += Math.sin(9552) + Math.cos(9553) * 46;
+acc += Math.sin(9553) + Math.cos(9554) * 47;
+acc += Math.sin(9554) + Math.cos(9555) * 48;
+acc += Math.sin(9555) + Math.cos(9556) * 49;
+acc += Math.sin(9556) + Math.cos(9557) * 50;
+acc += Math.sin(9557) + Math.cos(9558) * 51;
+acc += Math.sin(9558) + Math.cos(9559) * 52;
+acc += Math.sin(9559) + Math.cos(9560) * 53;
+acc += Math.sin(9560) + Math.cos(9561) * 54;
+acc += Math.sin(9561) + Math.cos(9562) * 55;
+acc += Math.sin(9562) + Math.cos(9563) * 56;
+acc += Math.sin(9563) + Math.cos(9564) * 57;
+acc += Math.sin(9564) + Math.cos(9565) * 58;
+acc += Math.sin(9565) + Math.cos(9566) * 59;
+acc += Math.sin(9566) + Math.cos(9567) * 60;
+acc += Math.sin(9567) + Math.cos(9568) * 61;
+acc += Math.sin(9568) + Math.cos(9569) * 62;
+acc += Math.sin(9569) + Math.cos(9570) * 63;
+acc += Math.sin(9570) + Math.cos(9571) * 64;
+acc += Math.sin(9571) + Math.cos(9572) * 65;
+acc += Math.sin(9572) + Math.cos(9573) * 66;
+acc += Math.sin(9573) + Math.cos(9574) * 67;
+acc += Math.sin(9574) + Math.cos(9575) * 68;
+acc += Math.sin(9575) + Math.cos(9576) * 69;
+acc += Math.sin(9576) + Math.cos(9577) * 70;
+acc += Math.sin(9577) + Math.cos(9578) * 71;
+acc += Math.sin(9578) + Math.cos(9579) * 72;
+acc += Math.sin(9579) + Math.cos(9580) * 73;
+acc += Math.sin(9580) + Math.cos(9581) * 74;
+acc += Math.sin(9581) + Math.cos(9582) * 75;
+acc += Math.sin(9582) + Math.cos(9583) * 76;
+acc += Math.sin(9583) + Math.cos(9584) * 77;
+acc += Math.sin(9584) + Math.cos(9585) * 78;
+acc += Math.sin(9585) + Math.cos(9586) * 79;
+acc += Math.sin(9586) + Math.cos(9587) * 80;
+acc += Math.sin(9587) + Math.cos(9588) * 81;
+acc += Math.sin(9588) + Math.cos(9589) * 82;
+acc += Math.sin(9589) + Math.cos(9590) * 83;
+acc += Math.sin(9590) + Math.cos(9591) * 84;
+acc += Math.sin(9591) + Math.cos(9592) * 85;
+acc += Math.sin(9592) + Math.cos(9593) * 86;
+acc += Math.sin(9593) + Math.cos(9594) * 87;
+acc += Math.sin(9594) + Math.cos(9595) * 88;
+acc += Math.sin(9595) + Math.cos(9596) * 89;
+acc += Math.sin(9596) + Math.cos(9597) * 90;
+acc += Math.sin(9597) + Math.cos(9598) * 91;
+acc += Math.sin(9598) + Math.cos(9599) * 92;
+acc += Math.sin(9599) + Math.cos(9600) * 93;
+acc += Math.sin(9600) + Math.cos(9601) * 94;
+acc += Math.sin(9601) + Math.cos(9602) * 95;
+acc += Math.sin(9602) + Math.cos(9603) * 96;
+acc += Math.sin(9603) + Math.cos(9604) * 0;
+acc += Math.sin(9604) + Math.cos(9605) * 1;
+acc += Math.sin(9605) + Math.cos(9606) * 2;
+acc += Math.sin(9606) + Math.cos(9607) * 3;
+acc += Math.sin(9607) + Math.cos(9608) * 4;
+acc += Math.sin(9608) + Math.cos(9609) * 5;
+acc += Math.sin(9609) + Math.cos(9610) * 6;
+acc += Math.sin(9610) + Math.cos(9611) * 7;
+acc += Math.sin(9611) + Math.cos(9612) * 8;
+acc += Math.sin(9612) + Math.cos(9613) * 9;
+acc += Math.sin(9613) + Math.cos(9614) * 10;
+acc += Math.sin(9614) + Math.cos(9615) * 11;
+acc += Math.sin(9615) + Math.cos(9616) * 12;
+acc += Math.sin(9616) + Math.cos(9617) * 13;
+acc += Math.sin(9617) + Math.cos(9618) * 14;
+acc += Math.sin(9618) + Math.cos(9619) * 15;
+acc += Math.sin(9619) + Math.cos(9620) * 16;
+acc += Math.sin(9620) + Math.cos(9621) * 17;
+acc += Math.sin(9621) + Math.cos(9622) * 18;
+acc += Math.sin(9622) + Math.cos(9623) * 19;
+acc += Math.sin(9623) + Math.cos(9624) * 20;
+acc += Math.sin(9624) + Math.cos(9625) * 21;
+acc += Math.sin(9625) + Math.cos(9626) * 22;
+acc += Math.sin(9626) + Math.cos(9627) * 23;
+acc += Math.sin(9627) + Math.cos(9628) * 24;
+acc += Math.sin(9628) + Math.cos(9629) * 25;
+acc += Math.sin(9629) + Math.cos(9630) * 26;
+acc += Math.sin(9630) + Math.cos(9631) * 27;
+acc += Math.sin(9631) + Math.cos(9632) * 28;
+acc += Math.sin(9632) + Math.cos(9633) * 29;
+acc += Math.sin(9633) + Math.cos(9634) * 30;
+acc += Math.sin(9634) + Math.cos(9635) * 31;
+acc += Math.sin(9635) + Math.cos(9636) * 32;
+acc += Math.sin(9636) + Math.cos(9637) * 33;
+acc += Math.sin(9637) + Math.cos(9638) * 34;
+acc += Math.sin(9638) + Math.cos(9639) * 35;
+acc += Math.sin(9639) + Math.cos(9640) * 36;
+acc += Math.sin(9640) + Math.cos(9641) * 37;
+acc += Math.sin(9641) + Math.cos(9642) * 38;
+acc += Math.sin(9642) + Math.cos(9643) * 39;
+acc += Math.sin(9643) + Math.cos(9644) * 40;
+acc += Math.sin(9644) + Math.cos(9645) * 41;
+acc += Math.sin(9645) + Math.cos(9646) * 42;
+acc += Math.sin(9646) + Math.cos(9647) * 43;
+acc += Math.sin(9647) + Math.cos(9648) * 44;
+acc += Math.sin(9648) + Math.cos(9649) * 45;
+acc += Math.sin(9649) + Math.cos(9650) * 46;
+acc += Math.sin(9650) + Math.cos(9651) * 47;
+acc += Math.sin(9651) + Math.cos(9652) * 48;
+acc += Math.sin(9652) + Math.cos(9653) * 49;
+acc += Math.sin(9653) + Math.cos(9654) * 50;
+acc += Math.sin(9654) + Math.cos(9655) * 51;
+acc += Math.sin(9655) + Math.cos(9656) * 52;
+acc += Math.sin(9656) + Math.cos(9657) * 53;
+acc += Math.sin(9657) + Math.cos(9658) * 54;
+acc += Math.sin(9658) + Math.cos(9659) * 55;
+acc += Math.sin(9659) + Math.cos(9660) * 56;
+acc += Math.sin(9660) + Math.cos(9661) * 57;
+acc += Math.sin(9661) + Math.cos(9662) * 58;
+acc += Math.sin(9662) + Math.cos(9663) * 59;
+acc += Math.sin(9663) + Math.cos(9664) * 60;
+acc += Math.sin(9664) + Math.cos(9665) * 61;
+acc += Math.sin(9665) + Math.cos(9666) * 62;
+acc += Math.sin(9666) + Math.cos(9667) * 63;
+acc += Math.sin(9667) + Math.cos(9668) * 64;
+acc += Math.sin(9668) + Math.cos(9669) * 65;
+acc += Math.sin(9669) + Math.cos(9670) * 66;
+acc += Math.sin(9670) + Math.cos(9671) * 67;
+acc += Math.sin(9671) + Math.cos(9672) * 68;
+acc += Math.sin(9672) + Math.cos(9673) * 69;
+acc += Math.sin(9673) + Math.cos(9674) * 70;
+acc += Math.sin(9674) + Math.cos(9675) * 71;
+acc += Math.sin(9675) + Math.cos(9676) * 72;
+acc += Math.sin(9676) + Math.cos(9677) * 73;
+acc += Math.sin(9677) + Math.cos(9678) * 74;
+acc += Math.sin(9678) + Math.cos(9679) * 75;
+acc += Math.sin(9679) + Math.cos(9680) * 76;
+acc += Math.sin(9680) + Math.cos(9681) * 77;
+acc += Math.sin(9681) + Math.cos(9682) * 78;
+acc += Math.sin(9682) + Math.cos(9683) * 79;
+acc += Math.sin(9683) + Math.cos(9684) * 80;
+acc += Math.sin(9684) + Math.cos(9685) * 81;
+acc += Math.sin(9685) + Math.cos(9686) * 82;
+acc += Math.sin(9686) + Math.cos(9687) * 83;
+acc += Math.sin(9687) + Math.cos(9688) * 84;
+acc += Math.sin(9688) + Math.cos(9689) * 85;
+acc += Math.sin(9689) + Math.cos(9690) * 86;
+acc += Math.sin(9690) + Math.cos(9691) * 87;
+acc += Math.sin(9691) + Math.cos(9692) * 88;
+acc += Math.sin(9692) + Math.cos(9693) * 89;
+acc += Math.sin(9693) + Math.cos(9694) * 90;
+acc += Math.sin(9694) + Math.cos(9695) * 91;
+acc += Math.sin(9695) + Math.cos(9696) * 92;
+acc += Math.sin(9696) + Math.cos(9697) * 93;
+acc += Math.sin(9697) + Math.cos(9698) * 94;
+acc += Math.sin(9698) + Math.cos(9699) * 95;
+acc += Math.sin(9699) + Math.cos(9700) * 96;
+acc += Math.sin(9700) + Math.cos(9701) * 0;
+acc += Math.sin(9701) + Math.cos(9702) * 1;
+acc += Math.sin(9702) + Math.cos(9703) * 2;
+acc += Math.sin(9703) + Math.cos(9704) * 3;
+acc += Math.sin(9704) + Math.cos(9705) * 4;
+acc += Math.sin(9705) + Math.cos(9706) * 5;
+acc += Math.sin(9706) + Math.cos(9707) * 6;
+acc += Math.sin(9707) + Math.cos(9708) * 7;
+acc += Math.sin(9708) + Math.cos(9709) * 8;
+acc += Math.sin(9709) + Math.cos(9710) * 9;
+acc += Math.sin(9710) + Math.cos(9711) * 10;
+acc += Math.sin(9711) + Math.cos(9712) * 11;
+acc += Math.sin(9712) + Math.cos(9713) * 12;
+acc += Math.sin(9713) + Math.cos(9714) * 13;
+acc += Math.sin(9714) + Math.cos(9715) * 14;
+acc += Math.sin(9715) + Math.cos(9716) * 15;
+acc += Math.sin(9716) + Math.cos(9717) * 16;
+acc += Math.sin(9717) + Math.cos(9718) * 17;
+acc += Math.sin(9718) + Math.cos(9719) * 18;
+acc += Math.sin(9719) + Math.cos(9720) * 19;
+acc += Math.sin(9720) + Math.cos(9721) * 20;
+acc += Math.sin(9721) + Math.cos(9722) * 21;
+acc += Math.sin(9722) + Math.cos(9723) * 22;
+acc += Math.sin(9723) + Math.cos(9724) * 23;
+acc += Math.sin(9724) + Math.cos(9725) * 24;
+acc += Math.sin(9725) + Math.cos(9726) * 25;
+acc += Math.sin(9726) + Math.cos(9727) * 26;
+acc += Math.sin(9727) + Math.cos(9728) * 27;
+acc += Math.sin(9728) + Math.cos(9729) * 28;
+acc += Math.sin(9729) + Math.cos(9730) * 29;
+acc += Math.sin(9730) + Math.cos(9731) * 30;
+acc += Math.sin(9731) + Math.cos(9732) * 31;
+acc += Math.sin(9732) + Math.cos(9733) * 32;
+acc += Math.sin(9733) + Math.cos(9734) * 33;
+acc += Math.sin(9734) + Math.cos(9735) * 34;
+acc += Math.sin(9735) + Math.cos(9736) * 35;
+acc += Math.sin(9736) + Math.cos(9737) * 36;
+acc += Math.sin(9737) + Math.cos(9738) * 37;
+acc += Math.sin(9738) + Math.cos(9739) * 38;
+acc += Math.sin(9739) + Math.cos(9740) * 39;
+acc += Math.sin(9740) + Math.cos(9741) * 40;
+acc += Math.sin(9741) + Math.cos(9742) * 41;
+acc += Math.sin(9742) + Math.cos(9743) * 42;
+acc += Math.sin(9743) + Math.cos(9744) * 43;
+acc += Math.sin(9744) + Math.cos(9745) * 44;
+acc += Math.sin(9745) + Math.cos(9746) * 45;
+acc += Math.sin(9746) + Math.cos(9747) * 46;
+acc += Math.sin(9747) + Math.cos(9748) * 47;
+acc += Math.sin(9748) + Math.cos(9749) * 48;
+acc += Math.sin(9749) + Math.cos(9750) * 49;
+acc += Math.sin(9750) + Math.cos(9751) * 50;
+acc += Math.sin(9751) + Math.cos(9752) * 51;
+acc += Math.sin(9752) + Math.cos(9753) * 52;
+acc += Math.sin(9753) + Math.cos(9754) * 53;
+acc += Math.sin(9754) + Math.cos(9755) * 54;
+acc += Math.sin(9755) + Math.cos(9756) * 55;
+acc += Math.sin(9756) + Math.cos(9757) * 56;
+acc += Math.sin(9757) + Math.cos(9758) * 57;
+acc += Math.sin(9758) + Math.cos(9759) * 58;
+acc += Math.sin(9759) + Math.cos(9760) * 59;
+acc += Math.sin(9760) + Math.cos(9761) * 60;
+acc += Math.sin(9761) + Math.cos(9762) * 61;
+acc += Math.sin(9762) + Math.cos(9763) * 62;
+acc += Math.sin(9763) + Math.cos(9764) * 63;
+acc += Math.sin(9764) + Math.cos(9765) * 64;
+acc += Math.sin(9765) + Math.cos(9766) * 65;
+acc += Math.sin(9766) + Math.cos(9767) * 66;
+acc += Math.sin(9767) + Math.cos(9768) * 67;
+acc += Math.sin(9768) + Math.cos(9769) * 68;
+acc += Math.sin(9769) + Math.cos(9770) * 69;
+acc += Math.sin(9770) + Math.cos(9771) * 70;
+acc += Math.sin(9771) + Math.cos(9772) * 71;
+acc += Math.sin(9772) + Math.cos(9773) * 72;
+acc += Math.sin(9773) + Math.cos(9774) * 73;
+acc += Math.sin(9774) + Math.cos(9775) * 74;
+acc += Math.sin(9775) + Math.cos(9776) * 75;
+acc += Math.sin(9776) + Math.cos(9777) * 76;
+acc += Math.sin(9777) + Math.cos(9778) * 77;
+acc += Math.sin(9778) + Math.cos(9779) * 78;
+acc += Math.sin(9779) + Math.cos(9780) * 79;
+acc += Math.sin(9780) + Math.cos(9781) * 80;
+acc += Math.sin(9781) + Math.cos(9782) * 81;
+acc += Math.sin(9782) + Math.cos(9783) * 82;
+acc += Math.sin(9783) + Math.cos(9784) * 83;
+acc += Math.sin(9784) + Math.cos(9785) * 84;
+acc += Math.sin(9785) + Math.cos(9786) * 85;
+acc += Math.sin(9786) + Math.cos(9787) * 86;
+acc += Math.sin(9787) + Math.cos(9788) * 87;
+acc += Math.sin(9788) + Math.cos(9789) * 88;
+acc += Math.sin(9789) + Math.cos(9790) * 89;
+acc += Math.sin(9790) + Math.cos(9791) * 90;
+acc += Math.sin(9791) + Math.cos(9792) * 91;
+acc += Math.sin(9792) + Math.cos(9793) * 92;
+acc += Math.sin(9793) + Math.cos(9794) * 93;
+acc += Math.sin(9794) + Math.cos(9795) * 94;
+acc += Math.sin(9795) + Math.cos(9796) * 95;
+acc += Math.sin(9796) + Math.cos(9797) * 96;
+acc += Math.sin(9797) + Math.cos(9798) * 0;
+acc += Math.sin(9798) + Math.cos(9799) * 1;
+acc += Math.sin(9799) + Math.cos(9800) * 2;
+acc += Math.sin(9800) + Math.cos(9801) * 3;
+acc += Math.sin(9801) + Math.cos(9802) * 4;
+acc += Math.sin(9802) + Math.cos(9803) * 5;
+acc += Math.sin(9803) + Math.cos(9804) * 6;
+acc += Math.sin(9804) + Math.cos(9805) * 7;
+acc += Math.sin(9805) + Math.cos(9806) * 8;
+acc += Math.sin(9806) + Math.cos(9807) * 9;
+acc += Math.sin(9807) + Math.cos(9808) * 10;
+acc += Math.sin(9808) + Math.cos(9809) * 11;
+acc += Math.sin(9809) + Math.cos(9810) * 12;
+acc += Math.sin(9810) + Math.cos(9811) * 13;
+acc += Math.sin(9811) + Math.cos(9812) * 14;
+acc += Math.sin(9812) + Math.cos(9813) * 15;
+acc += Math.sin(9813) + Math.cos(9814) * 16;
+acc += Math.sin(9814) + Math.cos(9815) * 17;
+acc += Math.sin(9815) + Math.cos(9816) * 18;
+acc += Math.sin(9816) + Math.cos(9817) * 19;
+acc += Math.sin(9817) + Math.cos(9818) * 20;
+acc += Math.sin(9818) + Math.cos(9819) * 21;
+acc += Math.sin(9819) + Math.cos(9820) * 22;
+acc += Math.sin(9820) + Math.cos(9821) * 23;
+acc += Math.sin(9821) + Math.cos(9822) * 24;
+acc += Math.sin(9822) + Math.cos(9823) * 25;
+acc += Math.sin(9823) + Math.cos(9824) * 26;
+acc += Math.sin(9824) + Math.cos(9825) * 27;
+acc += Math.sin(9825) + Math.cos(9826) * 28;
+acc += Math.sin(9826) + Math.cos(9827) * 29;
+acc += Math.sin(9827) + Math.cos(9828) * 30;
+acc += Math.sin(9828) + Math.cos(9829) * 31;
+acc += Math.sin(9829) + Math.cos(9830) * 32;
+acc += Math.sin(9830) + Math.cos(9831) * 33;
+acc += Math.sin(9831) + Math.cos(9832) * 34;
+acc += Math.sin(9832) + Math.cos(9833) * 35;
+acc += Math.sin(9833) + Math.cos(9834) * 36;
+acc += Math.sin(9834) + Math.cos(9835) * 37;
+acc += Math.sin(9835) + Math.cos(9836) * 38;
+acc += Math.sin(9836) + Math.cos(9837) * 39;
+acc += Math.sin(9837) + Math.cos(9838) * 40;
+acc += Math.sin(9838) + Math.cos(9839) * 41;
+acc += Math.sin(9839) + Math.cos(9840) * 42;
+acc += Math.sin(9840) + Math.cos(9841) * 43;
+acc += Math.sin(9841) + Math.cos(9842) * 44;
+acc += Math.sin(9842) + Math.cos(9843) * 45;
+acc += Math.sin(9843) + Math.cos(9844) * 46;
+acc += Math.sin(9844) + Math.cos(9845) * 47;
+acc += Math.sin(9845) + Math.cos(9846) * 48;
+acc += Math.sin(9846) + Math.cos(9847) * 49;
+acc += Math.sin(9847) + Math.cos(9848) * 50;
+acc += Math.sin(9848) + Math.cos(9849) * 51;
+acc += Math.sin(9849) + Math.cos(9850) * 52;
+acc += Math.sin(9850) + Math.cos(9851) * 53;
+acc += Math.sin(9851) + Math.cos(9852) * 54;
+acc += Math.sin(9852) + Math.cos(9853) * 55;
+acc += Math.sin(9853) + Math.cos(9854) * 56;
+acc += Math.sin(9854) + Math.cos(9855) * 57;
+acc += Math.sin(9855) + Math.cos(9856) * 58;
+acc += Math.sin(9856) + Math.cos(9857) * 59;
+acc += Math.sin(9857) + Math.cos(9858) * 60;
+acc += Math.sin(9858) + Math.cos(9859) * 61;
+acc += Math.sin(9859) + Math.cos(9860) * 62;
+acc += Math.sin(9860) + Math.cos(9861) * 63;
+acc += Math.sin(9861) + Math.cos(9862) * 64;
+acc += Math.sin(9862) + Math.cos(9863) * 65;
+acc += Math.sin(9863) + Math.cos(9864) * 66;
+acc += Math.sin(9864) + Math.cos(9865) * 67;
+acc += Math.sin(9865) + Math.cos(9866) * 68;
+acc += Math.sin(9866) + Math.cos(9867) * 69;
+acc += Math.sin(9867) + Math.cos(9868) * 70;
+acc += Math.sin(9868) + Math.cos(9869) * 71;
+acc += Math.sin(9869) + Math.cos(9870) * 72;
+acc += Math.sin(9870) + Math.cos(9871) * 73;
+acc += Math.sin(9871) + Math.cos(9872) * 74;
+acc += Math.sin(9872) + Math.cos(9873) * 75;
+acc += Math.sin(9873) + Math.cos(9874) * 76;
+acc += Math.sin(9874) + Math.cos(9875) * 77;
+acc += Math.sin(9875) + Math.cos(9876) * 78;
+acc += Math.sin(9876) + Math.cos(9877) * 79;
+acc += Math.sin(9877) + Math.cos(9878) * 80;
+acc += Math.sin(9878) + Math.cos(9879) * 81;
+acc += Math.sin(9879) + Math.cos(9880) * 82;
+acc += Math.sin(9880) + Math.cos(9881) * 83;
+acc += Math.sin(9881) + Math.cos(9882) * 84;
+acc += Math.sin(9882) + Math.cos(9883) * 85;
+acc += Math.sin(9883) + Math.cos(9884) * 86;
+acc += Math.sin(9884) + Math.cos(9885) * 87;
+acc += Math.sin(9885) + Math.cos(9886) * 88;
+acc += Math.sin(9886) + Math.cos(9887) * 89;
+acc += Math.sin(9887) + Math.cos(9888) * 90;
+acc += Math.sin(9888) + Math.cos(9889) * 91;
+acc += Math.sin(9889) + Math.cos(9890) * 92;
+acc += Math.sin(9890) + Math.cos(9891) * 93;
+acc += Math.sin(9891) + Math.cos(9892) * 94;
+acc += Math.sin(9892) + Math.cos(9893) * 95;
+acc += Math.sin(9893) + Math.cos(9894) * 96;
+acc += Math.sin(9894) + Math.cos(9895) * 0;
+acc += Math.sin(9895) + Math.cos(9896) * 1;
+acc += Math.sin(9896) + Math.cos(9897) * 2;
+acc += Math.sin(9897) + Math.cos(9898) * 3;
+acc += Math.sin(9898) + Math.cos(9899) * 4;
+acc += Math.sin(9899) + Math.cos(9900) * 5;
+acc += Math.sin(9900) + Math.cos(9901) * 6;
+acc += Math.sin(9901) + Math.cos(9902) * 7;
+acc += Math.sin(9902) + Math.cos(9903) * 8;
+acc += Math.sin(9903) + Math.cos(9904) * 9;
+acc += Math.sin(9904) + Math.cos(9905) * 10;
+acc += Math.sin(9905) + Math.cos(9906) * 11;
+acc += Math.sin(9906) + Math.cos(9907) * 12;
+acc += Math.sin(9907) + Math.cos(9908) * 13;
+acc += Math.sin(9908) + Math.cos(9909) * 14;
+acc += Math.sin(9909) + Math.cos(9910) * 15;
+acc += Math.sin(9910) + Math.cos(9911) * 16;
+acc += Math.sin(9911) + Math.cos(9912) * 17;
+acc += Math.sin(9912) + Math.cos(9913) * 18;
+acc += Math.sin(9913) + Math.cos(9914) * 19;
+acc += Math.sin(9914) + Math.cos(9915) * 20;
+acc += Math.sin(9915) + Math.cos(9916) * 21;
+acc += Math.sin(9916) + Math.cos(9917) * 22;
+acc += Math.sin(9917) + Math.cos(9918) * 23;
+acc += Math.sin(9918) + Math.cos(9919) * 24;
+acc += Math.sin(9919) + Math.cos(9920) * 25;
+acc += Math.sin(9920) + Math.cos(9921) * 26;
+acc += Math.sin(9921) + Math.cos(9922) * 27;
+acc += Math.sin(9922) + Math.cos(9923) * 28;
+acc += Math.sin(9923) + Math.cos(9924) * 29;
+acc += Math.sin(9924) + Math.cos(9925) * 30;
+acc += Math.sin(9925) + Math.cos(9926) * 31;
+acc += Math.sin(9926) + Math.cos(9927) * 32;
+acc += Math.sin(9927) + Math.cos(9928) * 33;
+acc += Math.sin(9928) + Math.cos(9929) * 34;
+acc += Math.sin(9929) + Math.cos(9930) * 35;
+acc += Math.sin(9930) + Math.cos(9931) * 36;
+acc += Math.sin(9931) + Math.cos(9932) * 37;
+acc += Math.sin(9932) + Math.cos(9933) * 38;
+acc += Math.sin(9933) + Math.cos(9934) * 39;
+acc += Math.sin(9934) + Math.cos(9935) * 40;
+acc += Math.sin(9935) + Math.cos(9936) * 41;
+acc += Math.sin(9936) + Math.cos(9937) * 42;
+acc += Math.sin(9937) + Math.cos(9938) * 43;
+acc += Math.sin(9938) + Math.cos(9939) * 44;
+acc += Math.sin(9939) + Math.cos(9940) * 45;
+acc += Math.sin(9940) + Math.cos(9941) * 46;
+acc += Math.sin(9941) + Math.cos(9942) * 47;
+acc += Math.sin(9942) + Math.cos(9943) * 48;
+acc += Math.sin(9943) + Math.cos(9944) * 49;
+acc += Math.sin(9944) + Math.cos(9945) * 50;
+acc += Math.sin(9945) + Math.cos(9946) * 51;
+acc += Math.sin(9946) + Math.cos(9947) * 52;
+acc += Math.sin(9947) + Math.cos(9948) * 53;
+acc += Math.sin(9948) + Math.cos(9949) * 54;
+acc += Math.sin(9949) + Math.cos(9950) * 55;
+acc += Math.sin(9950) + Math.cos(9951) * 56;
+acc += Math.sin(9951) + Math.cos(9952) * 57;
+acc += Math.sin(9952) + Math.cos(9953) * 58;
+acc += Math.sin(9953) + Math.cos(9954) * 59;
+acc += Math.sin(9954) + Math.cos(9955) * 60;
+acc += Math.sin(9955) + Math.cos(9956) * 61;
+acc += Math.sin(9956) + Math.cos(9957) * 62;
+acc += Math.sin(9957) + Math.cos(9958) * 63;
+acc += Math.sin(9958) + Math.cos(9959) * 64;
+acc += Math.sin(9959) + Math.cos(9960) * 65;
+acc += Math.sin(9960) + Math.cos(9961) * 66;
+acc += Math.sin(9961) + Math.cos(9962) * 67;
+acc += Math.sin(9962) + Math.cos(9963) * 68;
+acc += Math.sin(9963) + Math.cos(9964) * 69;
+acc += Math.sin(9964) + Math.cos(9965) * 70;
+acc += Math.sin(9965) + Math.cos(9966) * 71;
+acc += Math.sin(9966) + Math.cos(9967) * 72;
+acc += Math.sin(9967) + Math.cos(9968) * 73;
+acc += Math.sin(9968) + Math.cos(9969) * 74;
+acc += Math.sin(9969) + Math.cos(9970) * 75;
+acc += Math.sin(9970) + Math.cos(9971) * 76;
+acc += Math.sin(9971) + Math.cos(9972) * 77;
+acc += Math.sin(9972) + Math.cos(9973) * 78;
+acc += Math.sin(9973) + Math.cos(9974) * 79;
+acc += Math.sin(9974) + Math.cos(9975) * 80;
+acc += Math.sin(9975) + Math.cos(9976) * 81;
+acc += Math.sin(9976) + Math.cos(9977) * 82;
+acc += Math.sin(9977) + Math.cos(9978) * 83;
+acc += Math.sin(9978) + Math.cos(9979) * 84;
+acc += Math.sin(9979) + Math.cos(9980) * 85;
+acc += Math.sin(9980) + Math.cos(9981) * 86;
+acc += Math.sin(9981) + Math.cos(9982) * 87;
+acc += Math.sin(9982) + Math.cos(9983) * 88;
+acc += Math.sin(9983) + Math.cos(9984) * 89;
+acc += Math.sin(9984) + Math.cos(9985) * 90;
+acc += Math.sin(9985) + Math.cos(9986) * 91;
+acc += Math.sin(9986) + Math.cos(9987) * 92;
+acc += Math.sin(9987) + Math.cos(9988) * 93;
+acc += Math.sin(9988) + Math.cos(9989) * 94;
+acc += Math.sin(9989) + Math.cos(9990) * 95;
+acc += Math.sin(9990) + Math.cos(9991) * 96;
+acc += Math.sin(9991) + Math.cos(9992) * 0;
+acc += Math.sin(9992) + Math.cos(9993) * 1;
+acc += Math.sin(9993) + Math.cos(9994) * 2;
+acc += Math.sin(9994) + Math.cos(9995) * 3;
+acc += Math.sin(9995) + Math.cos(9996) * 4;
+acc += Math.sin(9996) + Math.cos(9997) * 5;
+acc += Math.sin(9997) + Math.cos(9998) * 6;
+acc += Math.sin(9998) + Math.cos(9999) * 7;
+acc += Math.sin(9999) + Math.cos(10000) * 8;
+acc += Math.sin(10000) + Math.cos(10001) * 9;
+acc += Math.sin(10001) + Math.cos(10002) * 10;
+acc += Math.sin(10002) + Math.cos(10003) * 11;
+acc += Math.sin(10003) + Math.cos(10004) * 12;
+acc += Math.sin(10004) + Math.cos(10005) * 13;
+acc += Math.sin(10005) + Math.cos(10006) * 14;
+acc += Math.sin(10006) + Math.cos(10007) * 15;
+acc += Math.sin(10007) + Math.cos(10008) * 16;
+acc += Math.sin(10008) + Math.cos(10009) * 17;
+acc += Math.sin(10009) + Math.cos(10010) * 18;
+acc += Math.sin(10010) + Math.cos(10011) * 19;
+acc += Math.sin(10011) + Math.cos(10012) * 20;
+acc += Math.sin(10012) + Math.cos(10013) * 21;
+acc += Math.sin(10013) + Math.cos(10014) * 22;
+acc += Math.sin(10014) + Math.cos(10015) * 23;
+acc += Math.sin(10015) + Math.cos(10016) * 24;
+acc += Math.sin(10016) + Math.cos(10017) * 25;
+acc += Math.sin(10017) + Math.cos(10018) * 26;
+acc += Math.sin(10018) + Math.cos(10019) * 27;
+acc += Math.sin(10019) + Math.cos(10020) * 28;
+acc += Math.sin(10020) + Math.cos(10021) * 29;
+acc += Math.sin(10021) + Math.cos(10022) * 30;
+acc += Math.sin(10022) + Math.cos(10023) * 31;
+acc += Math.sin(10023) + Math.cos(10024) * 32;
+acc += Math.sin(10024) + Math.cos(10025) * 33;
+acc += Math.sin(10025) + Math.cos(10026) * 34;
+acc += Math.sin(10026) + Math.cos(10027) * 35;
+acc += Math.sin(10027) + Math.cos(10028) * 36;
+acc += Math.sin(10028) + Math.cos(10029) * 37;
+acc += Math.sin(10029) + Math.cos(10030) * 38;
+acc += Math.sin(10030) + Math.cos(10031) * 39;
+acc += Math.sin(10031) + Math.cos(10032) * 40;
+acc += Math.sin(10032) + Math.cos(10033) * 41;
+acc += Math.sin(10033) + Math.cos(10034) * 42;
+acc += Math.sin(10034) + Math.cos(10035) * 43;
+acc += Math.sin(10035) + Math.cos(10036) * 44;
+acc += Math.sin(10036) + Math.cos(10037) * 45;
+acc += Math.sin(10037) + Math.cos(10038) * 46;
+acc += Math.sin(10038) + Math.cos(10039) * 47;
+acc += Math.sin(10039) + Math.cos(10040) * 48;
+acc += Math.sin(10040) + Math.cos(10041) * 49;
+acc += Math.sin(10041) + Math.cos(10042) * 50;
+acc += Math.sin(10042) + Math.cos(10043) * 51;
+acc += Math.sin(10043) + Math.cos(10044) * 52;
+acc += Math.sin(10044) + Math.cos(10045) * 53;
+acc += Math.sin(10045) + Math.cos(10046) * 54;
+acc += Math.sin(10046) + Math.cos(10047) * 55;
+acc += Math.sin(10047) + Math.cos(10048) * 56;
+acc += Math.sin(10048) + Math.cos(10049) * 57;
+acc += Math.sin(10049) + Math.cos(10050) * 58;
+acc += Math.sin(10050) + Math.cos(10051) * 59;
+acc += Math.sin(10051) + Math.cos(10052) * 60;
+acc += Math.sin(10052) + Math.cos(10053) * 61;
+acc += Math.sin(10053) + Math.cos(10054) * 62;
+acc += Math.sin(10054) + Math.cos(10055) * 63;
+acc += Math.sin(10055) + Math.cos(10056) * 64;
+acc += Math.sin(10056) + Math.cos(10057) * 65;
+acc += Math.sin(10057) + Math.cos(10058) * 66;
+acc += Math.sin(10058) + Math.cos(10059) * 67;
+acc += Math.sin(10059) + Math.cos(10060) * 68;
+acc += Math.sin(10060) + Math.cos(10061) * 69;
+acc += Math.sin(10061) + Math.cos(10062) * 70;
+acc += Math.sin(10062) + Math.cos(10063) * 71;
+acc += Math.sin(10063) + Math.cos(10064) * 72;
+acc += Math.sin(10064) + Math.cos(10065) * 73;
+acc += Math.sin(10065) + Math.cos(10066) * 74;
+acc += Math.sin(10066) + Math.cos(10067) * 75;
+acc += Math.sin(10067) + Math.cos(10068) * 76;
+acc += Math.sin(10068) + Math.cos(10069) * 77;
+acc += Math.sin(10069) + Math.cos(10070) * 78;
+acc += Math.sin(10070) + Math.cos(10071) * 79;
+acc += Math.sin(10071) + Math.cos(10072) * 80;
+acc += Math.sin(10072) + Math.cos(10073) * 81;
+acc += Math.sin(10073) + Math.cos(10074) * 82;
+acc += Math.sin(10074) + Math.cos(10075) * 83;
+acc += Math.sin(10075) + Math.cos(10076) * 84;
+acc += Math.sin(10076) + Math.cos(10077) * 85;
+acc += Math.sin(10077) + Math.cos(10078) * 86;
+acc += Math.sin(10078) + Math.cos(10079) * 87;
+acc += Math.sin(10079) + Math.cos(10080) * 88;
+acc += Math.sin(10080) + Math.cos(10081) * 89;
+acc += Math.sin(10081) + Math.cos(10082) * 90;
+acc += Math.sin(10082) + Math.cos(10083) * 91;
+acc += Math.sin(10083) + Math.cos(10084) * 92;
+acc += Math.sin(10084) + Math.cos(10085) * 93;
+acc += Math.sin(10085) + Math.cos(10086) * 94;
+acc += Math.sin(10086) + Math.cos(10087) * 95;
+acc += Math.sin(10087) + Math.cos(10088) * 96;
+acc += Math.sin(10088) + Math.cos(10089) * 0;
+acc += Math.sin(10089) + Math.cos(10090) * 1;
+acc += Math.sin(10090) + Math.cos(10091) * 2;
+acc += Math.sin(10091) + Math.cos(10092) * 3;
+acc += Math.sin(10092) + Math.cos(10093) * 4;
+acc += Math.sin(10093) + Math.cos(10094) * 5;
+acc += Math.sin(10094) + Math.cos(10095) * 6;
+acc += Math.sin(10095) + Math.cos(10096) * 7;
+acc += Math.sin(10096) + Math.cos(10097) * 8;
+acc += Math.sin(10097) + Math.cos(10098) * 9;
+acc += Math.sin(10098) + Math.cos(10099) * 10;
+acc += Math.sin(10099) + Math.cos(10100) * 11;
+acc += Math.sin(10100) + Math.cos(10101) * 12;
+acc += Math.sin(10101) + Math.cos(10102) * 13;
+acc += Math.sin(10102) + Math.cos(10103) * 14;
+acc += Math.sin(10103) + Math.cos(10104) * 15;
+acc += Math.sin(10104) + Math.cos(10105) * 16;
+acc += Math.sin(10105) + Math.cos(10106) * 17;
+acc += Math.sin(10106) + Math.cos(10107) * 18;
+acc += Math.sin(10107) + Math.cos(10108) * 19;
+acc += Math.sin(10108) + Math.cos(10109) * 20;
+acc += Math.sin(10109) + Math.cos(10110) * 21;
+acc += Math.sin(10110) + Math.cos(10111) * 22;
+acc += Math.sin(10111) + Math.cos(10112) * 23;
+acc += Math.sin(10112) + Math.cos(10113) * 24;
+acc += Math.sin(10113) + Math.cos(10114) * 25;
+acc += Math.sin(10114) + Math.cos(10115) * 26;
+acc += Math.sin(10115) + Math.cos(10116) * 27;
+acc += Math.sin(10116) + Math.cos(10117) * 28;
+acc += Math.sin(10117) + Math.cos(10118) * 29;
+acc += Math.sin(10118) + Math.cos(10119) * 30;
+acc += Math.sin(10119) + Math.cos(10120) * 31;
+acc += Math.sin(10120) + Math.cos(10121) * 32;
+acc += Math.sin(10121) + Math.cos(10122) * 33;
+acc += Math.sin(10122) + Math.cos(10123) * 34;
+acc += Math.sin(10123) + Math.cos(10124) * 35;
+acc += Math.sin(10124) + Math.cos(10125) * 36;
+acc += Math.sin(10125) + Math.cos(10126) * 37;
+acc += Math.sin(10126) + Math.cos(10127) * 38;
+acc += Math.sin(10127) + Math.cos(10128) * 39;
+acc += Math.sin(10128) + Math.cos(10129) * 40;
+acc += Math.sin(10129) + Math.cos(10130) * 41;
+acc += Math.sin(10130) + Math.cos(10131) * 42;
+acc += Math.sin(10131) + Math.cos(10132) * 43;
+acc += Math.sin(10132) + Math.cos(10133) * 44;
+acc += Math.sin(10133) + Math.cos(10134) * 45;
+acc += Math.sin(10134) + Math.cos(10135) * 46;
+acc += Math.sin(10135) + Math.cos(10136) * 47;
+acc += Math.sin(10136) + Math.cos(10137) * 48;
+acc += Math.sin(10137) + Math.cos(10138) * 49;
+acc += Math.sin(10138) + Math.cos(10139) * 50;
+acc += Math.sin(10139) + Math.cos(10140) * 51;
+acc += Math.sin(10140) + Math.cos(10141) * 52;
+acc += Math.sin(10141) + Math.cos(10142) * 53;
+acc += Math.sin(10142) + Math.cos(10143) * 54;
+acc += Math.sin(10143) + Math.cos(10144) * 55;
+acc += Math.sin(10144) + Math.cos(10145) * 56;
+acc += Math.sin(10145) + Math.cos(10146) * 57;
+acc += Math.sin(10146) + Math.cos(10147) * 58;
+acc += Math.sin(10147) + Math.cos(10148) * 59;
+acc += Math.sin(10148) + Math.cos(10149) * 60;
+acc += Math.sin(10149) + Math.cos(10150) * 61;
+acc += Math.sin(10150) + Math.cos(10151) * 62;
+acc += Math.sin(10151) + Math.cos(10152) * 63;
+acc += Math.sin(10152) + Math.cos(10153) * 64;
+acc += Math.sin(10153) + Math.cos(10154) * 65;
+acc += Math.sin(10154) + Math.cos(10155) * 66;
+acc += Math.sin(10155) + Math.cos(10156) * 67;
+acc += Math.sin(10156) + Math.cos(10157) * 68;
+acc += Math.sin(10157) + Math.cos(10158) * 69;
+acc += Math.sin(10158) + Math.cos(10159) * 70;
+acc += Math.sin(10159) + Math.cos(10160) * 71;
+acc += Math.sin(10160) + Math.cos(10161) * 72;
+acc += Math.sin(10161) + Math.cos(10162) * 73;
+acc += Math.sin(10162) + Math.cos(10163) * 74;
+acc += Math.sin(10163) + Math.cos(10164) * 75;
+acc += Math.sin(10164) + Math.cos(10165) * 76;
+acc += Math.sin(10165) + Math.cos(10166) * 77;
+acc += Math.sin(10166) + Math.cos(10167) * 78;
+acc += Math.sin(10167) + Math.cos(10168) * 79;
+acc += Math.sin(10168) + Math.cos(10169) * 80;
+acc += Math.sin(10169) + Math.cos(10170) * 81;
+acc += Math.sin(10170) + Math.cos(10171) * 82;
+acc += Math.sin(10171) + Math.cos(10172) * 83;
+acc += Math.sin(10172) + Math.cos(10173) * 84;
+acc += Math.sin(10173) + Math.cos(10174) * 85;
+acc += Math.sin(10174) + Math.cos(10175) * 86;
+acc += Math.sin(10175) + Math.cos(10176) * 87;
+acc += Math.sin(10176) + Math.cos(10177) * 88;
+acc += Math.sin(10177) + Math.cos(10178) * 89;
+acc += Math.sin(10178) + Math.cos(10179) * 90;
+acc += Math.sin(10179) + Math.cos(10180) * 91;
+acc += Math.sin(10180) + Math.cos(10181) * 92;
+acc += Math.sin(10181) + Math.cos(10182) * 93;
+acc += Math.sin(10182) + Math.cos(10183) * 94;
+acc += Math.sin(10183) + Math.cos(10184) * 95;
+acc += Math.sin(10184) + Math.cos(10185) * 96;
+acc += Math.sin(10185) + Math.cos(10186) * 0;
+acc += Math.sin(10186) + Math.cos(10187) * 1;
+acc += Math.sin(10187) + Math.cos(10188) * 2;
+acc += Math.sin(10188) + Math.cos(10189) * 3;
+acc += Math.sin(10189) + Math.cos(10190) * 4;
+acc += Math.sin(10190) + Math.cos(10191) * 5;
+acc += Math.sin(10191) + Math.cos(10192) * 6;
+acc += Math.sin(10192) + Math.cos(10193) * 7;
+acc += Math.sin(10193) + Math.cos(10194) * 8;
+acc += Math.sin(10194) + Math.cos(10195) * 9;
+acc += Math.sin(10195) + Math.cos(10196) * 10;
+acc += Math.sin(10196) + Math.cos(10197) * 11;
+acc += Math.sin(10197) + Math.cos(10198) * 12;
+acc += Math.sin(10198) + Math.cos(10199) * 13;
+acc += Math.sin(10199) + Math.cos(10200) * 14;
+acc += Math.sin(10200) + Math.cos(10201) * 15;
+acc += Math.sin(10201) + Math.cos(10202) * 16;
+acc += Math.sin(10202) + Math.cos(10203) * 17;
+acc += Math.sin(10203) + Math.cos(10204) * 18;
+acc += Math.sin(10204) + Math.cos(10205) * 19;
+acc += Math.sin(10205) + Math.cos(10206) * 20;
+acc += Math.sin(10206) + Math.cos(10207) * 21;
+acc += Math.sin(10207) + Math.cos(10208) * 22;
+acc += Math.sin(10208) + Math.cos(10209) * 23;
+acc += Math.sin(10209) + Math.cos(10210) * 24;
+acc += Math.sin(10210) + Math.cos(10211) * 25;
+acc += Math.sin(10211) + Math.cos(10212) * 26;
+acc += Math.sin(10212) + Math.cos(10213) * 27;
+acc += Math.sin(10213) + Math.cos(10214) * 28;
+acc += Math.sin(10214) + Math.cos(10215) * 29;
+acc += Math.sin(10215) + Math.cos(10216) * 30;
+acc += Math.sin(10216) + Math.cos(10217) * 31;
+acc += Math.sin(10217) + Math.cos(10218) * 32;
+acc += Math.sin(10218) + Math.cos(10219) * 33;
+acc += Math.sin(10219) + Math.cos(10220) * 34;
+acc += Math.sin(10220) + Math.cos(10221) * 35;
+acc += Math.sin(10221) + Math.cos(10222) * 36;
+acc += Math.sin(10222) + Math.cos(10223) * 37;
+acc += Math.sin(10223) + Math.cos(10224) * 38;
+acc += Math.sin(10224) + Math.cos(10225) * 39;
+acc += Math.sin(10225) + Math.cos(10226) * 40;
+acc += Math.sin(10226) + Math.cos(10227) * 41;
+acc += Math.sin(10227) + Math.cos(10228) * 42;
+acc += Math.sin(10228) + Math.cos(10229) * 43;
+acc += Math.sin(10229) + Math.cos(10230) * 44;
+acc += Math.sin(10230) + Math.cos(10231) * 45;
+acc += Math.sin(10231) + Math.cos(10232) * 46;
+acc += Math.sin(10232) + Math.cos(10233) * 47;
+acc += Math.sin(10233) + Math.cos(10234) * 48;
+acc += Math.sin(10234) + Math.cos(10235) * 49;
+acc += Math.sin(10235) + Math.cos(10236) * 50;
+acc += Math.sin(10236) + Math.cos(10237) * 51;
+acc += Math.sin(10237) + Math.cos(10238) * 52;
+acc += Math.sin(10238) + Math.cos(10239) * 53;
+acc += Math.sin(10239) + Math.cos(10240) * 54;
+acc += Math.sin(10240) + Math.cos(10241) * 55;
+acc += Math.sin(10241) + Math.cos(10242) * 56;
+acc += Math.sin(10242) + Math.cos(10243) * 57;
+acc += Math.sin(10243) + Math.cos(10244) * 58;
+acc += Math.sin(10244) + Math.cos(10245) * 59;
+acc += Math.sin(10245) + Math.cos(10246) * 60;
+acc += Math.sin(10246) + Math.cos(10247) * 61;
+acc += Math.sin(10247) + Math.cos(10248) * 62;
+acc += Math.sin(10248) + Math.cos(10249) * 63;
+acc += Math.sin(10249) + Math.cos(10250) * 64;
+acc += Math.sin(10250) + Math.cos(10251) * 65;
+acc += Math.sin(10251) + Math.cos(10252) * 66;
+acc += Math.sin(10252) + Math.cos(10253) * 67;
+acc += Math.sin(10253) + Math.cos(10254) * 68;
+acc += Math.sin(10254) + Math.cos(10255) * 69;
+acc += Math.sin(10255) + Math.cos(10256) * 70;
+acc += Math.sin(10256) + Math.cos(10257) * 71;
+acc += Math.sin(10257) + Math.cos(10258) * 72;
+acc += Math.sin(10258) + Math.cos(10259) * 73;
+acc += Math.sin(10259) + Math.cos(10260) * 74;
+acc += Math.sin(10260) + Math.cos(10261) * 75;
+acc += Math.sin(10261) + Math.cos(10262) * 76;
+acc += Math.sin(10262) + Math.cos(10263) * 77;
+acc += Math.sin(10263) + Math.cos(10264) * 78;
+acc += Math.sin(10264) + Math.cos(10265) * 79;
+acc += Math.sin(10265) + Math.cos(10266) * 80;
+acc += Math.sin(10266) + Math.cos(10267) * 81;
+acc += Math.sin(10267) + Math.cos(10268) * 82;
+acc += Math.sin(10268) + Math.cos(10269) * 83;
+acc += Math.sin(10269) + Math.cos(10270) * 84;
+acc += Math.sin(10270) + Math.cos(10271) * 85;
+acc += Math.sin(10271) + Math.cos(10272) * 86;
+acc += Math.sin(10272) + Math.cos(10273) * 87;
+acc += Math.sin(10273) + Math.cos(10274) * 88;
+acc += Math.sin(10274) + Math.cos(10275) * 89;
+acc += Math.sin(10275) + Math.cos(10276) * 90;
+acc += Math.sin(10276) + Math.cos(10277) * 91;
+acc += Math.sin(10277) + Math.cos(10278) * 92;
+acc += Math.sin(10278) + Math.cos(10279) * 93;
+acc += Math.sin(10279) + Math.cos(10280) * 94;
+acc += Math.sin(10280) + Math.cos(10281) * 95;
+acc += Math.sin(10281) + Math.cos(10282) * 96;
+acc += Math.sin(10282) + Math.cos(10283) * 0;
+acc += Math.sin(10283) + Math.cos(10284) * 1;
+acc += Math.sin(10284) + Math.cos(10285) * 2;
+acc += Math.sin(10285) + Math.cos(10286) * 3;
+acc += Math.sin(10286) + Math.cos(10287) * 4;
+acc += Math.sin(10287) + Math.cos(10288) * 5;
+acc += Math.sin(10288) + Math.cos(10289) * 6;
+acc += Math.sin(10289) + Math.cos(10290) * 7;
+acc += Math.sin(10290) + Math.cos(10291) * 8;
+acc += Math.sin(10291) + Math.cos(10292) * 9;
+acc += Math.sin(10292) + Math.cos(10293) * 10;
+acc += Math.sin(10293) + Math.cos(10294) * 11;
+acc += Math.sin(10294) + Math.cos(10295) * 12;
+acc += Math.sin(10295) + Math.cos(10296) * 13;
+acc += Math.sin(10296) + Math.cos(10297) * 14;
+acc += Math.sin(10297) + Math.cos(10298) * 15;
+acc += Math.sin(10298) + Math.cos(10299) * 16;
+acc += Math.sin(10299) + Math.cos(10300) * 17;
+acc += Math.sin(10300) + Math.cos(10301) * 18;
+acc += Math.sin(10301) + Math.cos(10302) * 19;
+acc += Math.sin(10302) + Math.cos(10303) * 20;
+acc += Math.sin(10303) + Math.cos(10304) * 21;
+acc += Math.sin(10304) + Math.cos(10305) * 22;
+acc += Math.sin(10305) + Math.cos(10306) * 23;
+acc += Math.sin(10306) + Math.cos(10307) * 24;
+acc += Math.sin(10307) + Math.cos(10308) * 25;
+acc += Math.sin(10308) + Math.cos(10309) * 26;
+acc += Math.sin(10309) + Math.cos(10310) * 27;
+acc += Math.sin(10310) + Math.cos(10311) * 28;
+acc += Math.sin(10311) + Math.cos(10312) * 29;
+acc += Math.sin(10312) + Math.cos(10313) * 30;
+acc += Math.sin(10313) + Math.cos(10314) * 31;
+acc += Math.sin(10314) + Math.cos(10315) * 32;
+acc += Math.sin(10315) + Math.cos(10316) * 33;
+acc += Math.sin(10316) + Math.cos(10317) * 34;
+acc += Math.sin(10317) + Math.cos(10318) * 35;
+acc += Math.sin(10318) + Math.cos(10319) * 36;
+acc += Math.sin(10319) + Math.cos(10320) * 37;
+acc += Math.sin(10320) + Math.cos(10321) * 38;
+acc += Math.sin(10321) + Math.cos(10322) * 39;
+acc += Math.sin(10322) + Math.cos(10323) * 40;
+acc += Math.sin(10323) + Math.cos(10324) * 41;
+acc += Math.sin(10324) + Math.cos(10325) * 42;
+acc += Math.sin(10325) + Math.cos(10326) * 43;
+acc += Math.sin(10326) + Math.cos(10327) * 44;
+acc += Math.sin(10327) + Math.cos(10328) * 45;
+acc += Math.sin(10328) + Math.cos(10329) * 46;
+acc += Math.sin(10329) + Math.cos(10330) * 47;
+acc += Math.sin(10330) + Math.cos(10331) * 48;
+acc += Math.sin(10331) + Math.cos(10332) * 49;
+acc += Math.sin(10332) + Math.cos(10333) * 50;
+acc += Math.sin(10333) + Math.cos(10334) * 51;
+acc += Math.sin(10334) + Math.cos(10335) * 52;
+acc += Math.sin(10335) + Math.cos(10336) * 53;
+acc += Math.sin(10336) + Math.cos(10337) * 54;
+acc += Math.sin(10337) + Math.cos(10338) * 55;
+acc += Math.sin(10338) + Math.cos(10339) * 56;
+acc += Math.sin(10339) + Math.cos(10340) * 57;
+acc += Math.sin(10340) + Math.cos(10341) * 58;
+acc += Math.sin(10341) + Math.cos(10342) * 59;
+acc += Math.sin(10342) + Math.cos(10343) * 60;
+acc += Math.sin(10343) + Math.cos(10344) * 61;
+acc += Math.sin(10344) + Math.cos(10345) * 62;
+acc += Math.sin(10345) + Math.cos(10346) * 63;
+acc += Math.sin(10346) + Math.cos(10347) * 64;
+acc += Math.sin(10347) + Math.cos(10348) * 65;
+acc += Math.sin(10348) + Math.cos(10349) * 66;
+acc += Math.sin(10349) + Math.cos(10350) * 67;
+acc += Math.sin(10350) + Math.cos(10351) * 68;
+acc += Math.sin(10351) + Math.cos(10352) * 69;
+acc += Math.sin(10352) + Math.cos(10353) * 70;
+acc += Math.sin(10353) + Math.cos(10354) * 71;
+acc += Math.sin(10354) + Math.cos(10355) * 72;
+acc += Math.sin(10355) + Math.cos(10356) * 73;
+acc += Math.sin(10356) + Math.cos(10357) * 74;
+acc += Math.sin(10357) + Math.cos(10358) * 75;
+acc += Math.sin(10358) + Math.cos(10359) * 76;
+acc += Math.sin(10359) + Math.cos(10360) * 77;
+acc += Math.sin(10360) + Math.cos(10361) * 78;
+acc += Math.sin(10361) + Math.cos(10362) * 79;
+acc += Math.sin(10362) + Math.cos(10363) * 80;
+acc += Math.sin(10363) + Math.cos(10364) * 81;
+acc += Math.sin(10364) + Math.cos(10365) * 82;
+acc += Math.sin(10365) + Math.cos(10366) * 83;
+acc += Math.sin(10366) + Math.cos(10367) * 84;
+acc += Math.sin(10367) + Math.cos(10368) * 85;
+acc += Math.sin(10368) + Math.cos(10369) * 86;
+acc += Math.sin(10369) + Math.cos(10370) * 87;
+acc += Math.sin(10370) + Math.cos(10371) * 88;
+acc += Math.sin(10371) + Math.cos(10372) * 89;
+acc += Math.sin(10372) + Math.cos(10373) * 90;
+acc += Math.sin(10373) + Math.cos(10374) * 91;
+acc += Math.sin(10374) + Math.cos(10375) * 92;
+acc += Math.sin(10375) + Math.cos(10376) * 93;
+acc += Math.sin(10376) + Math.cos(10377) * 94;
+acc += Math.sin(10377) + Math.cos(10378) * 95;
+acc += Math.sin(10378) + Math.cos(10379) * 96;
+acc += Math.sin(10379) + Math.cos(10380) * 0;
+acc += Math.sin(10380) + Math.cos(10381) * 1;
+acc += Math.sin(10381) + Math.cos(10382) * 2;
+acc += Math.sin(10382) + Math.cos(10383) * 3;
+acc += Math.sin(10383) + Math.cos(10384) * 4;
+acc += Math.sin(10384) + Math.cos(10385) * 5;
+acc += Math.sin(10385) + Math.cos(10386) * 6;
+acc += Math.sin(10386) + Math.cos(10387) * 7;
+acc += Math.sin(10387) + Math.cos(10388) * 8;
+acc += Math.sin(10388) + Math.cos(10389) * 9;
+acc += Math.sin(10389) + Math.cos(10390) * 10;
+acc += Math.sin(10390) + Math.cos(10391) * 11;
+acc += Math.sin(10391) + Math.cos(10392) * 12;
+acc += Math.sin(10392) + Math.cos(10393) * 13;
+acc += Math.sin(10393) + Math.cos(10394) * 14;
+acc += Math.sin(10394) + Math.cos(10395) * 15;
+acc += Math.sin(10395) + Math.cos(10396) * 16;
+acc += Math.sin(10396) + Math.cos(10397) * 17;
+acc += Math.sin(10397) + Math.cos(10398) * 18;
+acc += Math.sin(10398) + Math.cos(10399) * 19;
+acc += Math.sin(10399) + Math.cos(10400) * 20;
+acc += Math.sin(10400) + Math.cos(10401) * 21;
+acc += Math.sin(10401) + Math.cos(10402) * 22;
+acc += Math.sin(10402) + Math.cos(10403) * 23;
+acc += Math.sin(10403) + Math.cos(10404) * 24;
+acc += Math.sin(10404) + Math.cos(10405) * 25;
+acc += Math.sin(10405) + Math.cos(10406) * 26;
+acc += Math.sin(10406) + Math.cos(10407) * 27;
+acc += Math.sin(10407) + Math.cos(10408) * 28;
+acc += Math.sin(10408) + Math.cos(10409) * 29;
+acc += Math.sin(10409) + Math.cos(10410) * 30;
+acc += Math.sin(10410) + Math.cos(10411) * 31;
+acc += Math.sin(10411) + Math.cos(10412) * 32;
+acc += Math.sin(10412) + Math.cos(10413) * 33;
+acc += Math.sin(10413) + Math.cos(10414) * 34;
+acc += Math.sin(10414) + Math.cos(10415) * 35;
+acc += Math.sin(10415) + Math.cos(10416) * 36;
+acc += Math.sin(10416) + Math.cos(10417) * 37;
+acc += Math.sin(10417) + Math.cos(10418) * 38;
+acc += Math.sin(10418) + Math.cos(10419) * 39;
+acc += Math.sin(10419) + Math.cos(10420) * 40;
+acc += Math.sin(10420) + Math.cos(10421) * 41;
+acc += Math.sin(10421) + Math.cos(10422) * 42;
+acc += Math.sin(10422) + Math.cos(10423) * 43;
+acc += Math.sin(10423) + Math.cos(10424) * 44;
+acc += Math.sin(10424) + Math.cos(10425) * 45;
+acc += Math.sin(10425) + Math.cos(10426) * 46;
+acc += Math.sin(10426) + Math.cos(10427) * 47;
+acc += Math.sin(10427) + Math.cos(10428) * 48;
+acc += Math.sin(10428) + Math.cos(10429) * 49;
+acc += Math.sin(10429) + Math.cos(10430) * 50;
+acc += Math.sin(10430) + Math.cos(10431) * 51;
+acc += Math.sin(10431) + Math.cos(10432) * 52;
+acc += Math.sin(10432) + Math.cos(10433) * 53;
+acc += Math.sin(10433) + Math.cos(10434) * 54;
+acc += Math.sin(10434) + Math.cos(10435) * 55;
+acc += Math.sin(10435) + Math.cos(10436) * 56;
+acc += Math.sin(10436) + Math.cos(10437) * 57;
+acc += Math.sin(10437) + Math.cos(10438) * 58;
+acc += Math.sin(10438) + Math.cos(10439) * 59;
+acc += Math.sin(10439) + Math.cos(10440) * 60;
+acc += Math.sin(10440) + Math.cos(10441) * 61;
+acc += Math.sin(10441) + Math.cos(10442) * 62;
+acc += Math.sin(10442) + Math.cos(10443) * 63;
+acc += Math.sin(10443) + Math.cos(10444) * 64;
+acc += Math.sin(10444) + Math.cos(10445) * 65;
+acc += Math.sin(10445) + Math.cos(10446) * 66;
+acc += Math.sin(10446) + Math.cos(10447) * 67;
+acc += Math.sin(10447) + Math.cos(10448) * 68;
+acc += Math.sin(10448) + Math.cos(10449) * 69;
+acc += Math.sin(10449) + Math.cos(10450) * 70;
+acc += Math.sin(10450) + Math.cos(10451) * 71;
+acc += Math.sin(10451) + Math.cos(10452) * 72;
+acc += Math.sin(10452) + Math.cos(10453) * 73;
+acc += Math.sin(10453) + Math.cos(10454) * 74;
+acc += Math.sin(10454) + Math.cos(10455) * 75;
+acc += Math.sin(10455) + Math.cos(10456) * 76;
+acc += Math.sin(10456) + Math.cos(10457) * 77;
+acc += Math.sin(10457) + Math.cos(10458) * 78;
+acc += Math.sin(10458) + Math.cos(10459) * 79;
+acc += Math.sin(10459) + Math.cos(10460) * 80;
+acc += Math.sin(10460) + Math.cos(10461) * 81;
+acc += Math.sin(10461) + Math.cos(10462) * 82;
+acc += Math.sin(10462) + Math.cos(10463) * 83;
+acc += Math.sin(10463) + Math.cos(10464) * 84;
+acc += Math.sin(10464) + Math.cos(10465) * 85;
+acc += Math.sin(10465) + Math.cos(10466) * 86;
+acc += Math.sin(10466) + Math.cos(10467) * 87;
+acc += Math.sin(10467) + Math.cos(10468) * 88;
+acc += Math.sin(10468) + Math.cos(10469) * 89;
+acc += Math.sin(10469) + Math.cos(10470) * 90;
+acc += Math.sin(10470) + Math.cos(10471) * 91;
+acc += Math.sin(10471) + Math.cos(10472) * 92;
+acc += Math.sin(10472) + Math.cos(10473) * 93;
+acc += Math.sin(10473) + Math.cos(10474) * 94;
+acc += Math.sin(10474) + Math.cos(10475) * 95;
+acc += Math.sin(10475) + Math.cos(10476) * 96;
+acc += Math.sin(10476) + Math.cos(10477) * 0;
+acc += Math.sin(10477) + Math.cos(10478) * 1;
+acc += Math.sin(10478) + Math.cos(10479) * 2;
+acc += Math.sin(10479) + Math.cos(10480) * 3;
+acc += Math.sin(10480) + Math.cos(10481) * 4;
+acc += Math.sin(10481) + Math.cos(10482) * 5;
+acc += Math.sin(10482) + Math.cos(10483) * 6;
+acc += Math.sin(10483) + Math.cos(10484) * 7;
+acc += Math.sin(10484) + Math.cos(10485) * 8;
+acc += Math.sin(10485) + Math.cos(10486) * 9;
+acc += Math.sin(10486) + Math.cos(10487) * 10;
+acc += Math.sin(10487) + Math.cos(10488) * 11;
+acc += Math.sin(10488) + Math.cos(10489) * 12;
+acc += Math.sin(10489) + Math.cos(10490) * 13;
+acc += Math.sin(10490) + Math.cos(10491) * 14;
+acc += Math.sin(10491) + Math.cos(10492) * 15;
+acc += Math.sin(10492) + Math.cos(10493) * 16;
+acc += Math.sin(10493) + Math.cos(10494) * 17;
+acc += Math.sin(10494) + Math.cos(10495) * 18;
+acc += Math.sin(10495) + Math.cos(10496) * 19;
+acc += Math.sin(10496) + Math.cos(10497) * 20;
+acc += Math.sin(10497) + Math.cos(10498) * 21;
+acc += Math.sin(10498) + Math.cos(10499) * 22;
+acc += Math.sin(10499) + Math.cos(10500) * 23;
+acc += Math.sin(10500) + Math.cos(10501) * 24;
+acc += Math.sin(10501) + Math.cos(10502) * 25;
+acc += Math.sin(10502) + Math.cos(10503) * 26;
+acc += Math.sin(10503) + Math.cos(10504) * 27;
+acc += Math.sin(10504) + Math.cos(10505) * 28;
+acc += Math.sin(10505) + Math.cos(10506) * 29;
+acc += Math.sin(10506) + Math.cos(10507) * 30;
+acc += Math.sin(10507) + Math.cos(10508) * 31;
+acc += Math.sin(10508) + Math.cos(10509) * 32;
+acc += Math.sin(10509) + Math.cos(10510) * 33;
+acc += Math.sin(10510) + Math.cos(10511) * 34;
+acc += Math.sin(10511) + Math.cos(10512) * 35;
+acc += Math.sin(10512) + Math.cos(10513) * 36;
+acc += Math.sin(10513) + Math.cos(10514) * 37;
+acc += Math.sin(10514) + Math.cos(10515) * 38;
+acc += Math.sin(10515) + Math.cos(10516) * 39;
+acc += Math.sin(10516) + Math.cos(10517) * 40;
+acc += Math.sin(10517) + Math.cos(10518) * 41;
+acc += Math.sin(10518) + Math.cos(10519) * 42;
+acc += Math.sin(10519) + Math.cos(10520) * 43;
+acc += Math.sin(10520) + Math.cos(10521) * 44;
+acc += Math.sin(10521) + Math.cos(10522) * 45;
+acc += Math.sin(10522) + Math.cos(10523) * 46;
+acc += Math.sin(10523) + Math.cos(10524) * 47;
+acc += Math.sin(10524) + Math.cos(10525) * 48;
+acc += Math.sin(10525) + Math.cos(10526) * 49;
+acc += Math.sin(10526) + Math.cos(10527) * 50;
+acc += Math.sin(10527) + Math.cos(10528) * 51;
+acc += Math.sin(10528) + Math.cos(10529) * 52;
+acc += Math.sin(10529) + Math.cos(10530) * 53;
+acc += Math.sin(10530) + Math.cos(10531) * 54;
+acc += Math.sin(10531) + Math.cos(10532) * 55;
+acc += Math.sin(10532) + Math.cos(10533) * 56;
+acc += Math.sin(10533) + Math.cos(10534) * 57;
+acc += Math.sin(10534) + Math.cos(10535) * 58;
+acc += Math.sin(10535) + Math.cos(10536) * 59;
+acc += Math.sin(10536) + Math.cos(10537) * 60;
+acc += Math.sin(10537) + Math.cos(10538) * 61;
+acc += Math.sin(10538) + Math.cos(10539) * 62;
+acc += Math.sin(10539) + Math.cos(10540) * 63;
+acc += Math.sin(10540) + Math.cos(10541) * 64;
+acc += Math.sin(10541) + Math.cos(10542) * 65;
+acc += Math.sin(10542) + Math.cos(10543) * 66;
+acc += Math.sin(10543) + Math.cos(10544) * 67;
+acc += Math.sin(10544) + Math.cos(10545) * 68;
+acc += Math.sin(10545) + Math.cos(10546) * 69;
+acc += Math.sin(10546) + Math.cos(10547) * 70;
+acc += Math.sin(10547) + Math.cos(10548) * 71;
+acc += Math.sin(10548) + Math.cos(10549) * 72;
+acc += Math.sin(10549) + Math.cos(10550) * 73;
+acc += Math.sin(10550) + Math.cos(10551) * 74;
+acc += Math.sin(10551) + Math.cos(10552) * 75;
+acc += Math.sin(10552) + Math.cos(10553) * 76;
+acc += Math.sin(10553) + Math.cos(10554) * 77;
+acc += Math.sin(10554) + Math.cos(10555) * 78;
+acc += Math.sin(10555) + Math.cos(10556) * 79;
+acc += Math.sin(10556) + Math.cos(10557) * 80;
+acc += Math.sin(10557) + Math.cos(10558) * 81;
+acc += Math.sin(10558) + Math.cos(10559) * 82;
+acc += Math.sin(10559) + Math.cos(10560) * 83;
+acc += Math.sin(10560) + Math.cos(10561) * 84;
+acc += Math.sin(10561) + Math.cos(10562) * 85;
+acc += Math.sin(10562) + Math.cos(10563) * 86;
+acc += Math.sin(10563) + Math.cos(10564) * 87;
+acc += Math.sin(10564) + Math.cos(10565) * 88;
+acc += Math.sin(10565) + Math.cos(10566) * 89;
+acc += Math.sin(10566) + Math.cos(10567) * 90;
+acc += Math.sin(10567) + Math.cos(10568) * 91;
+acc += Math.sin(10568) + Math.cos(10569) * 92;
+acc += Math.sin(10569) + Math.cos(10570) * 93;
+acc += Math.sin(10570) + Math.cos(10571) * 94;
+acc += Math.sin(10571) + Math.cos(10572) * 95;
+acc += Math.sin(10572) + Math.cos(10573) * 96;
+acc += Math.sin(10573) + Math.cos(10574) * 0;
+acc += Math.sin(10574) + Math.cos(10575) * 1;
+acc += Math.sin(10575) + Math.cos(10576) * 2;
+acc += Math.sin(10576) + Math.cos(10577) * 3;
+acc += Math.sin(10577) + Math.cos(10578) * 4;
+acc += Math.sin(10578) + Math.cos(10579) * 5;
+acc += Math.sin(10579) + Math.cos(10580) * 6;
+acc += Math.sin(10580) + Math.cos(10581) * 7;
+acc += Math.sin(10581) + Math.cos(10582) * 8;
+acc += Math.sin(10582) + Math.cos(10583) * 9;
+acc += Math.sin(10583) + Math.cos(10584) * 10;
+acc += Math.sin(10584) + Math.cos(10585) * 11;
+acc += Math.sin(10585) + Math.cos(10586) * 12;
+acc += Math.sin(10586) + Math.cos(10587) * 13;
+acc += Math.sin(10587) + Math.cos(10588) * 14;
+acc += Math.sin(10588) + Math.cos(10589) * 15;
+acc += Math.sin(10589) + Math.cos(10590) * 16;
+acc += Math.sin(10590) + Math.cos(10591) * 17;
+acc += Math.sin(10591) + Math.cos(10592) * 18;
+acc += Math.sin(10592) + Math.cos(10593) * 19;
+acc += Math.sin(10593) + Math.cos(10594) * 20;
+acc += Math.sin(10594) + Math.cos(10595) * 21;
+acc += Math.sin(10595) + Math.cos(10596) * 22;
+acc += Math.sin(10596) + Math.cos(10597) * 23;
+acc += Math.sin(10597) + Math.cos(10598) * 24;
+acc += Math.sin(10598) + Math.cos(10599) * 25;
+acc += Math.sin(10599) + Math.cos(10600) * 26;
+acc += Math.sin(10600) + Math.cos(10601) * 27;
+acc += Math.sin(10601) + Math.cos(10602) * 28;
+acc += Math.sin(10602) + Math.cos(10603) * 29;
+acc += Math.sin(10603) + Math.cos(10604) * 30;
+acc += Math.sin(10604) + Math.cos(10605) * 31;
+acc += Math.sin(10605) + Math.cos(10606) * 32;
+acc += Math.sin(10606) + Math.cos(10607) * 33;
+acc += Math.sin(10607) + Math.cos(10608) * 34;
+acc += Math.sin(10608) + Math.cos(10609) * 35;
+acc += Math.sin(10609) + Math.cos(10610) * 36;
+acc += Math.sin(10610) + Math.cos(10611) * 37;
+acc += Math.sin(10611) + Math.cos(10612) * 38;
+acc += Math.sin(10612) + Math.cos(10613) * 39;
+acc += Math.sin(10613) + Math.cos(10614) * 40;
+acc += Math.sin(10614) + Math.cos(10615) * 41;
+acc += Math.sin(10615) + Math.cos(10616) * 42;
+acc += Math.sin(10616) + Math.cos(10617) * 43;
+acc += Math.sin(10617) + Math.cos(10618) * 44;
+acc += Math.sin(10618) + Math.cos(10619) * 45;
+acc += Math.sin(10619) + Math.cos(10620) * 46;
+acc += Math.sin(10620) + Math.cos(10621) * 47;
+acc += Math.sin(10621) + Math.cos(10622) * 48;
+acc += Math.sin(10622) + Math.cos(10623) * 49;
+acc += Math.sin(10623) + Math.cos(10624) * 50;
+acc += Math.sin(10624) + Math.cos(10625) * 51;
+acc += Math.sin(10625) + Math.cos(10626) * 52;
+acc += Math.sin(10626) + Math.cos(10627) * 53;
+acc += Math.sin(10627) + Math.cos(10628) * 54;
+acc += Math.sin(10628) + Math.cos(10629) * 55;
+acc += Math.sin(10629) + Math.cos(10630) * 56;
+acc += Math.sin(10630) + Math.cos(10631) * 57;
+acc += Math.sin(10631) + Math.cos(10632) * 58;
+acc += Math.sin(10632) + Math.cos(10633) * 59;
+acc += Math.sin(10633) + Math.cos(10634) * 60;
+acc += Math.sin(10634) + Math.cos(10635) * 61;
+acc += Math.sin(10635) + Math.cos(10636) * 62;
+acc += Math.sin(10636) + Math.cos(10637) * 63;
+acc += Math.sin(10637) + Math.cos(10638) * 64;
+acc += Math.sin(10638) + Math.cos(10639) * 65;
+acc += Math.sin(10639) + Math.cos(10640) * 66;
+acc += Math.sin(10640) + Math.cos(10641) * 67;
+acc += Math.sin(10641) + Math.cos(10642) * 68;
+acc += Math.sin(10642) + Math.cos(10643) * 69;
+acc += Math.sin(10643) + Math.cos(10644) * 70;
+acc += Math.sin(10644) + Math.cos(10645) * 71;
+acc += Math.sin(10645) + Math.cos(10646) * 72;
+acc += Math.sin(10646) + Math.cos(10647) * 73;
+acc += Math.sin(10647) + Math.cos(10648) * 74;
+acc += Math.sin(10648) + Math.cos(10649) * 75;
+acc += Math.sin(10649) + Math.cos(10650) * 76;
+acc += Math.sin(10650) + Math.cos(10651) * 77;
+acc += Math.sin(10651) + Math.cos(10652) * 78;
+acc += Math.sin(10652) + Math.cos(10653) * 79;
+acc += Math.sin(10653) + Math.cos(10654) * 80;
+acc += Math.sin(10654) + Math.cos(10655) * 81;
+acc += Math.sin(10655) + Math.cos(10656) * 82;
+acc += Math.sin(10656) + Math.cos(10657) * 83;
+acc += Math.sin(10657) + Math.cos(10658) * 84;
+acc += Math.sin(10658) + Math.cos(10659) * 85;
+acc += Math.sin(10659) + Math.cos(10660) * 86;
+acc += Math.sin(10660) + Math.cos(10661) * 87;
+acc += Math.sin(10661) + Math.cos(10662) * 88;
+acc += Math.sin(10662) + Math.cos(10663) * 89;
+acc += Math.sin(10663) + Math.cos(10664) * 90;
+acc += Math.sin(10664) + Math.cos(10665) * 91;
+acc += Math.sin(10665) + Math.cos(10666) * 92;
+acc += Math.sin(10666) + Math.cos(10667) * 93;
+acc += Math.sin(10667) + Math.cos(10668) * 94;
+acc += Math.sin(10668) + Math.cos(10669) * 95;
+acc += Math.sin(10669) + Math.cos(10670) * 96;
+acc += Math.sin(10670) + Math.cos(10671) * 0;
+acc += Math.sin(10671) + Math.cos(10672) * 1;
+acc += Math.sin(10672) + Math.cos(10673) * 2;
+acc += Math.sin(10673) + Math.cos(10674) * 3;
+acc += Math.sin(10674) + Math.cos(10675) * 4;
+acc += Math.sin(10675) + Math.cos(10676) * 5;
+acc += Math.sin(10676) + Math.cos(10677) * 6;
+acc += Math.sin(10677) + Math.cos(10678) * 7;
+acc += Math.sin(10678) + Math.cos(10679) * 8;
+acc += Math.sin(10679) + Math.cos(10680) * 9;
+acc += Math.sin(10680) + Math.cos(10681) * 10;
+acc += Math.sin(10681) + Math.cos(10682) * 11;
+acc += Math.sin(10682) + Math.cos(10683) * 12;
+acc += Math.sin(10683) + Math.cos(10684) * 13;
+acc += Math.sin(10684) + Math.cos(10685) * 14;
+acc += Math.sin(10685) + Math.cos(10686) * 15;
+acc += Math.sin(10686) + Math.cos(10687) * 16;
+acc += Math.sin(10687) + Math.cos(10688) * 17;
+acc += Math.sin(10688) + Math.cos(10689) * 18;
+acc += Math.sin(10689) + Math.cos(10690) * 19;
+acc += Math.sin(10690) + Math.cos(10691) * 20;
+acc += Math.sin(10691) + Math.cos(10692) * 21;
+acc += Math.sin(10692) + Math.cos(10693) * 22;
+acc += Math.sin(10693) + Math.cos(10694) * 23;
+acc += Math.sin(10694) + Math.cos(10695) * 24;
+acc += Math.sin(10695) + Math.cos(10696) * 25;
+acc += Math.sin(10696) + Math.cos(10697) * 26;
+acc += Math.sin(10697) + Math.cos(10698) * 27;
+acc += Math.sin(10698) + Math.cos(10699) * 28;
+acc += Math.sin(10699) + Math.cos(10700) * 29;
+acc += Math.sin(10700) + Math.cos(10701) * 30;
+acc += Math.sin(10701) + Math.cos(10702) * 31;
+acc += Math.sin(10702) + Math.cos(10703) * 32;
+acc += Math.sin(10703) + Math.cos(10704) * 33;
+acc += Math.sin(10704) + Math.cos(10705) * 34;
+acc += Math.sin(10705) + Math.cos(10706) * 35;
+acc += Math.sin(10706) + Math.cos(10707) * 36;
+acc += Math.sin(10707) + Math.cos(10708) * 37;
+acc += Math.sin(10708) + Math.cos(10709) * 38;
+acc += Math.sin(10709) + Math.cos(10710) * 39;
+acc += Math.sin(10710) + Math.cos(10711) * 40;
+acc += Math.sin(10711) + Math.cos(10712) * 41;
+acc += Math.sin(10712) + Math.cos(10713) * 42;
+acc += Math.sin(10713) + Math.cos(10714) * 43;
+acc += Math.sin(10714) + Math.cos(10715) * 44;
+acc += Math.sin(10715) + Math.cos(10716) * 45;
+acc += Math.sin(10716) + Math.cos(10717) * 46;
+acc += Math.sin(10717) + Math.cos(10718) * 47;
+acc += Math.sin(10718) + Math.cos(10719) * 48;
+acc += Math.sin(10719) + Math.cos(10720) * 49;
+acc += Math.sin(10720) + Math.cos(10721) * 50;
+acc += Math.sin(10721) + Math.cos(10722) * 51;
+acc += Math.sin(10722) + Math.cos(10723) * 52;
+acc += Math.sin(10723) + Math.cos(10724) * 53;
+acc += Math.sin(10724) + Math.cos(10725) * 54;
+acc += Math.sin(10725) + Math.cos(10726) * 55;
+acc += Math.sin(10726) + Math.cos(10727) * 56;
+acc += Math.sin(10727) + Math.cos(10728) * 57;
+acc += Math.sin(10728) + Math.cos(10729) * 58;
+acc += Math.sin(10729) + Math.cos(10730) * 59;
+acc += Math.sin(10730) + Math.cos(10731) * 60;
+acc += Math.sin(10731) + Math.cos(10732) * 61;
+acc += Math.sin(10732) + Math.cos(10733) * 62;
+acc += Math.sin(10733) + Math.cos(10734) * 63;
+acc += Math.sin(10734) + Math.cos(10735) * 64;
+acc += Math.sin(10735) + Math.cos(10736) * 65;
+acc += Math.sin(10736) + Math.cos(10737) * 66;
+acc += Math.sin(10737) + Math.cos(10738) * 67;
+acc += Math.sin(10738) + Math.cos(10739) * 68;
+acc += Math.sin(10739) + Math.cos(10740) * 69;
+acc += Math.sin(10740) + Math.cos(10741) * 70;
+acc += Math.sin(10741) + Math.cos(10742) * 71;
+acc += Math.sin(10742) + Math.cos(10743) * 72;
+acc += Math.sin(10743) + Math.cos(10744) * 73;
+acc += Math.sin(10744) + Math.cos(10745) * 74;
+acc += Math.sin(10745) + Math.cos(10746) * 75;
+acc += Math.sin(10746) + Math.cos(10747) * 76;
+acc += Math.sin(10747) + Math.cos(10748) * 77;
+acc += Math.sin(10748) + Math.cos(10749) * 78;
+acc += Math.sin(10749) + Math.cos(10750) * 79;
+acc += Math.sin(10750) + Math.cos(10751) * 80;
+acc += Math.sin(10751) + Math.cos(10752) * 81;
+acc += Math.sin(10752) + Math.cos(10753) * 82;
+acc += Math.sin(10753) + Math.cos(10754) * 83;
+acc += Math.sin(10754) + Math.cos(10755) * 84;
+acc += Math.sin(10755) + Math.cos(10756) * 85;
+acc += Math.sin(10756) + Math.cos(10757) * 86;
+acc += Math.sin(10757) + Math.cos(10758) * 87;
+acc += Math.sin(10758) + Math.cos(10759) * 88;
+acc += Math.sin(10759) + Math.cos(10760) * 89;
+acc += Math.sin(10760) + Math.cos(10761) * 90;
+acc += Math.sin(10761) + Math.cos(10762) * 91;
+acc += Math.sin(10762) + Math.cos(10763) * 92;
+acc += Math.sin(10763) + Math.cos(10764) * 93;
+acc += Math.sin(10764) + Math.cos(10765) * 94;
+acc += Math.sin(10765) + Math.cos(10766) * 95;
+acc += Math.sin(10766) + Math.cos(10767) * 96;
+acc += Math.sin(10767) + Math.cos(10768) * 0;
+acc += Math.sin(10768) + Math.cos(10769) * 1;
+acc += Math.sin(10769) + Math.cos(10770) * 2;
+acc += Math.sin(10770) + Math.cos(10771) * 3;
+acc += Math.sin(10771) + Math.cos(10772) * 4;
+acc += Math.sin(10772) + Math.cos(10773) * 5;
+acc += Math.sin(10773) + Math.cos(10774) * 6;
+acc += Math.sin(10774) + Math.cos(10775) * 7;
+acc += Math.sin(10775) + Math.cos(10776) * 8;
+acc += Math.sin(10776) + Math.cos(10777) * 9;
+acc += Math.sin(10777) + Math.cos(10778) * 10;
+acc += Math.sin(10778) + Math.cos(10779) * 11;
+acc += Math.sin(10779) + Math.cos(10780) * 12;
+acc += Math.sin(10780) + Math.cos(10781) * 13;
+acc += Math.sin(10781) + Math.cos(10782) * 14;
+acc += Math.sin(10782) + Math.cos(10783) * 15;
+acc += Math.sin(10783) + Math.cos(10784) * 16;
+acc += Math.sin(10784) + Math.cos(10785) * 17;
+acc += Math.sin(10785) + Math.cos(10786) * 18;
+acc += Math.sin(10786) + Math.cos(10787) * 19;
+acc += Math.sin(10787) + Math.cos(10788) * 20;
+acc += Math.sin(10788) + Math.cos(10789) * 21;
+acc += Math.sin(10789) + Math.cos(10790) * 22;
+acc += Math.sin(10790) + Math.cos(10791) * 23;
+acc += Math.sin(10791) + Math.cos(10792) * 24;
+acc += Math.sin(10792) + Math.cos(10793) * 25;
+acc += Math.sin(10793) + Math.cos(10794) * 26;
+acc += Math.sin(10794) + Math.cos(10795) * 27;
+acc += Math.sin(10795) + Math.cos(10796) * 28;
+acc += Math.sin(10796) + Math.cos(10797) * 29;
+acc += Math.sin(10797) + Math.cos(10798) * 30;
+acc += Math.sin(10798) + Math.cos(10799) * 31;
+acc += Math.sin(10799) + Math.cos(10800) * 32;
+acc += Math.sin(10800) + Math.cos(10801) * 33;
+acc += Math.sin(10801) + Math.cos(10802) * 34;
+acc += Math.sin(10802) + Math.cos(10803) * 35;
+acc += Math.sin(10803) + Math.cos(10804) * 36;
+acc += Math.sin(10804) + Math.cos(10805) * 37;
+acc += Math.sin(10805) + Math.cos(10806) * 38;
+acc += Math.sin(10806) + Math.cos(10807) * 39;
+acc += Math.sin(10807) + Math.cos(10808) * 40;
+acc += Math.sin(10808) + Math.cos(10809) * 41;
+acc += Math.sin(10809) + Math.cos(10810) * 42;
+acc += Math.sin(10810) + Math.cos(10811) * 43;
+acc += Math.sin(10811) + Math.cos(10812) * 44;
+acc += Math.sin(10812) + Math.cos(10813) * 45;
+acc += Math.sin(10813) + Math.cos(10814) * 46;
+acc += Math.sin(10814) + Math.cos(10815) * 47;
+acc += Math.sin(10815) + Math.cos(10816) * 48;
+acc += Math.sin(10816) + Math.cos(10817) * 49;
+acc += Math.sin(10817) + Math.cos(10818) * 50;
+acc += Math.sin(10818) + Math.cos(10819) * 51;
+acc += Math.sin(10819) + Math.cos(10820) * 52;
+acc += Math.sin(10820) + Math.cos(10821) * 53;
+acc += Math.sin(10821) + Math.cos(10822) * 54;
+acc += Math.sin(10822) + Math.cos(10823) * 55;
+acc += Math.sin(10823) + Math.cos(10824) * 56;
+acc += Math.sin(10824) + Math.cos(10825) * 57;
+acc += Math.sin(10825) + Math.cos(10826) * 58;
+acc += Math.sin(10826) + Math.cos(10827) * 59;
+acc += Math.sin(10827) + Math.cos(10828) * 60;
+acc += Math.sin(10828) + Math.cos(10829) * 61;
+acc += Math.sin(10829) + Math.cos(10830) * 62;
+acc += Math.sin(10830) + Math.cos(10831) * 63;
+acc += Math.sin(10831) + Math.cos(10832) * 64;
+acc += Math.sin(10832) + Math.cos(10833) * 65;
+acc += Math.sin(10833) + Math.cos(10834) * 66;
+acc += Math.sin(10834) + Math.cos(10835) * 67;
+acc += Math.sin(10835) + Math.cos(10836) * 68;
+acc += Math.sin(10836) + Math.cos(10837) * 69;
+acc += Math.sin(10837) + Math.cos(10838) * 70;
+acc += Math.sin(10838) + Math.cos(10839) * 71;
+acc += Math.sin(10839) + Math.cos(10840) * 72;
+acc += Math.sin(10840) + Math.cos(10841) * 73;
+acc += Math.sin(10841) + Math.cos(10842) * 74;
+acc += Math.sin(10842) + Math.cos(10843) * 75;
+acc += Math.sin(10843) + Math.cos(10844) * 76;
+acc += Math.sin(10844) + Math.cos(10845) * 77;
+acc += Math.sin(10845) + Math.cos(10846) * 78;
+acc += Math.sin(10846) + Math.cos(10847) * 79;
+acc += Math.sin(10847) + Math.cos(10848) * 80;
+acc += Math.sin(10848) + Math.cos(10849) * 81;
+acc += Math.sin(10849) + Math.cos(10850) * 82;
+acc += Math.sin(10850) + Math.cos(10851) * 83;
+acc += Math.sin(10851) + Math.cos(10852) * 84;
+acc += Math.sin(10852) + Math.cos(10853) * 85;
+acc += Math.sin(10853) + Math.cos(10854) * 86;
+acc += Math.sin(10854) + Math.cos(10855) * 87;
+acc += Math.sin(10855) + Math.cos(10856) * 88;
+acc += Math.sin(10856) + Math.cos(10857) * 89;
+acc += Math.sin(10857) + Math.cos(10858) * 90;
+acc += Math.sin(10858) + Math.cos(10859) * 91;
+acc += Math.sin(10859) + Math.cos(10860) * 92;
+acc += Math.sin(10860) + Math.cos(10861) * 93;
+acc += Math.sin(10861) + Math.cos(10862) * 94;
+acc += Math.sin(10862) + Math.cos(10863) * 95;
+acc += Math.sin(10863) + Math.cos(10864) * 96;
+acc += Math.sin(10864) + Math.cos(10865) * 0;
+acc += Math.sin(10865) + Math.cos(10866) * 1;
+acc += Math.sin(10866) + Math.cos(10867) * 2;
+acc += Math.sin(10867) + Math.cos(10868) * 3;
+acc += Math.sin(10868) + Math.cos(10869) * 4;
+acc += Math.sin(10869) + Math.cos(10870) * 5;
+acc += Math.sin(10870) + Math.cos(10871) * 6;
+acc += Math.sin(10871) + Math.cos(10872) * 7;
+acc += Math.sin(10872) + Math.cos(10873) * 8;
+acc += Math.sin(10873) + Math.cos(10874) * 9;
+acc += Math.sin(10874) + Math.cos(10875) * 10;
+acc += Math.sin(10875) + Math.cos(10876) * 11;
+acc += Math.sin(10876) + Math.cos(10877) * 12;
+acc += Math.sin(10877) + Math.cos(10878) * 13;
+acc += Math.sin(10878) + Math.cos(10879) * 14;
+acc += Math.sin(10879) + Math.cos(10880) * 15;
+acc += Math.sin(10880) + Math.cos(10881) * 16;
+acc += Math.sin(10881) + Math.cos(10882) * 17;
+acc += Math.sin(10882) + Math.cos(10883) * 18;
+acc += Math.sin(10883) + Math.cos(10884) * 19;
+acc += Math.sin(10884) + Math.cos(10885) * 20;
+acc += Math.sin(10885) + Math.cos(10886) * 21;
+acc += Math.sin(10886) + Math.cos(10887) * 22;
+acc += Math.sin(10887) + Math.cos(10888) * 23;
+acc += Math.sin(10888) + Math.cos(10889) * 24;
+acc += Math.sin(10889) + Math.cos(10890) * 25;
+acc += Math.sin(10890) + Math.cos(10891) * 26;
+acc += Math.sin(10891) + Math.cos(10892) * 27;
+acc += Math.sin(10892) + Math.cos(10893) * 28;
+acc += Math.sin(10893) + Math.cos(10894) * 29;
+acc += Math.sin(10894) + Math.cos(10895) * 30;
+acc += Math.sin(10895) + Math.cos(10896) * 31;
+acc += Math.sin(10896) + Math.cos(10897) * 32;
+acc += Math.sin(10897) + Math.cos(10898) * 33;
+acc += Math.sin(10898) + Math.cos(10899) * 34;
+acc += Math.sin(10899) + Math.cos(10900) * 35;
+acc += Math.sin(10900) + Math.cos(10901) * 36;
+acc += Math.sin(10901) + Math.cos(10902) * 37;
+acc += Math.sin(10902) + Math.cos(10903) * 38;
+acc += Math.sin(10903) + Math.cos(10904) * 39;
+acc += Math.sin(10904) + Math.cos(10905) * 40;
+acc += Math.sin(10905) + Math.cos(10906) * 41;
+acc += Math.sin(10906) + Math.cos(10907) * 42;
+acc += Math.sin(10907) + Math.cos(10908) * 43;
+acc += Math.sin(10908) + Math.cos(10909) * 44;
+acc += Math.sin(10909) + Math.cos(10910) * 45;
+acc += Math.sin(10910) + Math.cos(10911) * 46;
+acc += Math.sin(10911) + Math.cos(10912) * 47;
+acc += Math.sin(10912) + Math.cos(10913) * 48;
+acc += Math.sin(10913) + Math.cos(10914) * 49;
+acc += Math.sin(10914) + Math.cos(10915) * 50;
+acc += Math.sin(10915) + Math.cos(10916) * 51;
+acc += Math.sin(10916) + Math.cos(10917) * 52;
+acc += Math.sin(10917) + Math.cos(10918) * 53;
+acc += Math.sin(10918) + Math.cos(10919) * 54;
+acc += Math.sin(10919) + Math.cos(10920) * 55;
+acc += Math.sin(10920) + Math.cos(10921) * 56;
+acc += Math.sin(10921) + Math.cos(10922) * 57;
+acc += Math.sin(10922) + Math.cos(10923) * 58;
+acc += Math.sin(10923) + Math.cos(10924) * 59;
+acc += Math.sin(10924) + Math.cos(10925) * 60;
+acc += Math.sin(10925) + Math.cos(10926) * 61;
+acc += Math.sin(10926) + Math.cos(10927) * 62;
+acc += Math.sin(10927) + Math.cos(10928) * 63;
+acc += Math.sin(10928) + Math.cos(10929) * 64;
+acc += Math.sin(10929) + Math.cos(10930) * 65;
+acc += Math.sin(10930) + Math.cos(10931) * 66;
+acc += Math.sin(10931) + Math.cos(10932) * 67;
+acc += Math.sin(10932) + Math.cos(10933) * 68;
+acc += Math.sin(10933) + Math.cos(10934) * 69;
+acc += Math.sin(10934) + Math.cos(10935) * 70;
+acc += Math.sin(10935) + Math.cos(10936) * 71;
+acc += Math.sin(10936) + Math.cos(10937) * 72;
+acc += Math.sin(10937) + Math.cos(10938) * 73;
+acc += Math.sin(10938) + Math.cos(10939) * 74;
+acc += Math.sin(10939) + Math.cos(10940) * 75;
+acc += Math.sin(10940) + Math.cos(10941) * 76;
+acc += Math.sin(10941) + Math.cos(10942) * 77;
+acc += Math.sin(10942) + Math.cos(10943) * 78;
+acc += Math.sin(10943) + Math.cos(10944) * 79;
+acc += Math.sin(10944) + Math.cos(10945) * 80;
+acc += Math.sin(10945) + Math.cos(10946) * 81;
+acc += Math.sin(10946) + Math.cos(10947) * 82;
+acc += Math.sin(10947) + Math.cos(10948) * 83;
+acc += Math.sin(10948) + Math.cos(10949) * 84;
+acc += Math.sin(10949) + Math.cos(10950) * 85;
+acc += Math.sin(10950) + Math.cos(10951) * 86;
+acc += Math.sin(10951) + Math.cos(10952) * 87;
+acc += Math.sin(10952) + Math.cos(10953) * 88;
+acc += Math.sin(10953) + Math.cos(10954) * 89;
+acc += Math.sin(10954) + Math.cos(10955) * 90;
+acc += Math.sin(10955) + Math.cos(10956) * 91;
+acc += Math.sin(10956) + Math.cos(10957) * 92;
+acc += Math.sin(10957) + Math.cos(10958) * 93;
+acc += Math.sin(10958) + Math.cos(10959) * 94;
+acc += Math.sin(10959) + Math.cos(10960) * 95;
+acc += Math.sin(10960) + Math.cos(10961) * 96;
+acc += Math.sin(10961) + Math.cos(10962) * 0;
+acc += Math.sin(10962) + Math.cos(10963) * 1;
+acc += Math.sin(10963) + Math.cos(10964) * 2;
+acc += Math.sin(10964) + Math.cos(10965) * 3;
+acc += Math.sin(10965) + Math.cos(10966) * 4;
+acc += Math.sin(10966) + Math.cos(10967) * 5;
+acc += Math.sin(10967) + Math.cos(10968) * 6;
+acc += Math.sin(10968) + Math.cos(10969) * 7;
+acc += Math.sin(10969) + Math.cos(10970) * 8;
+acc += Math.sin(10970) + Math.cos(10971) * 9;
+acc += Math.sin(10971) + Math.cos(10972) * 10;
+acc += Math.sin(10972) + Math.cos(10973) * 11;
+acc += Math.sin(10973) + Math.cos(10974) * 12;
+acc += Math.sin(10974) + Math.cos(10975) * 13;
+acc += Math.sin(10975) + Math.cos(10976) * 14;
+acc += Math.sin(10976) + Math.cos(10977) * 15;
+acc += Math.sin(10977) + Math.cos(10978) * 16;
+acc += Math.sin(10978) + Math.cos(10979) * 17;
+acc += Math.sin(10979) + Math.cos(10980) * 18;
+acc += Math.sin(10980) + Math.cos(10981) * 19;
+acc += Math.sin(10981) + Math.cos(10982) * 20;
+acc += Math.sin(10982) + Math.cos(10983) * 21;
+acc += Math.sin(10983) + Math.cos(10984) * 22;
+acc += Math.sin(10984) + Math.cos(10985) * 23;
+acc += Math.sin(10985) + Math.cos(10986) * 24;
+acc += Math.sin(10986) + Math.cos(10987) * 25;
+acc += Math.sin(10987) + Math.cos(10988) * 26;
+acc += Math.sin(10988) + Math.cos(10989) * 27;
+acc += Math.sin(10989) + Math.cos(10990) * 28;
+acc += Math.sin(10990) + Math.cos(10991) * 29;
+acc += Math.sin(10991) + Math.cos(10992) * 30;
+acc += Math.sin(10992) + Math.cos(10993) * 31;
+acc += Math.sin(10993) + Math.cos(10994) * 32;
+acc += Math.sin(10994) + Math.cos(10995) * 33;
+acc += Math.sin(10995) + Math.cos(10996) * 34;
+acc += Math.sin(10996) + Math.cos(10997) * 35;
+acc += Math.sin(10997) + Math.cos(10998) * 36;
+acc += Math.sin(10998) + Math.cos(10999) * 37;
+acc += Math.sin(10999) + Math.cos(11000) * 38;
+acc += Math.sin(11000) + Math.cos(11001) * 39;
+acc += Math.sin(11001) + Math.cos(11002) * 40;
+acc += Math.sin(11002) + Math.cos(11003) * 41;
+acc += Math.sin(11003) + Math.cos(11004) * 42;
+acc += Math.sin(11004) + Math.cos(11005) * 43;
+acc += Math.sin(11005) + Math.cos(11006) * 44;
+acc += Math.sin(11006) + Math.cos(11007) * 45;
+acc += Math.sin(11007) + Math.cos(11008) * 46;
+acc += Math.sin(11008) + Math.cos(11009) * 47;
+acc += Math.sin(11009) + Math.cos(11010) * 48;
+acc += Math.sin(11010) + Math.cos(11011) * 49;
+acc += Math.sin(11011) + Math.cos(11012) * 50;
+acc += Math.sin(11012) + Math.cos(11013) * 51;
+acc += Math.sin(11013) + Math.cos(11014) * 52;
+acc += Math.sin(11014) + Math.cos(11015) * 53;
+acc += Math.sin(11015) + Math.cos(11016) * 54;
+acc += Math.sin(11016) + Math.cos(11017) * 55;
+acc += Math.sin(11017) + Math.cos(11018) * 56;
+acc += Math.sin(11018) + Math.cos(11019) * 57;
+acc += Math.sin(11019) + Math.cos(11020) * 58;
+acc += Math.sin(11020) + Math.cos(11021) * 59;
+acc += Math.sin(11021) + Math.cos(11022) * 60;
+acc += Math.sin(11022) + Math.cos(11023) * 61;
+acc += Math.sin(11023) + Math.cos(11024) * 62;
+acc += Math.sin(11024) + Math.cos(11025) * 63;
+acc += Math.sin(11025) + Math.cos(11026) * 64;
+acc += Math.sin(11026) + Math.cos(11027) * 65;
+acc += Math.sin(11027) + Math.cos(11028) * 66;
+acc += Math.sin(11028) + Math.cos(11029) * 67;
+acc += Math.sin(11029) + Math.cos(11030) * 68;
+acc += Math.sin(11030) + Math.cos(11031) * 69;
+acc += Math.sin(11031) + Math.cos(11032) * 70;
+acc += Math.sin(11032) + Math.cos(11033) * 71;
+acc += Math.sin(11033) + Math.cos(11034) * 72;
+acc += Math.sin(11034) + Math.cos(11035) * 73;
+acc += Math.sin(11035) + Math.cos(11036) * 74;
+acc += Math.sin(11036) + Math.cos(11037) * 75;
+acc += Math.sin(11037) + Math.cos(11038) * 76;
+acc += Math.sin(11038) + Math.cos(11039) * 77;
+acc += Math.sin(11039) + Math.cos(11040) * 78;
+acc += Math.sin(11040) + Math.cos(11041) * 79;
+acc += Math.sin(11041) + Math.cos(11042) * 80;
+acc += Math.sin(11042) + Math.cos(11043) * 81;
+acc += Math.sin(11043) + Math.cos(11044) * 82;
+acc += Math.sin(11044) + Math.cos(11045) * 83;
+acc += Math.sin(11045) + Math.cos(11046) * 84;
+acc += Math.sin(11046) + Math.cos(11047) * 85;
+acc += Math.sin(11047) + Math.cos(11048) * 86;
+acc += Math.sin(11048) + Math.cos(11049) * 87;
+acc += Math.sin(11049) + Math.cos(11050) * 88;
+acc += Math.sin(11050) + Math.cos(11051) * 89;
+acc += Math.sin(11051) + Math.cos(11052) * 90;
+acc += Math.sin(11052) + Math.cos(11053) * 91;
+acc += Math.sin(11053) + Math.cos(11054) * 92;
+acc += Math.sin(11054) + Math.cos(11055) * 93;
+acc += Math.sin(11055) + Math.cos(11056) * 94;
+acc += Math.sin(11056) + Math.cos(11057) * 95;
+acc += Math.sin(11057) + Math.cos(11058) * 96;
+acc += Math.sin(11058) + Math.cos(11059) * 0;
+acc += Math.sin(11059) + Math.cos(11060) * 1;
+acc += Math.sin(11060) + Math.cos(11061) * 2;
+acc += Math.sin(11061) + Math.cos(11062) * 3;
+acc += Math.sin(11062) + Math.cos(11063) * 4;
+acc += Math.sin(11063) + Math.cos(11064) * 5;
+acc += Math.sin(11064) + Math.cos(11065) * 6;
+acc += Math.sin(11065) + Math.cos(11066) * 7;
+acc += Math.sin(11066) + Math.cos(11067) * 8;
+acc += Math.sin(11067) + Math.cos(11068) * 9;
+acc += Math.sin(11068) + Math.cos(11069) * 10;
+acc += Math.sin(11069) + Math.cos(11070) * 11;
+acc += Math.sin(11070) + Math.cos(11071) * 12;
+acc += Math.sin(11071) + Math.cos(11072) * 13;
+acc += Math.sin(11072) + Math.cos(11073) * 14;
+acc += Math.sin(11073) + Math.cos(11074) * 15;
+acc += Math.sin(11074) + Math.cos(11075) * 16;
+acc += Math.sin(11075) + Math.cos(11076) * 17;
+acc += Math.sin(11076) + Math.cos(11077) * 18;
+acc += Math.sin(11077) + Math.cos(11078) * 19;
+acc += Math.sin(11078) + Math.cos(11079) * 20;
+acc += Math.sin(11079) + Math.cos(11080) * 21;
+acc += Math.sin(11080) + Math.cos(11081) * 22;
+acc += Math.sin(11081) + Math.cos(11082) * 23;
+acc += Math.sin(11082) + Math.cos(11083) * 24;
+acc += Math.sin(11083) + Math.cos(11084) * 25;
+acc += Math.sin(11084) + Math.cos(11085) * 26;
+acc += Math.sin(11085) + Math.cos(11086) * 27;
+acc += Math.sin(11086) + Math.cos(11087) * 28;
+acc += Math.sin(11087) + Math.cos(11088) * 29;
+acc += Math.sin(11088) + Math.cos(11089) * 30;
+acc += Math.sin(11089) + Math.cos(11090) * 31;
+acc += Math.sin(11090) + Math.cos(11091) * 32;
+acc += Math.sin(11091) + Math.cos(11092) * 33;
+acc += Math.sin(11092) + Math.cos(11093) * 34;
+acc += Math.sin(11093) + Math.cos(11094) * 35;
+acc += Math.sin(11094) + Math.cos(11095) * 36;
+acc += Math.sin(11095) + Math.cos(11096) * 37;
+acc += Math.sin(11096) + Math.cos(11097) * 38;
+acc += Math.sin(11097) + Math.cos(11098) * 39;
+acc += Math.sin(11098) + Math.cos(11099) * 40;
+acc += Math.sin(11099) + Math.cos(11100) * 41;
+acc += Math.sin(11100) + Math.cos(11101) * 42;
+acc += Math.sin(11101) + Math.cos(11102) * 43;
+acc += Math.sin(11102) + Math.cos(11103) * 44;
+acc += Math.sin(11103) + Math.cos(11104) * 45;
+acc += Math.sin(11104) + Math.cos(11105) * 46;
+acc += Math.sin(11105) + Math.cos(11106) * 47;
+acc += Math.sin(11106) + Math.cos(11107) * 48;
+acc += Math.sin(11107) + Math.cos(11108) * 49;
+acc += Math.sin(11108) + Math.cos(11109) * 50;
+acc += Math.sin(11109) + Math.cos(11110) * 51;
+acc += Math.sin(11110) + Math.cos(11111) * 52;
+acc += Math.sin(11111) + Math.cos(11112) * 53;
+acc += Math.sin(11112) + Math.cos(11113) * 54;
+acc += Math.sin(11113) + Math.cos(11114) * 55;
+acc += Math.sin(11114) + Math.cos(11115) * 56;
+acc += Math.sin(11115) + Math.cos(11116) * 57;
+acc += Math.sin(11116) + Math.cos(11117) * 58;
+acc += Math.sin(11117) + Math.cos(11118) * 59;
+acc += Math.sin(11118) + Math.cos(11119) * 60;
+acc += Math.sin(11119) + Math.cos(11120) * 61;
+acc += Math.sin(11120) + Math.cos(11121) * 62;
+acc += Math.sin(11121) + Math.cos(11122) * 63;
+acc += Math.sin(11122) + Math.cos(11123) * 64;
+acc += Math.sin(11123) + Math.cos(11124) * 65;
+acc += Math.sin(11124) + Math.cos(11125) * 66;
+acc += Math.sin(11125) + Math.cos(11126) * 67;
+acc += Math.sin(11126) + Math.cos(11127) * 68;
+acc += Math.sin(11127) + Math.cos(11128) * 69;
+acc += Math.sin(11128) + Math.cos(11129) * 70;
+acc += Math.sin(11129) + Math.cos(11130) * 71;
+acc += Math.sin(11130) + Math.cos(11131) * 72;
+acc += Math.sin(11131) + Math.cos(11132) * 73;
+acc += Math.sin(11132) + Math.cos(11133) * 74;
+acc += Math.sin(11133) + Math.cos(11134) * 75;
+acc += Math.sin(11134) + Math.cos(11135) * 76;
+acc += Math.sin(11135) + Math.cos(11136) * 77;
+acc += Math.sin(11136) + Math.cos(11137) * 78;
+acc += Math.sin(11137) + Math.cos(11138) * 79;
+acc += Math.sin(11138) + Math.cos(11139) * 80;
+acc += Math.sin(11139) + Math.cos(11140) * 81;
+acc += Math.sin(11140) + Math.cos(11141) * 82;
+acc += Math.sin(11141) + Math.cos(11142) * 83;
+acc += Math.sin(11142) + Math.cos(11143) * 84;
+acc += Math.sin(11143) + Math.cos(11144) * 85;
+acc += Math.sin(11144) + Math.cos(11145) * 86;
+acc += Math.sin(11145) + Math.cos(11146) * 87;
+acc += Math.sin(11146) + Math.cos(11147) * 88;
+acc += Math.sin(11147) + Math.cos(11148) * 89;
+acc += Math.sin(11148) + Math.cos(11149) * 90;
+acc += Math.sin(11149) + Math.cos(11150) * 91;
+acc += Math.sin(11150) + Math.cos(11151) * 92;
+acc += Math.sin(11151) + Math.cos(11152) * 93;
+acc += Math.sin(11152) + Math.cos(11153) * 94;
+acc += Math.sin(11153) + Math.cos(11154) * 95;
+acc += Math.sin(11154) + Math.cos(11155) * 96;
+acc += Math.sin(11155) + Math.cos(11156) * 0;
+acc += Math.sin(11156) + Math.cos(11157) * 1;
+acc += Math.sin(11157) + Math.cos(11158) * 2;
+acc += Math.sin(11158) + Math.cos(11159) * 3;
+acc += Math.sin(11159) + Math.cos(11160) * 4;
+acc += Math.sin(11160) + Math.cos(11161) * 5;
+acc += Math.sin(11161) + Math.cos(11162) * 6;
+acc += Math.sin(11162) + Math.cos(11163) * 7;
+acc += Math.sin(11163) + Math.cos(11164) * 8;
+acc += Math.sin(11164) + Math.cos(11165) * 9;
+acc += Math.sin(11165) + Math.cos(11166) * 10;
+acc += Math.sin(11166) + Math.cos(11167) * 11;
+acc += Math.sin(11167) + Math.cos(11168) * 12;
+acc += Math.sin(11168) + Math.cos(11169) * 13;
+acc += Math.sin(11169) + Math.cos(11170) * 14;
+acc += Math.sin(11170) + Math.cos(11171) * 15;
+acc += Math.sin(11171) + Math.cos(11172) * 16;
+acc += Math.sin(11172) + Math.cos(11173) * 17;
+acc += Math.sin(11173) + Math.cos(11174) * 18;
+acc += Math.sin(11174) + Math.cos(11175) * 19;
+acc += Math.sin(11175) + Math.cos(11176) * 20;
+acc += Math.sin(11176) + Math.cos(11177) * 21;
+acc += Math.sin(11177) + Math.cos(11178) * 22;
+acc += Math.sin(11178) + Math.cos(11179) * 23;
+acc += Math.sin(11179) + Math.cos(11180) * 24;
+acc += Math.sin(11180) + Math.cos(11181) * 25;
+acc += Math.sin(11181) + Math.cos(11182) * 26;
+acc += Math.sin(11182) + Math.cos(11183) * 27;
+acc += Math.sin(11183) + Math.cos(11184) * 28;
+acc += Math.sin(11184) + Math.cos(11185) * 29;
+acc += Math.sin(11185) + Math.cos(11186) * 30;
+acc += Math.sin(11186) + Math.cos(11187) * 31;
+acc += Math.sin(11187) + Math.cos(11188) * 32;
+acc += Math.sin(11188) + Math.cos(11189) * 33;
+acc += Math.sin(11189) + Math.cos(11190) * 34;
+acc += Math.sin(11190) + Math.cos(11191) * 35;
+acc += Math.sin(11191) + Math.cos(11192) * 36;
+acc += Math.sin(11192) + Math.cos(11193) * 37;
+acc += Math.sin(11193) + Math.cos(11194) * 38;
+acc += Math.sin(11194) + Math.cos(11195) * 39;
+acc += Math.sin(11195) + Math.cos(11196) * 40;
+acc += Math.sin(11196) + Math.cos(11197) * 41;
+acc += Math.sin(11197) + Math.cos(11198) * 42;
+acc += Math.sin(11198) + Math.cos(11199) * 43;
+acc += Math.sin(11199) + Math.cos(11200) * 44;
+acc += Math.sin(11200) + Math.cos(11201) * 45;
+acc += Math.sin(11201) + Math.cos(11202) * 46;
+acc += Math.sin(11202) + Math.cos(11203) * 47;
+acc += Math.sin(11203) + Math.cos(11204) * 48;
+acc += Math.sin(11204) + Math.cos(11205) * 49;
+acc += Math.sin(11205) + Math.cos(11206) * 50;
+acc += Math.sin(11206) + Math.cos(11207) * 51;
+acc += Math.sin(11207) + Math.cos(11208) * 52;
+acc += Math.sin(11208) + Math.cos(11209) * 53;
+acc += Math.sin(11209) + Math.cos(11210) * 54;
+acc += Math.sin(11210) + Math.cos(11211) * 55;
+acc += Math.sin(11211) + Math.cos(11212) * 56;
+acc += Math.sin(11212) + Math.cos(11213) * 57;
+acc += Math.sin(11213) + Math.cos(11214) * 58;
+acc += Math.sin(11214) + Math.cos(11215) * 59;
+acc += Math.sin(11215) + Math.cos(11216) * 60;
+acc += Math.sin(11216) + Math.cos(11217) * 61;
+acc += Math.sin(11217) + Math.cos(11218) * 62;
+acc += Math.sin(11218) + Math.cos(11219) * 63;
+acc += Math.sin(11219) + Math.cos(11220) * 64;
+acc += Math.sin(11220) + Math.cos(11221) * 65;
+acc += Math.sin(11221) + Math.cos(11222) * 66;
+acc += Math.sin(11222) + Math.cos(11223) * 67;
+acc += Math.sin(11223) + Math.cos(11224) * 68;
+acc += Math.sin(11224) + Math.cos(11225) * 69;
+acc += Math.sin(11225) + Math.cos(11226) * 70;
+acc += Math.sin(11226) + Math.cos(11227) * 71;
+acc += Math.sin(11227) + Math.cos(11228) * 72;
+acc += Math.sin(11228) + Math.cos(11229) * 73;
+acc += Math.sin(11229) + Math.cos(11230) * 74;
+acc += Math.sin(11230) + Math.cos(11231) * 75;
+acc += Math.sin(11231) + Math.cos(11232) * 76;
+acc += Math.sin(11232) + Math.cos(11233) * 77;
+acc += Math.sin(11233) + Math.cos(11234) * 78;
+acc += Math.sin(11234) + Math.cos(11235) * 79;
+acc += Math.sin(11235) + Math.cos(11236) * 80;
+acc += Math.sin(11236) + Math.cos(11237) * 81;
+acc += Math.sin(11237) + Math.cos(11238) * 82;
+acc += Math.sin(11238) + Math.cos(11239) * 83;
+acc += Math.sin(11239) + Math.cos(11240) * 84;
+acc += Math.sin(11240) + Math.cos(11241) * 85;
+acc += Math.sin(11241) + Math.cos(11242) * 86;
+acc += Math.sin(11242) + Math.cos(11243) * 87;
+acc += Math.sin(11243) + Math.cos(11244) * 88;
+acc += Math.sin(11244) + Math.cos(11245) * 89;
+acc += Math.sin(11245) + Math.cos(11246) * 90;
+acc += Math.sin(11246) + Math.cos(11247) * 91;
+acc += Math.sin(11247) + Math.cos(11248) * 92;
+acc += Math.sin(11248) + Math.cos(11249) * 93;
+acc += Math.sin(11249) + Math.cos(11250) * 94;
+acc += Math.sin(11250) + Math.cos(11251) * 95;
+acc += Math.sin(11251) + Math.cos(11252) * 96;
+acc += Math.sin(11252) + Math.cos(11253) * 0;
+acc += Math.sin(11253) + Math.cos(11254) * 1;
+acc += Math.sin(11254) + Math.cos(11255) * 2;
+acc += Math.sin(11255) + Math.cos(11256) * 3;
+acc += Math.sin(11256) + Math.cos(11257) * 4;
+acc += Math.sin(11257) + Math.cos(11258) * 5;
+acc += Math.sin(11258) + Math.cos(11259) * 6;
+acc += Math.sin(11259) + Math.cos(11260) * 7;
+acc += Math.sin(11260) + Math.cos(11261) * 8;
+acc += Math.sin(11261) + Math.cos(11262) * 9;
+acc += Math.sin(11262) + Math.cos(11263) * 10;
+acc += Math.sin(11263) + Math.cos(11264) * 11;
+acc += Math.sin(11264) + Math.cos(11265) * 12;
+acc += Math.sin(11265) + Math.cos(11266) * 13;
+acc += Math.sin(11266) + Math.cos(11267) * 14;
+acc += Math.sin(11267) + Math.cos(11268) * 15;
+acc += Math.sin(11268) + Math.cos(11269) * 16;
+acc += Math.sin(11269) + Math.cos(11270) * 17;
+acc += Math.sin(11270) + Math.cos(11271) * 18;
+acc += Math.sin(11271) + Math.cos(11272) * 19;
+acc += Math.sin(11272) + Math.cos(11273) * 20;
+acc += Math.sin(11273) + Math.cos(11274) * 21;
+acc += Math.sin(11274) + Math.cos(11275) * 22;
+acc += Math.sin(11275) + Math.cos(11276) * 23;
+acc += Math.sin(11276) + Math.cos(11277) * 24;
+acc += Math.sin(11277) + Math.cos(11278) * 25;
+acc += Math.sin(11278) + Math.cos(11279) * 26;
+acc += Math.sin(11279) + Math.cos(11280) * 27;
+acc += Math.sin(11280) + Math.cos(11281) * 28;
+acc += Math.sin(11281) + Math.cos(11282) * 29;
+acc += Math.sin(11282) + Math.cos(11283) * 30;
+acc += Math.sin(11283) + Math.cos(11284) * 31;
+acc += Math.sin(11284) + Math.cos(11285) * 32;
+acc += Math.sin(11285) + Math.cos(11286) * 33;
+acc += Math.sin(11286) + Math.cos(11287) * 34;
+acc += Math.sin(11287) + Math.cos(11288) * 35;
+acc += Math.sin(11288) + Math.cos(11289) * 36;
+acc += Math.sin(11289) + Math.cos(11290) * 37;
+acc += Math.sin(11290) + Math.cos(11291) * 38;
+acc += Math.sin(11291) + Math.cos(11292) * 39;
+acc += Math.sin(11292) + Math.cos(11293) * 40;
+acc += Math.sin(11293) + Math.cos(11294) * 41;
+acc += Math.sin(11294) + Math.cos(11295) * 42;
+acc += Math.sin(11295) + Math.cos(11296) * 43;
+acc += Math.sin(11296) + Math.cos(11297) * 44;
+acc += Math.sin(11297) + Math.cos(11298) * 45;
+acc += Math.sin(11298) + Math.cos(11299) * 46;
+acc += Math.sin(11299) + Math.cos(11300) * 47;
+acc += Math.sin(11300) + Math.cos(11301) * 48;
+acc += Math.sin(11301) + Math.cos(11302) * 49;
+acc += Math.sin(11302) + Math.cos(11303) * 50;
+acc += Math.sin(11303) + Math.cos(11304) * 51;
+acc += Math.sin(11304) + Math.cos(11305) * 52;
+acc += Math.sin(11305) + Math.cos(11306) * 53;
+acc += Math.sin(11306) + Math.cos(11307) * 54;
+acc += Math.sin(11307) + Math.cos(11308) * 55;
+acc += Math.sin(11308) + Math.cos(11309) * 56;
+acc += Math.sin(11309) + Math.cos(11310) * 57;
+acc += Math.sin(11310) + Math.cos(11311) * 58;
+acc += Math.sin(11311) + Math.cos(11312) * 59;
+acc += Math.sin(11312) + Math.cos(11313) * 60;
+acc += Math.sin(11313) + Math.cos(11314) * 61;
+acc += Math.sin(11314) + Math.cos(11315) * 62;
+acc += Math.sin(11315) + Math.cos(11316) * 63;
+acc += Math.sin(11316) + Math.cos(11317) * 64;
+acc += Math.sin(11317) + Math.cos(11318) * 65;
+acc += Math.sin(11318) + Math.cos(11319) * 66;
+acc += Math.sin(11319) + Math.cos(11320) * 67;
+acc += Math.sin(11320) + Math.cos(11321) * 68;
+acc += Math.sin(11321) + Math.cos(11322) * 69;
+acc += Math.sin(11322) + Math.cos(11323) * 70;
+acc += Math.sin(11323) + Math.cos(11324) * 71;
+acc += Math.sin(11324) + Math.cos(11325) * 72;
+acc += Math.sin(11325) + Math.cos(11326) * 73;
+acc += Math.sin(11326) + Math.cos(11327) * 74;
+acc += Math.sin(11327) + Math.cos(11328) * 75;
+acc += Math.sin(11328) + Math.cos(11329) * 76;
+acc += Math.sin(11329) + Math.cos(11330) * 77;
+acc += Math.sin(11330) + Math.cos(11331) * 78;
+acc += Math.sin(11331) + Math.cos(11332) * 79;
+acc += Math.sin(11332) + Math.cos(11333) * 80;
+acc += Math.sin(11333) + Math.cos(11334) * 81;
+acc += Math.sin(11334) + Math.cos(11335) * 82;
+acc += Math.sin(11335) + Math.cos(11336) * 83;
+acc += Math.sin(11336) + Math.cos(11337) * 84;
+acc += Math.sin(11337) + Math.cos(11338) * 85;
+acc += Math.sin(11338) + Math.cos(11339) * 86;
+acc += Math.sin(11339) + Math.cos(11340) * 87;
+acc += Math.sin(11340) + Math.cos(11341) * 88;
+acc += Math.sin(11341) + Math.cos(11342) * 89;
+acc += Math.sin(11342) + Math.cos(11343) * 90;
+acc += Math.sin(11343) + Math.cos(11344) * 91;
+acc += Math.sin(11344) + Math.cos(11345) * 92;
+acc += Math.sin(11345) + Math.cos(11346) * 93;
+acc += Math.sin(11346) + Math.cos(11347) * 94;
+acc += Math.sin(11347) + Math.cos(11348) * 95;
+acc += Math.sin(11348) + Math.cos(11349) * 96;
+acc += Math.sin(11349) + Math.cos(11350) * 0;
+acc += Math.sin(11350) + Math.cos(11351) * 1;
+acc += Math.sin(11351) + Math.cos(11352) * 2;
+acc += Math.sin(11352) + Math.cos(11353) * 3;
+acc += Math.sin(11353) + Math.cos(11354) * 4;
+acc += Math.sin(11354) + Math.cos(11355) * 5;
+acc += Math.sin(11355) + Math.cos(11356) * 6;
+acc += Math.sin(11356) + Math.cos(11357) * 7;
+acc += Math.sin(11357) + Math.cos(11358) * 8;
+acc += Math.sin(11358) + Math.cos(11359) * 9;
+acc += Math.sin(11359) + Math.cos(11360) * 10;
+acc += Math.sin(11360) + Math.cos(11361) * 11;
+acc += Math.sin(11361) + Math.cos(11362) * 12;
+acc += Math.sin(11362) + Math.cos(11363) * 13;
+acc += Math.sin(11363) + Math.cos(11364) * 14;
+acc += Math.sin(11364) + Math.cos(11365) * 15;
+acc += Math.sin(11365) + Math.cos(11366) * 16;
+acc += Math.sin(11366) + Math.cos(11367) * 17;
+acc += Math.sin(11367) + Math.cos(11368) * 18;
+acc += Math.sin(11368) + Math.cos(11369) * 19;
+acc += Math.sin(11369) + Math.cos(11370) * 20;
+acc += Math.sin(11370) + Math.cos(11371) * 21;
+acc += Math.sin(11371) + Math.cos(11372) * 22;
+acc += Math.sin(11372) + Math.cos(11373) * 23;
+acc += Math.sin(11373) + Math.cos(11374) * 24;
+acc += Math.sin(11374) + Math.cos(11375) * 25;
+acc += Math.sin(11375) + Math.cos(11376) * 26;
+acc += Math.sin(11376) + Math.cos(11377) * 27;
+acc += Math.sin(11377) + Math.cos(11378) * 28;
+acc += Math.sin(11378) + Math.cos(11379) * 29;
+acc += Math.sin(11379) + Math.cos(11380) * 30;
+acc += Math.sin(11380) + Math.cos(11381) * 31;
+acc += Math.sin(11381) + Math.cos(11382) * 32;
+acc += Math.sin(11382) + Math.cos(11383) * 33;
+acc += Math.sin(11383) + Math.cos(11384) * 34;
+acc += Math.sin(11384) + Math.cos(11385) * 35;
+acc += Math.sin(11385) + Math.cos(11386) * 36;
+acc += Math.sin(11386) + Math.cos(11387) * 37;
+acc += Math.sin(11387) + Math.cos(11388) * 38;
+acc += Math.sin(11388) + Math.cos(11389) * 39;
+acc += Math.sin(11389) + Math.cos(11390) * 40;
+acc += Math.sin(11390) + Math.cos(11391) * 41;
+acc += Math.sin(11391) + Math.cos(11392) * 42;
+acc += Math.sin(11392) + Math.cos(11393) * 43;
+acc += Math.sin(11393) + Math.cos(11394) * 44;
+acc += Math.sin(11394) + Math.cos(11395) * 45;
+acc += Math.sin(11395) + Math.cos(11396) * 46;
+acc += Math.sin(11396) + Math.cos(11397) * 47;
+acc += Math.sin(11397) + Math.cos(11398) * 48;
+acc += Math.sin(11398) + Math.cos(11399) * 49;
+acc += Math.sin(11399) + Math.cos(11400) * 50;
+acc += Math.sin(11400) + Math.cos(11401) * 51;
+acc += Math.sin(11401) + Math.cos(11402) * 52;
+acc += Math.sin(11402) + Math.cos(11403) * 53;
+acc += Math.sin(11403) + Math.cos(11404) * 54;
+acc += Math.sin(11404) + Math.cos(11405) * 55;
+acc += Math.sin(11405) + Math.cos(11406) * 56;
+acc += Math.sin(11406) + Math.cos(11407) * 57;
+acc += Math.sin(11407) + Math.cos(11408) * 58;
+acc += Math.sin(11408) + Math.cos(11409) * 59;
+acc += Math.sin(11409) + Math.cos(11410) * 60;
+acc += Math.sin(11410) + Math.cos(11411) * 61;
+acc += Math.sin(11411) + Math.cos(11412) * 62;
+acc += Math.sin(11412) + Math.cos(11413) * 63;
+acc += Math.sin(11413) + Math.cos(11414) * 64;
+acc += Math.sin(11414) + Math.cos(11415) * 65;
+acc += Math.sin(11415) + Math.cos(11416) * 66;
+acc += Math.sin(11416) + Math.cos(11417) * 67;
+acc += Math.sin(11417) + Math.cos(11418) * 68;
+acc += Math.sin(11418) + Math.cos(11419) * 69;
+acc += Math.sin(11419) + Math.cos(11420) * 70;
+acc += Math.sin(11420) + Math.cos(11421) * 71;
+acc += Math.sin(11421) + Math.cos(11422) * 72;
+acc += Math.sin(11422) + Math.cos(11423) * 73;
+acc += Math.sin(11423) + Math.cos(11424) * 74;
+acc += Math.sin(11424) + Math.cos(11425) * 75;
+acc += Math.sin(11425) + Math.cos(11426) * 76;
+acc += Math.sin(11426) + Math.cos(11427) * 77;
+acc += Math.sin(11427) + Math.cos(11428) * 78;
+acc += Math.sin(11428) + Math.cos(11429) * 79;
+acc += Math.sin(11429) + Math.cos(11430) * 80;
+acc += Math.sin(11430) + Math.cos(11431) * 81;
+acc += Math.sin(11431) + Math.cos(11432) * 82;
+acc += Math.sin(11432) + Math.cos(11433) * 83;
+acc += Math.sin(11433) + Math.cos(11434) * 84;
+acc += Math.sin(11434) + Math.cos(11435) * 85;
+acc += Math.sin(11435) + Math.cos(11436) * 86;
+acc += Math.sin(11436) + Math.cos(11437) * 87;
+acc += Math.sin(11437) + Math.cos(11438) * 88;
+acc += Math.sin(11438) + Math.cos(11439) * 89;
+acc += Math.sin(11439) + Math.cos(11440) * 90;
+acc += Math.sin(11440) + Math.cos(11441) * 91;
+acc += Math.sin(11441) + Math.cos(11442) * 92;
+acc += Math.sin(11442) + Math.cos(11443) * 93;
+acc += Math.sin(11443) + Math.cos(11444) * 94;
+acc += Math.sin(11444) + Math.cos(11445) * 95;
+acc += Math.sin(11445) + Math.cos(11446) * 96;
+acc += Math.sin(11446) + Math.cos(11447) * 0;
+acc += Math.sin(11447) + Math.cos(11448) * 1;
+acc += Math.sin(11448) + Math.cos(11449) * 2;
+acc += Math.sin(11449) + Math.cos(11450) * 3;
+acc += Math.sin(11450) + Math.cos(11451) * 4;
+acc += Math.sin(11451) + Math.cos(11452) * 5;
+acc += Math.sin(11452) + Math.cos(11453) * 6;
+acc += Math.sin(11453) + Math.cos(11454) * 7;
+acc += Math.sin(11454) + Math.cos(11455) * 8;
+acc += Math.sin(11455) + Math.cos(11456) * 9;
+acc += Math.sin(11456) + Math.cos(11457) * 10;
+acc += Math.sin(11457) + Math.cos(11458) * 11;
+acc += Math.sin(11458) + Math.cos(11459) * 12;
+acc += Math.sin(11459) + Math.cos(11460) * 13;
+acc += Math.sin(11460) + Math.cos(11461) * 14;
+acc += Math.sin(11461) + Math.cos(11462) * 15;
+acc += Math.sin(11462) + Math.cos(11463) * 16;
+acc += Math.sin(11463) + Math.cos(11464) * 17;
+acc += Math.sin(11464) + Math.cos(11465) * 18;
+acc += Math.sin(11465) + Math.cos(11466) * 19;
+acc += Math.sin(11466) + Math.cos(11467) * 20;
+acc += Math.sin(11467) + Math.cos(11468) * 21;
+acc += Math.sin(11468) + Math.cos(11469) * 22;
+acc += Math.sin(11469) + Math.cos(11470) * 23;
+acc += Math.sin(11470) + Math.cos(11471) * 24;
+acc += Math.sin(11471) + Math.cos(11472) * 25;
+acc += Math.sin(11472) + Math.cos(11473) * 26;
+acc += Math.sin(11473) + Math.cos(11474) * 27;
+acc += Math.sin(11474) + Math.cos(11475) * 28;
+acc += Math.sin(11475) + Math.cos(11476) * 29;
+acc += Math.sin(11476) + Math.cos(11477) * 30;
+acc += Math.sin(11477) + Math.cos(11478) * 31;
+acc += Math.sin(11478) + Math.cos(11479) * 32;
+acc += Math.sin(11479) + Math.cos(11480) * 33;
+acc += Math.sin(11480) + Math.cos(11481) * 34;
+acc += Math.sin(11481) + Math.cos(11482) * 35;
+acc += Math.sin(11482) + Math.cos(11483) * 36;
+acc += Math.sin(11483) + Math.cos(11484) * 37;
+acc += Math.sin(11484) + Math.cos(11485) * 38;
+acc += Math.sin(11485) + Math.cos(11486) * 39;
+acc += Math.sin(11486) + Math.cos(11487) * 40;
+acc += Math.sin(11487) + Math.cos(11488) * 41;
+acc += Math.sin(11488) + Math.cos(11489) * 42;
+acc += Math.sin(11489) + Math.cos(11490) * 43;
+acc += Math.sin(11490) + Math.cos(11491) * 44;
+acc += Math.sin(11491) + Math.cos(11492) * 45;
+acc += Math.sin(11492) + Math.cos(11493) * 46;
+acc += Math.sin(11493) + Math.cos(11494) * 47;
+acc += Math.sin(11494) + Math.cos(11495) * 48;
+acc += Math.sin(11495) + Math.cos(11496) * 49;
+acc += Math.sin(11496) + Math.cos(11497) * 50;
+acc += Math.sin(11497) + Math.cos(11498) * 51;
+acc += Math.sin(11498) + Math.cos(11499) * 52;
+acc += Math.sin(11499) + Math.cos(11500) * 53;
+acc += Math.sin(11500) + Math.cos(11501) * 54;
+acc += Math.sin(11501) + Math.cos(11502) * 55;
+acc += Math.sin(11502) + Math.cos(11503) * 56;
+acc += Math.sin(11503) + Math.cos(11504) * 57;
+acc += Math.sin(11504) + Math.cos(11505) * 58;
+acc += Math.sin(11505) + Math.cos(11506) * 59;
+acc += Math.sin(11506) + Math.cos(11507) * 60;
+acc += Math.sin(11507) + Math.cos(11508) * 61;
+acc += Math.sin(11508) + Math.cos(11509) * 62;
+acc += Math.sin(11509) + Math.cos(11510) * 63;
+acc += Math.sin(11510) + Math.cos(11511) * 64;
+acc += Math.sin(11511) + Math.cos(11512) * 65;
+acc += Math.sin(11512) + Math.cos(11513) * 66;
+acc += Math.sin(11513) + Math.cos(11514) * 67;
+acc += Math.sin(11514) + Math.cos(11515) * 68;
+acc += Math.sin(11515) + Math.cos(11516) * 69;
+acc += Math.sin(11516) + Math.cos(11517) * 70;
+acc += Math.sin(11517) + Math.cos(11518) * 71;
+acc += Math.sin(11518) + Math.cos(11519) * 72;
+acc += Math.sin(11519) + Math.cos(11520) * 73;
+acc += Math.sin(11520) + Math.cos(11521) * 74;
+acc += Math.sin(11521) + Math.cos(11522) * 75;
+acc += Math.sin(11522) + Math.cos(11523) * 76;
+acc += Math.sin(11523) + Math.cos(11524) * 77;
+acc += Math.sin(11524) + Math.cos(11525) * 78;
+acc += Math.sin(11525) + Math.cos(11526) * 79;
+acc += Math.sin(11526) + Math.cos(11527) * 80;
+acc += Math.sin(11527) + Math.cos(11528) * 81;
+acc += Math.sin(11528) + Math.cos(11529) * 82;
+acc += Math.sin(11529) + Math.cos(11530) * 83;
+acc += Math.sin(11530) + Math.cos(11531) * 84;
+acc += Math.sin(11531) + Math.cos(11532) * 85;
+acc += Math.sin(11532) + Math.cos(11533) * 86;
+acc += Math.sin(11533) + Math.cos(11534) * 87;
+acc += Math.sin(11534) + Math.cos(11535) * 88;
+acc += Math.sin(11535) + Math.cos(11536) * 89;
+acc += Math.sin(11536) + Math.cos(11537) * 90;
+acc += Math.sin(11537) + Math.cos(11538) * 91;
+acc += Math.sin(11538) + Math.cos(11539) * 92;
+acc += Math.sin(11539) + Math.cos(11540) * 93;
+acc += Math.sin(11540) + Math.cos(11541) * 94;
+acc += Math.sin(11541) + Math.cos(11542) * 95;
+acc += Math.sin(11542) + Math.cos(11543) * 96;
+acc += Math.sin(11543) + Math.cos(11544) * 0;
+acc += Math.sin(11544) + Math.cos(11545) * 1;
+acc += Math.sin(11545) + Math.cos(11546) * 2;
+acc += Math.sin(11546) + Math.cos(11547) * 3;
+acc += Math.sin(11547) + Math.cos(11548) * 4;
+acc += Math.sin(11548) + Math.cos(11549) * 5;
+acc += Math.sin(11549) + Math.cos(11550) * 6;
+acc += Math.sin(11550) + Math.cos(11551) * 7;
+acc += Math.sin(11551) + Math.cos(11552) * 8;
+acc += Math.sin(11552) + Math.cos(11553) * 9;
+acc += Math.sin(11553) + Math.cos(11554) * 10;
+acc += Math.sin(11554) + Math.cos(11555) * 11;
+acc += Math.sin(11555) + Math.cos(11556) * 12;
+acc += Math.sin(11556) + Math.cos(11557) * 13;
+acc += Math.sin(11557) + Math.cos(11558) * 14;
+acc += Math.sin(11558) + Math.cos(11559) * 15;
+acc += Math.sin(11559) + Math.cos(11560) * 16;
+acc += Math.sin(11560) + Math.cos(11561) * 17;
+acc += Math.sin(11561) + Math.cos(11562) * 18;
+acc += Math.sin(11562) + Math.cos(11563) * 19;
+acc += Math.sin(11563) + Math.cos(11564) * 20;
+acc += Math.sin(11564) + Math.cos(11565) * 21;
+acc += Math.sin(11565) + Math.cos(11566) * 22;
+acc += Math.sin(11566) + Math.cos(11567) * 23;
+acc += Math.sin(11567) + Math.cos(11568) * 24;
+acc += Math.sin(11568) + Math.cos(11569) * 25;
+acc += Math.sin(11569) + Math.cos(11570) * 26;
+acc += Math.sin(11570) + Math.cos(11571) * 27;
+acc += Math.sin(11571) + Math.cos(11572) * 28;
+acc += Math.sin(11572) + Math.cos(11573) * 29;
+acc += Math.sin(11573) + Math.cos(11574) * 30;
+acc += Math.sin(11574) + Math.cos(11575) * 31;
+acc += Math.sin(11575) + Math.cos(11576) * 32;
+acc += Math.sin(11576) + Math.cos(11577) * 33;
+acc += Math.sin(11577) + Math.cos(11578) * 34;
+acc += Math.sin(11578) + Math.cos(11579) * 35;
+acc += Math.sin(11579) + Math.cos(11580) * 36;
+acc += Math.sin(11580) + Math.cos(11581) * 37;
+acc += Math.sin(11581) + Math.cos(11582) * 38;
+acc += Math.sin(11582) + Math.cos(11583) * 39;
+acc += Math.sin(11583) + Math.cos(11584) * 40;
+acc += Math.sin(11584) + Math.cos(11585) * 41;
+acc += Math.sin(11585) + Math.cos(11586) * 42;
+acc += Math.sin(11586) + Math.cos(11587) * 43;
+acc += Math.sin(11587) + Math.cos(11588) * 44;
+acc += Math.sin(11588) + Math.cos(11589) * 45;
+acc += Math.sin(11589) + Math.cos(11590) * 46;
+acc += Math.sin(11590) + Math.cos(11591) * 47;
+acc += Math.sin(11591) + Math.cos(11592) * 48;
+acc += Math.sin(11592) + Math.cos(11593) * 49;
+acc += Math.sin(11593) + Math.cos(11594) * 50;
+acc += Math.sin(11594) + Math.cos(11595) * 51;
+acc += Math.sin(11595) + Math.cos(11596) * 52;
+acc += Math.sin(11596) + Math.cos(11597) * 53;
+acc += Math.sin(11597) + Math.cos(11598) * 54;
+acc += Math.sin(11598) + Math.cos(11599) * 55;
+acc += Math.sin(11599) + Math.cos(11600) * 56;
+acc += Math.sin(11600) + Math.cos(11601) * 57;
+acc += Math.sin(11601) + Math.cos(11602) * 58;
+acc += Math.sin(11602) + Math.cos(11603) * 59;
+acc += Math.sin(11603) + Math.cos(11604) * 60;
+acc += Math.sin(11604) + Math.cos(11605) * 61;
+acc += Math.sin(11605) + Math.cos(11606) * 62;
+acc += Math.sin(11606) + Math.cos(11607) * 63;
+acc += Math.sin(11607) + Math.cos(11608) * 64;
+acc += Math.sin(11608) + Math.cos(11609) * 65;
+acc += Math.sin(11609) + Math.cos(11610) * 66;
+acc += Math.sin(11610) + Math.cos(11611) * 67;
+acc += Math.sin(11611) + Math.cos(11612) * 68;
+acc += Math.sin(11612) + Math.cos(11613) * 69;
+acc += Math.sin(11613) + Math.cos(11614) * 70;
+acc += Math.sin(11614) + Math.cos(11615) * 71;
+acc += Math.sin(11615) + Math.cos(11616) * 72;
+acc += Math.sin(11616) + Math.cos(11617) * 73;
+acc += Math.sin(11617) + Math.cos(11618) * 74;
+acc += Math.sin(11618) + Math.cos(11619) * 75;
+acc += Math.sin(11619) + Math.cos(11620) * 76;
+acc += Math.sin(11620) + Math.cos(11621) * 77;
+acc += Math.sin(11621) + Math.cos(11622) * 78;
+acc += Math.sin(11622) + Math.cos(11623) * 79;
+acc += Math.sin(11623) + Math.cos(11624) * 80;
+acc += Math.sin(11624) + Math.cos(11625) * 81;
+acc += Math.sin(11625) + Math.cos(11626) * 82;
+acc += Math.sin(11626) + Math.cos(11627) * 83;
+acc += Math.sin(11627) + Math.cos(11628) * 84;
+acc += Math.sin(11628) + Math.cos(11629) * 85;
+acc += Math.sin(11629) + Math.cos(11630) * 86;
+acc += Math.sin(11630) + Math.cos(11631) * 87;
+acc += Math.sin(11631) + Math.cos(11632) * 88;
+acc += Math.sin(11632) + Math.cos(11633) * 89;
+acc += Math.sin(11633) + Math.cos(11634) * 90;
+acc += Math.sin(11634) + Math.cos(11635) * 91;
+acc += Math.sin(11635) + Math.cos(11636) * 92;
+acc += Math.sin(11636) + Math.cos(11637) * 93;
+acc += Math.sin(11637) + Math.cos(11638) * 94;
+acc += Math.sin(11638) + Math.cos(11639) * 95;
+acc += Math.sin(11639) + Math.cos(11640) * 96;
+acc += Math.sin(11640) + Math.cos(11641) * 0;
+acc += Math.sin(11641) + Math.cos(11642) * 1;
+acc += Math.sin(11642) + Math.cos(11643) * 2;
+acc += Math.sin(11643) + Math.cos(11644) * 3;
+acc += Math.sin(11644) + Math.cos(11645) * 4;
+acc += Math.sin(11645) + Math.cos(11646) * 5;
+acc += Math.sin(11646) + Math.cos(11647) * 6;
+acc += Math.sin(11647) + Math.cos(11648) * 7;
+acc += Math.sin(11648) + Math.cos(11649) * 8;
+acc += Math.sin(11649) + Math.cos(11650) * 9;
+acc += Math.sin(11650) + Math.cos(11651) * 10;
+acc += Math.sin(11651) + Math.cos(11652) * 11;
+acc += Math.sin(11652) + Math.cos(11653) * 12;
+acc += Math.sin(11653) + Math.cos(11654) * 13;
+acc += Math.sin(11654) + Math.cos(11655) * 14;
+acc += Math.sin(11655) + Math.cos(11656) * 15;
+acc += Math.sin(11656) + Math.cos(11657) * 16;
+acc += Math.sin(11657) + Math.cos(11658) * 17;
+acc += Math.sin(11658) + Math.cos(11659) * 18;
+acc += Math.sin(11659) + Math.cos(11660) * 19;
+acc += Math.sin(11660) + Math.cos(11661) * 20;
+acc += Math.sin(11661) + Math.cos(11662) * 21;
+acc += Math.sin(11662) + Math.cos(11663) * 22;
+acc += Math.sin(11663) + Math.cos(11664) * 23;
+acc += Math.sin(11664) + Math.cos(11665) * 24;
+acc += Math.sin(11665) + Math.cos(11666) * 25;
+acc += Math.sin(11666) + Math.cos(11667) * 26;
+acc += Math.sin(11667) + Math.cos(11668) * 27;
+acc += Math.sin(11668) + Math.cos(11669) * 28;
+acc += Math.sin(11669) + Math.cos(11670) * 29;
+acc += Math.sin(11670) + Math.cos(11671) * 30;
+acc += Math.sin(11671) + Math.cos(11672) * 31;
+acc += Math.sin(11672) + Math.cos(11673) * 32;
+acc += Math.sin(11673) + Math.cos(11674) * 33;
+acc += Math.sin(11674) + Math.cos(11675) * 34;
+acc += Math.sin(11675) + Math.cos(11676) * 35;
+acc += Math.sin(11676) + Math.cos(11677) * 36;
+acc += Math.sin(11677) + Math.cos(11678) * 37;
+acc += Math.sin(11678) + Math.cos(11679) * 38;
+acc += Math.sin(11679) + Math.cos(11680) * 39;
+acc += Math.sin(11680) + Math.cos(11681) * 40;
+acc += Math.sin(11681) + Math.cos(11682) * 41;
+acc += Math.sin(11682) + Math.cos(11683) * 42;
+acc += Math.sin(11683) + Math.cos(11684) * 43;
+acc += Math.sin(11684) + Math.cos(11685) * 44;
+acc += Math.sin(11685) + Math.cos(11686) * 45;
+acc += Math.sin(11686) + Math.cos(11687) * 46;
+acc += Math.sin(11687) + Math.cos(11688) * 47;
+acc += Math.sin(11688) + Math.cos(11689) * 48;
+acc += Math.sin(11689) + Math.cos(11690) * 49;
+acc += Math.sin(11690) + Math.cos(11691) * 50;
+acc += Math.sin(11691) + Math.cos(11692) * 51;
+acc += Math.sin(11692) + Math.cos(11693) * 52;
+acc += Math.sin(11693) + Math.cos(11694) * 53;
+acc += Math.sin(11694) + Math.cos(11695) * 54;
+acc += Math.sin(11695) + Math.cos(11696) * 55;
+acc += Math.sin(11696) + Math.cos(11697) * 56;
+acc += Math.sin(11697) + Math.cos(11698) * 57;
+acc += Math.sin(11698) + Math.cos(11699) * 58;
+acc += Math.sin(11699) + Math.cos(11700) * 59;
+acc += Math.sin(11700) + Math.cos(11701) * 60;
+acc += Math.sin(11701) + Math.cos(11702) * 61;
+acc += Math.sin(11702) + Math.cos(11703) * 62;
+acc += Math.sin(11703) + Math.cos(11704) * 63;
+acc += Math.sin(11704) + Math.cos(11705) * 64;
+acc += Math.sin(11705) + Math.cos(11706) * 65;
+acc += Math.sin(11706) + Math.cos(11707) * 66;
+acc += Math.sin(11707) + Math.cos(11708) * 67;
+acc += Math.sin(11708) + Math.cos(11709) * 68;
+acc += Math.sin(11709) + Math.cos(11710) * 69;
+acc += Math.sin(11710) + Math.cos(11711) * 70;
+acc += Math.sin(11711) + Math.cos(11712) * 71;
+acc += Math.sin(11712) + Math.cos(11713) * 72;
+acc += Math.sin(11713) + Math.cos(11714) * 73;
+acc += Math.sin(11714) + Math.cos(11715) * 74;
+acc += Math.sin(11715) + Math.cos(11716) * 75;
+acc += Math.sin(11716) + Math.cos(11717) * 76;
+acc += Math.sin(11717) + Math.cos(11718) * 77;
+acc += Math.sin(11718) + Math.cos(11719) * 78;
+acc += Math.sin(11719) + Math.cos(11720) * 79;
+acc += Math.sin(11720) + Math.cos(11721) * 80;
+acc += Math.sin(11721) + Math.cos(11722) * 81;
+acc += Math.sin(11722) + Math.cos(11723) * 82;
+acc += Math.sin(11723) + Math.cos(11724) * 83;
+acc += Math.sin(11724) + Math.cos(11725) * 84;
+acc += Math.sin(11725) + Math.cos(11726) * 85;
+acc += Math.sin(11726) + Math.cos(11727) * 86;
+acc += Math.sin(11727) + Math.cos(11728) * 87;
+acc += Math.sin(11728) + Math.cos(11729) * 88;
+acc += Math.sin(11729) + Math.cos(11730) * 89;
+acc += Math.sin(11730) + Math.cos(11731) * 90;
+acc += Math.sin(11731) + Math.cos(11732) * 91;
+acc += Math.sin(11732) + Math.cos(11733) * 92;
+acc += Math.sin(11733) + Math.cos(11734) * 93;
+acc += Math.sin(11734) + Math.cos(11735) * 94;
+acc += Math.sin(11735) + Math.cos(11736) * 95;
+acc += Math.sin(11736) + Math.cos(11737) * 96;
+acc += Math.sin(11737) + Math.cos(11738) * 0;
+acc += Math.sin(11738) + Math.cos(11739) * 1;
+acc += Math.sin(11739) + Math.cos(11740) * 2;
+acc += Math.sin(11740) + Math.cos(11741) * 3;
+acc += Math.sin(11741) + Math.cos(11742) * 4;
+acc += Math.sin(11742) + Math.cos(11743) * 5;
+acc += Math.sin(11743) + Math.cos(11744) * 6;
+acc += Math.sin(11744) + Math.cos(11745) * 7;
+acc += Math.sin(11745) + Math.cos(11746) * 8;
+acc += Math.sin(11746) + Math.cos(11747) * 9;
+acc += Math.sin(11747) + Math.cos(11748) * 10;
+acc += Math.sin(11748) + Math.cos(11749) * 11;
+acc += Math.sin(11749) + Math.cos(11750) * 12;
+acc += Math.sin(11750) + Math.cos(11751) * 13;
+acc += Math.sin(11751) + Math.cos(11752) * 14;
+acc += Math.sin(11752) + Math.cos(11753) * 15;
+acc += Math.sin(11753) + Math.cos(11754) * 16;
+acc += Math.sin(11754) + Math.cos(11755) * 17;
+acc += Math.sin(11755) + Math.cos(11756) * 18;
+acc += Math.sin(11756) + Math.cos(11757) * 19;
+acc += Math.sin(11757) + Math.cos(11758) * 20;
+acc += Math.sin(11758) + Math.cos(11759) * 21;
+acc += Math.sin(11759) + Math.cos(11760) * 22;
+acc += Math.sin(11760) + Math.cos(11761) * 23;
+acc += Math.sin(11761) + Math.cos(11762) * 24;
+acc += Math.sin(11762) + Math.cos(11763) * 25;
+acc += Math.sin(11763) + Math.cos(11764) * 26;
+acc += Math.sin(11764) + Math.cos(11765) * 27;
+acc += Math.sin(11765) + Math.cos(11766) * 28;
+acc += Math.sin(11766) + Math.cos(11767) * 29;
+acc += Math.sin(11767) + Math.cos(11768) * 30;
+acc += Math.sin(11768) + Math.cos(11769) * 31;
+acc += Math.sin(11769) + Math.cos(11770) * 32;
+acc += Math.sin(11770) + Math.cos(11771) * 33;
+acc += Math.sin(11771) + Math.cos(11772) * 34;
+acc += Math.sin(11772) + Math.cos(11773) * 35;
+acc += Math.sin(11773) + Math.cos(11774) * 36;
+acc += Math.sin(11774) + Math.cos(11775) * 37;
+acc += Math.sin(11775) + Math.cos(11776) * 38;
+acc += Math.sin(11776) + Math.cos(11777) * 39;
+acc += Math.sin(11777) + Math.cos(11778) * 40;
+acc += Math.sin(11778) + Math.cos(11779) * 41;
+acc += Math.sin(11779) + Math.cos(11780) * 42;
+acc += Math.sin(11780) + Math.cos(11781) * 43;
+acc += Math.sin(11781) + Math.cos(11782) * 44;
+acc += Math.sin(11782) + Math.cos(11783) * 45;
+acc += Math.sin(11783) + Math.cos(11784) * 46;
+acc += Math.sin(11784) + Math.cos(11785) * 47;
+acc += Math.sin(11785) + Math.cos(11786) * 48;
+acc += Math.sin(11786) + Math.cos(11787) * 49;
+acc += Math.sin(11787) + Math.cos(11788) * 50;
+acc += Math.sin(11788) + Math.cos(11789) * 51;
+acc += Math.sin(11789) + Math.cos(11790) * 52;
+acc += Math.sin(11790) + Math.cos(11791) * 53;
+acc += Math.sin(11791) + Math.cos(11792) * 54;
+acc += Math.sin(11792) + Math.cos(11793) * 55;
+acc += Math.sin(11793) + Math.cos(11794) * 56;
+acc += Math.sin(11794) + Math.cos(11795) * 57;
+acc += Math.sin(11795) + Math.cos(11796) * 58;
+acc += Math.sin(11796) + Math.cos(11797) * 59;
+acc += Math.sin(11797) + Math.cos(11798) * 60;
+acc += Math.sin(11798) + Math.cos(11799) * 61;
+acc += Math.sin(11799) + Math.cos(11800) * 62;
+acc += Math.sin(11800) + Math.cos(11801) * 63;
+acc += Math.sin(11801) + Math.cos(11802) * 64;
+acc += Math.sin(11802) + Math.cos(11803) * 65;
+acc += Math.sin(11803) + Math.cos(11804) * 66;
+acc += Math.sin(11804) + Math.cos(11805) * 67;
+acc += Math.sin(11805) + Math.cos(11806) * 68;
+acc += Math.sin(11806) + Math.cos(11807) * 69;
+acc += Math.sin(11807) + Math.cos(11808) * 70;
+acc += Math.sin(11808) + Math.cos(11809) * 71;
+acc += Math.sin(11809) + Math.cos(11810) * 72;
+acc += Math.sin(11810) + Math.cos(11811) * 73;
+acc += Math.sin(11811) + Math.cos(11812) * 74;
+acc += Math.sin(11812) + Math.cos(11813) * 75;
+acc += Math.sin(11813) + Math.cos(11814) * 76;
+acc += Math.sin(11814) + Math.cos(11815) * 77;
+acc += Math.sin(11815) + Math.cos(11816) * 78;
+acc += Math.sin(11816) + Math.cos(11817) * 79;
+acc += Math.sin(11817) + Math.cos(11818) * 80;
+acc += Math.sin(11818) + Math.cos(11819) * 81;
+acc += Math.sin(11819) + Math.cos(11820) * 82;
+acc += Math.sin(11820) + Math.cos(11821) * 83;
+acc += Math.sin(11821) + Math.cos(11822) * 84;
+acc += Math.sin(11822) + Math.cos(11823) * 85;
+acc += Math.sin(11823) + Math.cos(11824) * 86;
+acc += Math.sin(11824) + Math.cos(11825) * 87;
+acc += Math.sin(11825) + Math.cos(11826) * 88;
+acc += Math.sin(11826) + Math.cos(11827) * 89;
+acc += Math.sin(11827) + Math.cos(11828) * 90;
+acc += Math.sin(11828) + Math.cos(11829) * 91;
+acc += Math.sin(11829) + Math.cos(11830) * 92;
+acc += Math.sin(11830) + Math.cos(11831) * 93;
+acc += Math.sin(11831) + Math.cos(11832) * 94;
+acc += Math.sin(11832) + Math.cos(11833) * 95;
+acc += Math.sin(11833) + Math.cos(11834) * 96;
+acc += Math.sin(11834) + Math.cos(11835) * 0;
+acc += Math.sin(11835) + Math.cos(11836) * 1;
+acc += Math.sin(11836) + Math.cos(11837) * 2;
+acc += Math.sin(11837) + Math.cos(11838) * 3;
+acc += Math.sin(11838) + Math.cos(11839) * 4;
+acc += Math.sin(11839) + Math.cos(11840) * 5;
+acc += Math.sin(11840) + Math.cos(11841) * 6;
+acc += Math.sin(11841) + Math.cos(11842) * 7;
+acc += Math.sin(11842) + Math.cos(11843) * 8;
+acc += Math.sin(11843) + Math.cos(11844) * 9;
+acc += Math.sin(11844) + Math.cos(11845) * 10;
+acc += Math.sin(11845) + Math.cos(11846) * 11;
+acc += Math.sin(11846) + Math.cos(11847) * 12;
+acc += Math.sin(11847) + Math.cos(11848) * 13;
+acc += Math.sin(11848) + Math.cos(11849) * 14;
+acc += Math.sin(11849) + Math.cos(11850) * 15;
+acc += Math.sin(11850) + Math.cos(11851) * 16;
+acc += Math.sin(11851) + Math.cos(11852) * 17;
+acc += Math.sin(11852) + Math.cos(11853) * 18;
+acc += Math.sin(11853) + Math.cos(11854) * 19;
+acc += Math.sin(11854) + Math.cos(11855) * 20;
+acc += Math.sin(11855) + Math.cos(11856) * 21;
+acc += Math.sin(11856) + Math.cos(11857) * 22;
+acc += Math.sin(11857) + Math.cos(11858) * 23;
+acc += Math.sin(11858) + Math.cos(11859) * 24;
+acc += Math.sin(11859) + Math.cos(11860) * 25;
+acc += Math.sin(11860) + Math.cos(11861) * 26;
+acc += Math.sin(11861) + Math.cos(11862) * 27;
+acc += Math.sin(11862) + Math.cos(11863) * 28;
+acc += Math.sin(11863) + Math.cos(11864) * 29;
+acc += Math.sin(11864) + Math.cos(11865) * 30;
+acc += Math.sin(11865) + Math.cos(11866) * 31;
+acc += Math.sin(11866) + Math.cos(11867) * 32;
+acc += Math.sin(11867) + Math.cos(11868) * 33;
+acc += Math.sin(11868) + Math.cos(11869) * 34;
+acc += Math.sin(11869) + Math.cos(11870) * 35;
+acc += Math.sin(11870) + Math.cos(11871) * 36;
+acc += Math.sin(11871) + Math.cos(11872) * 37;
+acc += Math.sin(11872) + Math.cos(11873) * 38;
+acc += Math.sin(11873) + Math.cos(11874) * 39;
+acc += Math.sin(11874) + Math.cos(11875) * 40;
+acc += Math.sin(11875) + Math.cos(11876) * 41;
+acc += Math.sin(11876) + Math.cos(11877) * 42;
+acc += Math.sin(11877) + Math.cos(11878) * 43;
+acc += Math.sin(11878) + Math.cos(11879) * 44;
+acc += Math.sin(11879) + Math.cos(11880) * 45;
+acc += Math.sin(11880) + Math.cos(11881) * 46;
+acc += Math.sin(11881) + Math.cos(11882) * 47;
+acc += Math.sin(11882) + Math.cos(11883) * 48;
+acc += Math.sin(11883) + Math.cos(11884) * 49;
+acc += Math.sin(11884) + Math.cos(11885) * 50;
+acc += Math.sin(11885) + Math.cos(11886) * 51;
+acc += Math.sin(11886) + Math.cos(11887) * 52;
+acc += Math.sin(11887) + Math.cos(11888) * 53;
+acc += Math.sin(11888) + Math.cos(11889) * 54;
+acc += Math.sin(11889) + Math.cos(11890) * 55;
+acc += Math.sin(11890) + Math.cos(11891) * 56;
+acc += Math.sin(11891) + Math.cos(11892) * 57;
+acc += Math.sin(11892) + Math.cos(11893) * 58;
+acc += Math.sin(11893) + Math.cos(11894) * 59;
+acc += Math.sin(11894) + Math.cos(11895) * 60;
+acc += Math.sin(11895) + Math.cos(11896) * 61;
+acc += Math.sin(11896) + Math.cos(11897) * 62;
+acc += Math.sin(11897) + Math.cos(11898) * 63;
+acc += Math.sin(11898) + Math.cos(11899) * 64;
+acc += Math.sin(11899) + Math.cos(11900) * 65;
+acc += Math.sin(11900) + Math.cos(11901) * 66;
+acc += Math.sin(11901) + Math.cos(11902) * 67;
+acc += Math.sin(11902) + Math.cos(11903) * 68;
+acc += Math.sin(11903) + Math.cos(11904) * 69;
+acc += Math.sin(11904) + Math.cos(11905) * 70;
+acc += Math.sin(11905) + Math.cos(11906) * 71;
+acc += Math.sin(11906) + Math.cos(11907) * 72;
+acc += Math.sin(11907) + Math.cos(11908) * 73;
+acc += Math.sin(11908) + Math.cos(11909) * 74;
+acc += Math.sin(11909) + Math.cos(11910) * 75;
+acc += Math.sin(11910) + Math.cos(11911) * 76;
+acc += Math.sin(11911) + Math.cos(11912) * 77;
+acc += Math.sin(11912) + Math.cos(11913) * 78;
+acc += Math.sin(11913) + Math.cos(11914) * 79;
+acc += Math.sin(11914) + Math.cos(11915) * 80;
+acc += Math.sin(11915) + Math.cos(11916) * 81;
+acc += Math.sin(11916) + Math.cos(11917) * 82;
+acc += Math.sin(11917) + Math.cos(11918) * 83;
+acc += Math.sin(11918) + Math.cos(11919) * 84;
+acc += Math.sin(11919) + Math.cos(11920) * 85;
+acc += Math.sin(11920) + Math.cos(11921) * 86;
+acc += Math.sin(11921) + Math.cos(11922) * 87;
+acc += Math.sin(11922) + Math.cos(11923) * 88;
+acc += Math.sin(11923) + Math.cos(11924) * 89;
+acc += Math.sin(11924) + Math.cos(11925) * 90;
+acc += Math.sin(11925) + Math.cos(11926) * 91;
+acc += Math.sin(11926) + Math.cos(11927) * 92;
+acc += Math.sin(11927) + Math.cos(11928) * 93;
+acc += Math.sin(11928) + Math.cos(11929) * 94;
+acc += Math.sin(11929) + Math.cos(11930) * 95;
+acc += Math.sin(11930) + Math.cos(11931) * 96;
+acc += Math.sin(11931) + Math.cos(11932) * 0;
+acc += Math.sin(11932) + Math.cos(11933) * 1;
+acc += Math.sin(11933) + Math.cos(11934) * 2;
+acc += Math.sin(11934) + Math.cos(11935) * 3;
+acc += Math.sin(11935) + Math.cos(11936) * 4;
+acc += Math.sin(11936) + Math.cos(11937) * 5;
+acc += Math.sin(11937) + Math.cos(11938) * 6;
+acc += Math.sin(11938) + Math.cos(11939) * 7;
+acc += Math.sin(11939) + Math.cos(11940) * 8;
+acc += Math.sin(11940) + Math.cos(11941) * 9;
+acc += Math.sin(11941) + Math.cos(11942) * 10;
+acc += Math.sin(11942) + Math.cos(11943) * 11;
+acc += Math.sin(11943) + Math.cos(11944) * 12;
+acc += Math.sin(11944) + Math.cos(11945) * 13;
+acc += Math.sin(11945) + Math.cos(11946) * 14;
+acc += Math.sin(11946) + Math.cos(11947) * 15;
+acc += Math.sin(11947) + Math.cos(11948) * 16;
+acc += Math.sin(11948) + Math.cos(11949) * 17;
+acc += Math.sin(11949) + Math.cos(11950) * 18;
+acc += Math.sin(11950) + Math.cos(11951) * 19;
+acc += Math.sin(11951) + Math.cos(11952) * 20;
+acc += Math.sin(11952) + Math.cos(11953) * 21;
+acc += Math.sin(11953) + Math.cos(11954) * 22;
+acc += Math.sin(11954) + Math.cos(11955) * 23;
+acc += Math.sin(11955) + Math.cos(11956) * 24;
+acc += Math.sin(11956) + Math.cos(11957) * 25;
+acc += Math.sin(11957) + Math.cos(11958) * 26;
+acc += Math.sin(11958) + Math.cos(11959) * 27;
+acc += Math.sin(11959) + Math.cos(11960) * 28;
+acc += Math.sin(11960) + Math.cos(11961) * 29;
+acc += Math.sin(11961) + Math.cos(11962) * 30;
+acc += Math.sin(11962) + Math.cos(11963) * 31;
+acc += Math.sin(11963) + Math.cos(11964) * 32;
+acc += Math.sin(11964) + Math.cos(11965) * 33;
+acc += Math.sin(11965) + Math.cos(11966) * 34;
+acc += Math.sin(11966) + Math.cos(11967) * 35;
+acc += Math.sin(11967) + Math.cos(11968) * 36;
+acc += Math.sin(11968) + Math.cos(11969) * 37;
+acc += Math.sin(11969) + Math.cos(11970) * 38;
+acc += Math.sin(11970) + Math.cos(11971) * 39;
+acc += Math.sin(11971) + Math.cos(11972) * 40;
+acc += Math.sin(11972) + Math.cos(11973) * 41;
+acc += Math.sin(11973) + Math.cos(11974) * 42;
+acc += Math.sin(11974) + Math.cos(11975) * 43;
+acc += Math.sin(11975) + Math.cos(11976) * 44;
+acc += Math.sin(11976) + Math.cos(11977) * 45;
+acc += Math.sin(11977) + Math.cos(11978) * 46;
+acc += Math.sin(11978) + Math.cos(11979) * 47;
+acc += Math.sin(11979) + Math.cos(11980) * 48;
+acc += Math.sin(11980) + Math.cos(11981) * 49;
+acc += Math.sin(11981) + Math.cos(11982) * 50;
+acc += Math.sin(11982) + Math.cos(11983) * 51;
+acc += Math.sin(11983) + Math.cos(11984) * 52;
+acc += Math.sin(11984) + Math.cos(11985) * 53;
+acc += Math.sin(11985) + Math.cos(11986) * 54;
+acc += Math.sin(11986) + Math.cos(11987) * 55;
+acc += Math.sin(11987) + Math.cos(11988) * 56;
+acc += Math.sin(11988) + Math.cos(11989) * 57;
+acc += Math.sin(11989) + Math.cos(11990) * 58;
+acc += Math.sin(11990) + Math.cos(11991) * 59;
+acc += Math.sin(11991) + Math.cos(11992) * 60;
+acc += Math.sin(11992) + Math.cos(11993) * 61;
+acc += Math.sin(11993) + Math.cos(11994) * 62;
+acc += Math.sin(11994) + Math.cos(11995) * 63;
+acc += Math.sin(11995) + Math.cos(11996) * 64;
+acc += Math.sin(11996) + Math.cos(11997) * 65;
+acc += Math.sin(11997) + Math.cos(11998) * 66;
+acc += Math.sin(11998) + Math.cos(11999) * 67;
+acc += Math.sin(11999) + Math.cos(12000) * 68;
+acc += Math.sin(12000) + Math.cos(12001) * 69;
+acc += Math.sin(12001) + Math.cos(12002) * 70;
+acc += Math.sin(12002) + Math.cos(12003) * 71;
+acc += Math.sin(12003) + Math.cos(12004) * 72;
+acc += Math.sin(12004) + Math.cos(12005) * 73;
+acc += Math.sin(12005) + Math.cos(12006) * 74;
+acc += Math.sin(12006) + Math.cos(12007) * 75;
+acc += Math.sin(12007) + Math.cos(12008) * 76;
+acc += Math.sin(12008) + Math.cos(12009) * 77;
+acc += Math.sin(12009) + Math.cos(12010) * 78;
+acc += Math.sin(12010) + Math.cos(12011) * 79;
+acc += Math.sin(12011) + Math.cos(12012) * 80;
+acc += Math.sin(12012) + Math.cos(12013) * 81;
+acc += Math.sin(12013) + Math.cos(12014) * 82;
+acc += Math.sin(12014) + Math.cos(12015) * 83;
+acc += Math.sin(12015) + Math.cos(12016) * 84;
+acc += Math.sin(12016) + Math.cos(12017) * 85;
+acc += Math.sin(12017) + Math.cos(12018) * 86;
+acc += Math.sin(12018) + Math.cos(12019) * 87;
+acc += Math.sin(12019) + Math.cos(12020) * 88;
+acc += Math.sin(12020) + Math.cos(12021) * 89;
+acc += Math.sin(12021) + Math.cos(12022) * 90;
+acc += Math.sin(12022) + Math.cos(12023) * 91;
+acc += Math.sin(12023) + Math.cos(12024) * 92;
+acc += Math.sin(12024) + Math.cos(12025) * 93;
+acc += Math.sin(12025) + Math.cos(12026) * 94;
+acc += Math.sin(12026) + Math.cos(12027) * 95;
+acc += Math.sin(12027) + Math.cos(12028) * 96;
+acc += Math.sin(12028) + Math.cos(12029) * 0;
+acc += Math.sin(12029) + Math.cos(12030) * 1;
+acc += Math.sin(12030) + Math.cos(12031) * 2;
+acc += Math.sin(12031) + Math.cos(12032) * 3;
+acc += Math.sin(12032) + Math.cos(12033) * 4;
+acc += Math.sin(12033) + Math.cos(12034) * 5;
+acc += Math.sin(12034) + Math.cos(12035) * 6;
+acc += Math.sin(12035) + Math.cos(12036) * 7;
+acc += Math.sin(12036) + Math.cos(12037) * 8;
+acc += Math.sin(12037) + Math.cos(12038) * 9;
+acc += Math.sin(12038) + Math.cos(12039) * 10;
+acc += Math.sin(12039) + Math.cos(12040) * 11;
+acc += Math.sin(12040) + Math.cos(12041) * 12;
+acc += Math.sin(12041) + Math.cos(12042) * 13;
+acc += Math.sin(12042) + Math.cos(12043) * 14;
+acc += Math.sin(12043) + Math.cos(12044) * 15;
+acc += Math.sin(12044) + Math.cos(12045) * 16;
+acc += Math.sin(12045) + Math.cos(12046) * 17;
+acc += Math.sin(12046) + Math.cos(12047) * 18;
+acc += Math.sin(12047) + Math.cos(12048) * 19;
+acc += Math.sin(12048) + Math.cos(12049) * 20;
+acc += Math.sin(12049) + Math.cos(12050) * 21;
+acc += Math.sin(12050) + Math.cos(12051) * 22;
+acc += Math.sin(12051) + Math.cos(12052) * 23;
+acc += Math.sin(12052) + Math.cos(12053) * 24;
+acc += Math.sin(12053) + Math.cos(12054) * 25;
+acc += Math.sin(12054) + Math.cos(12055) * 26;
+acc += Math.sin(12055) + Math.cos(12056) * 27;
+acc += Math.sin(12056) + Math.cos(12057) * 28;
+acc += Math.sin(12057) + Math.cos(12058) * 29;
+acc += Math.sin(12058) + Math.cos(12059) * 30;
+acc += Math.sin(12059) + Math.cos(12060) * 31;
+acc += Math.sin(12060) + Math.cos(12061) * 32;
+acc += Math.sin(12061) + Math.cos(12062) * 33;
+acc += Math.sin(12062) + Math.cos(12063) * 34;
+acc += Math.sin(12063) + Math.cos(12064) * 35;
+acc += Math.sin(12064) + Math.cos(12065) * 36;
+acc += Math.sin(12065) + Math.cos(12066) * 37;
+acc += Math.sin(12066) + Math.cos(12067) * 38;
+acc += Math.sin(12067) + Math.cos(12068) * 39;
+acc += Math.sin(12068) + Math.cos(12069) * 40;
+acc += Math.sin(12069) + Math.cos(12070) * 41;
+acc += Math.sin(12070) + Math.cos(12071) * 42;
+acc += Math.sin(12071) + Math.cos(12072) * 43;
+acc += Math.sin(12072) + Math.cos(12073) * 44;
+acc += Math.sin(12073) + Math.cos(12074) * 45;
+acc += Math.sin(12074) + Math.cos(12075) * 46;
+acc += Math.sin(12075) + Math.cos(12076) * 47;
+acc += Math.sin(12076) + Math.cos(12077) * 48;
+acc += Math.sin(12077) + Math.cos(12078) * 49;
+acc += Math.sin(12078) + Math.cos(12079) * 50;
+acc += Math.sin(12079) + Math.cos(12080) * 51;
+acc += Math.sin(12080) + Math.cos(12081) * 52;
+acc += Math.sin(12081) + Math.cos(12082) * 53;
+acc += Math.sin(12082) + Math.cos(12083) * 54;
+acc += Math.sin(12083) + Math.cos(12084) * 55;
+acc += Math.sin(12084) + Math.cos(12085) * 56;
+acc += Math.sin(12085) + Math.cos(12086) * 57;
+acc += Math.sin(12086) + Math.cos(12087) * 58;
+acc += Math.sin(12087) + Math.cos(12088) * 59;
+acc += Math.sin(12088) + Math.cos(12089) * 60;
+acc += Math.sin(12089) + Math.cos(12090) * 61;
+acc += Math.sin(12090) + Math.cos(12091) * 62;
+acc += Math.sin(12091) + Math.cos(12092) * 63;
+acc += Math.sin(12092) + Math.cos(12093) * 64;
+acc += Math.sin(12093) + Math.cos(12094) * 65;
+acc += Math.sin(12094) + Math.cos(12095) * 66;
+acc += Math.sin(12095) + Math.cos(12096) * 67;
+acc += Math.sin(12096) + Math.cos(12097) * 68;
+acc += Math.sin(12097) + Math.cos(12098) * 69;
+acc += Math.sin(12098) + Math.cos(12099) * 70;
+acc += Math.sin(12099) + Math.cos(12100) * 71;
+acc += Math.sin(12100) + Math.cos(12101) * 72;
+acc += Math.sin(12101) + Math.cos(12102) * 73;
+acc += Math.sin(12102) + Math.cos(12103) * 74;
+acc += Math.sin(12103) + Math.cos(12104) * 75;
+acc += Math.sin(12104) + Math.cos(12105) * 76;
+acc += Math.sin(12105) + Math.cos(12106) * 77;
+acc += Math.sin(12106) + Math.cos(12107) * 78;
+acc += Math.sin(12107) + Math.cos(12108) * 79;
+acc += Math.sin(12108) + Math.cos(12109) * 80;
+acc += Math.sin(12109) + Math.cos(12110) * 81;
+acc += Math.sin(12110) + Math.cos(12111) * 82;
+acc += Math.sin(12111) + Math.cos(12112) * 83;
+acc += Math.sin(12112) + Math.cos(12113) * 84;
+acc += Math.sin(12113) + Math.cos(12114) * 85;
+acc += Math.sin(12114) + Math.cos(12115) * 86;
+acc += Math.sin(12115) + Math.cos(12116) * 87;
+acc += Math.sin(12116) + Math.cos(12117) * 88;
+acc += Math.sin(12117) + Math.cos(12118) * 89;
+acc += Math.sin(12118) + Math.cos(12119) * 90;
+acc += Math.sin(12119) + Math.cos(12120) * 91;
+acc += Math.sin(12120) + Math.cos(12121) * 92;
+acc += Math.sin(12121) + Math.cos(12122) * 93;
+acc += Math.sin(12122) + Math.cos(12123) * 94;
+acc += Math.sin(12123) + Math.cos(12124) * 95;
+acc += Math.sin(12124) + Math.cos(12125) * 96;
+acc += Math.sin(12125) + Math.cos(12126) * 0;
+acc += Math.sin(12126) + Math.cos(12127) * 1;
+acc += Math.sin(12127) + Math.cos(12128) * 2;
+acc += Math.sin(12128) + Math.cos(12129) * 3;
+acc += Math.sin(12129) + Math.cos(12130) * 4;
+acc += Math.sin(12130) + Math.cos(12131) * 5;
+acc += Math.sin(12131) + Math.cos(12132) * 6;
+acc += Math.sin(12132) + Math.cos(12133) * 7;
+acc += Math.sin(12133) + Math.cos(12134) * 8;
+acc += Math.sin(12134) + Math.cos(12135) * 9;
+acc += Math.sin(12135) + Math.cos(12136) * 10;
+acc += Math.sin(12136) + Math.cos(12137) * 11;
+acc += Math.sin(12137) + Math.cos(12138) * 12;
+acc += Math.sin(12138) + Math.cos(12139) * 13;
+acc += Math.sin(12139) + Math.cos(12140) * 14;
+acc += Math.sin(12140) + Math.cos(12141) * 15;
+acc += Math.sin(12141) + Math.cos(12142) * 16;
+acc += Math.sin(12142) + Math.cos(12143) * 17;
+acc += Math.sin(12143) + Math.cos(12144) * 18;
+acc += Math.sin(12144) + Math.cos(12145) * 19;
+acc += Math.sin(12145) + Math.cos(12146) * 20;
+acc += Math.sin(12146) + Math.cos(12147) * 21;
+acc += Math.sin(12147) + Math.cos(12148) * 22;
+acc += Math.sin(12148) + Math.cos(12149) * 23;
+acc += Math.sin(12149) + Math.cos(12150) * 24;
+acc += Math.sin(12150) + Math.cos(12151) * 25;
+acc += Math.sin(12151) + Math.cos(12152) * 26;
+acc += Math.sin(12152) + Math.cos(12153) * 27;
+acc += Math.sin(12153) + Math.cos(12154) * 28;
+acc += Math.sin(12154) + Math.cos(12155) * 29;
+acc += Math.sin(12155) + Math.cos(12156) * 30;
+acc += Math.sin(12156) + Math.cos(12157) * 31;
+acc += Math.sin(12157) + Math.cos(12158) * 32;
+acc += Math.sin(12158) + Math.cos(12159) * 33;
+acc += Math.sin(12159) + Math.cos(12160) * 34;
+acc += Math.sin(12160) + Math.cos(12161) * 35;
+acc += Math.sin(12161) + Math.cos(12162) * 36;
+acc += Math.sin(12162) + Math.cos(12163) * 37;
+acc += Math.sin(12163) + Math.cos(12164) * 38;
+acc += Math.sin(12164) + Math.cos(12165) * 39;
+acc += Math.sin(12165) + Math.cos(12166) * 40;
+acc += Math.sin(12166) + Math.cos(12167) * 41;
+acc += Math.sin(12167) + Math.cos(12168) * 42;
+acc += Math.sin(12168) + Math.cos(12169) * 43;
+acc += Math.sin(12169) + Math.cos(12170) * 44;
+acc += Math.sin(12170) + Math.cos(12171) * 45;
+acc += Math.sin(12171) + Math.cos(12172) * 46;
+acc += Math.sin(12172) + Math.cos(12173) * 47;
+acc += Math.sin(12173) + Math.cos(12174) * 48;
+acc += Math.sin(12174) + Math.cos(12175) * 49;
+acc += Math.sin(12175) + Math.cos(12176) * 50;
+acc += Math.sin(12176) + Math.cos(12177) * 51;
+acc += Math.sin(12177) + Math.cos(12178) * 52;
+acc += Math.sin(12178) + Math.cos(12179) * 53;
+acc += Math.sin(12179) + Math.cos(12180) * 54;
+acc += Math.sin(12180) + Math.cos(12181) * 55;
+acc += Math.sin(12181) + Math.cos(12182) * 56;
+acc += Math.sin(12182) + Math.cos(12183) * 57;
+acc += Math.sin(12183) + Math.cos(12184) * 58;
+acc += Math.sin(12184) + Math.cos(12185) * 59;
+acc += Math.sin(12185) + Math.cos(12186) * 60;
+acc += Math.sin(12186) + Math.cos(12187) * 61;
+acc += Math.sin(12187) + Math.cos(12188) * 62;
+acc += Math.sin(12188) + Math.cos(12189) * 63;
+acc += Math.sin(12189) + Math.cos(12190) * 64;
+acc += Math.sin(12190) + Math.cos(12191) * 65;
+acc += Math.sin(12191) + Math.cos(12192) * 66;
+acc += Math.sin(12192) + Math.cos(12193) * 67;
+acc += Math.sin(12193) + Math.cos(12194) * 68;
+acc += Math.sin(12194) + Math.cos(12195) * 69;
+acc += Math.sin(12195) + Math.cos(12196) * 70;
+acc += Math.sin(12196) + Math.cos(12197) * 71;
+acc += Math.sin(12197) + Math.cos(12198) * 72;
+acc += Math.sin(12198) + Math.cos(12199) * 73;
+acc += Math.sin(12199) + Math.cos(12200) * 74;
+acc += Math.sin(12200) + Math.cos(12201) * 75;
+acc += Math.sin(12201) + Math.cos(12202) * 76;
+acc += Math.sin(12202) + Math.cos(12203) * 77;
+acc += Math.sin(12203) + Math.cos(12204) * 78;
+acc += Math.sin(12204) + Math.cos(12205) * 79;
+acc += Math.sin(12205) + Math.cos(12206) * 80;
+acc += Math.sin(12206) + Math.cos(12207) * 81;
+acc += Math.sin(12207) + Math.cos(12208) * 82;
+acc += Math.sin(12208) + Math.cos(12209) * 83;
+acc += Math.sin(12209) + Math.cos(12210) * 84;
+acc += Math.sin(12210) + Math.cos(12211) * 85;
+acc += Math.sin(12211) + Math.cos(12212) * 86;
+acc += Math.sin(12212) + Math.cos(12213) * 87;
+acc += Math.sin(12213) + Math.cos(12214) * 88;
+acc += Math.sin(12214) + Math.cos(12215) * 89;
+acc += Math.sin(12215) + Math.cos(12216) * 90;
+acc += Math.sin(12216) + Math.cos(12217) * 91;
+acc += Math.sin(12217) + Math.cos(12218) * 92;
+acc += Math.sin(12218) + Math.cos(12219) * 93;
+acc += Math.sin(12219) + Math.cos(12220) * 94;
+acc += Math.sin(12220) + Math.cos(12221) * 95;
+acc += Math.sin(12221) + Math.cos(12222) * 96;
+acc += Math.sin(12222) + Math.cos(12223) * 0;
+acc += Math.sin(12223) + Math.cos(12224) * 1;
+acc += Math.sin(12224) + Math.cos(12225) * 2;
+acc += Math.sin(12225) + Math.cos(12226) * 3;
+acc += Math.sin(12226) + Math.cos(12227) * 4;
+acc += Math.sin(12227) + Math.cos(12228) * 5;
+acc += Math.sin(12228) + Math.cos(12229) * 6;
+acc += Math.sin(12229) + Math.cos(12230) * 7;
+acc += Math.sin(12230) + Math.cos(12231) * 8;
+acc += Math.sin(12231) + Math.cos(12232) * 9;
+acc += Math.sin(12232) + Math.cos(12233) * 10;
+acc += Math.sin(12233) + Math.cos(12234) * 11;
+acc += Math.sin(12234) + Math.cos(12235) * 12;
+acc += Math.sin(12235) + Math.cos(12236) * 13;
+acc += Math.sin(12236) + Math.cos(12237) * 14;
+acc += Math.sin(12237) + Math.cos(12238) * 15;
+acc += Math.sin(12238) + Math.cos(12239) * 16;
+acc += Math.sin(12239) + Math.cos(12240) * 17;
+acc += Math.sin(12240) + Math.cos(12241) * 18;
+acc += Math.sin(12241) + Math.cos(12242) * 19;
+acc += Math.sin(12242) + Math.cos(12243) * 20;
+acc += Math.sin(12243) + Math.cos(12244) * 21;
+acc += Math.sin(12244) + Math.cos(12245) * 22;
+acc += Math.sin(12245) + Math.cos(12246) * 23;
+acc += Math.sin(12246) + Math.cos(12247) * 24;
+acc += Math.sin(12247) + Math.cos(12248) * 25;
+acc += Math.sin(12248) + Math.cos(12249) * 26;
+acc += Math.sin(12249) + Math.cos(12250) * 27;
+acc += Math.sin(12250) + Math.cos(12251) * 28;
+acc += Math.sin(12251) + Math.cos(12252) * 29;
+acc += Math.sin(12252) + Math.cos(12253) * 30;
+acc += Math.sin(12253) + Math.cos(12254) * 31;
+acc += Math.sin(12254) + Math.cos(12255) * 32;
+acc += Math.sin(12255) + Math.cos(12256) * 33;
+acc += Math.sin(12256) + Math.cos(12257) * 34;
+acc += Math.sin(12257) + Math.cos(12258) * 35;
+acc += Math.sin(12258) + Math.cos(12259) * 36;
+acc += Math.sin(12259) + Math.cos(12260) * 37;
+acc += Math.sin(12260) + Math.cos(12261) * 38;
+acc += Math.sin(12261) + Math.cos(12262) * 39;
+acc += Math.sin(12262) + Math.cos(12263) * 40;
+acc += Math.sin(12263) + Math.cos(12264) * 41;
+acc += Math.sin(12264) + Math.cos(12265) * 42;
+acc += Math.sin(12265) + Math.cos(12266) * 43;
+acc += Math.sin(12266) + Math.cos(12267) * 44;
+acc += Math.sin(12267) + Math.cos(12268) * 45;
+acc += Math.sin(12268) + Math.cos(12269) * 46;
+acc += Math.sin(12269) + Math.cos(12270) * 47;
+acc += Math.sin(12270) + Math.cos(12271) * 48;
+acc += Math.sin(12271) + Math.cos(12272) * 49;
+acc += Math.sin(12272) + Math.cos(12273) * 50;
+acc += Math.sin(12273) + Math.cos(12274) * 51;
+acc += Math.sin(12274) + Math.cos(12275) * 52;
+acc += Math.sin(12275) + Math.cos(12276) * 53;
+acc += Math.sin(12276) + Math.cos(12277) * 54;
+acc += Math.sin(12277) + Math.cos(12278) * 55;
+acc += Math.sin(12278) + Math.cos(12279) * 56;
+acc += Math.sin(12279) + Math.cos(12280) * 57;
+acc += Math.sin(12280) + Math.cos(12281) * 58;
+acc += Math.sin(12281) + Math.cos(12282) * 59;
+acc += Math.sin(12282) + Math.cos(12283) * 60;
+acc += Math.sin(12283) + Math.cos(12284) * 61;
+acc += Math.sin(12284) + Math.cos(12285) * 62;
+acc += Math.sin(12285) + Math.cos(12286) * 63;
+acc += Math.sin(12286) + Math.cos(12287) * 64;
+acc += Math.sin(12287) + Math.cos(12288) * 65;
+acc += Math.sin(12288) + Math.cos(12289) * 66;
+acc += Math.sin(12289) + Math.cos(12290) * 67;
+acc += Math.sin(12290) + Math.cos(12291) * 68;
+acc += Math.sin(12291) + Math.cos(12292) * 69;
+acc += Math.sin(12292) + Math.cos(12293) * 70;
+acc += Math.sin(12293) + Math.cos(12294) * 71;
+acc += Math.sin(12294) + Math.cos(12295) * 72;
+acc += Math.sin(12295) + Math.cos(12296) * 73;
+acc += Math.sin(12296) + Math.cos(12297) * 74;
+acc += Math.sin(12297) + Math.cos(12298) * 75;
+acc += Math.sin(12298) + Math.cos(12299) * 76;
+acc += Math.sin(12299) + Math.cos(12300) * 77;
+acc += Math.sin(12300) + Math.cos(12301) * 78;
+acc += Math.sin(12301) + Math.cos(12302) * 79;
+acc += Math.sin(12302) + Math.cos(12303) * 80;
+acc += Math.sin(12303) + Math.cos(12304) * 81;
+acc += Math.sin(12304) + Math.cos(12305) * 82;
+acc += Math.sin(12305) + Math.cos(12306) * 83;
+acc += Math.sin(12306) + Math.cos(12307) * 84;
+acc += Math.sin(12307) + Math.cos(12308) * 85;
+acc += Math.sin(12308) + Math.cos(12309) * 86;
+acc += Math.sin(12309) + Math.cos(12310) * 87;
+acc += Math.sin(12310) + Math.cos(12311) * 88;
+acc += Math.sin(12311) + Math.cos(12312) * 89;
+acc += Math.sin(12312) + Math.cos(12313) * 90;
+acc += Math.sin(12313) + Math.cos(12314) * 91;
+acc += Math.sin(12314) + Math.cos(12315) * 92;
+acc += Math.sin(12315) + Math.cos(12316) * 93;
+acc += Math.sin(12316) + Math.cos(12317) * 94;
+acc += Math.sin(12317) + Math.cos(12318) * 95;
+acc += Math.sin(12318) + Math.cos(12319) * 96;
+acc += Math.sin(12319) + Math.cos(12320) * 0;
+acc += Math.sin(12320) + Math.cos(12321) * 1;
+acc += Math.sin(12321) + Math.cos(12322) * 2;
+acc += Math.sin(12322) + Math.cos(12323) * 3;
+acc += Math.sin(12323) + Math.cos(12324) * 4;
+acc += Math.sin(12324) + Math.cos(12325) * 5;
+acc += Math.sin(12325) + Math.cos(12326) * 6;
+acc += Math.sin(12326) + Math.cos(12327) * 7;
+acc += Math.sin(12327) + Math.cos(12328) * 8;
+acc += Math.sin(12328) + Math.cos(12329) * 9;
+acc += Math.sin(12329) + Math.cos(12330) * 10;
+acc += Math.sin(12330) + Math.cos(12331) * 11;
+acc += Math.sin(12331) + Math.cos(12332) * 12;
+acc += Math.sin(12332) + Math.cos(12333) * 13;
+acc += Math.sin(12333) + Math.cos(12334) * 14;
+acc += Math.sin(12334) + Math.cos(12335) * 15;
+acc += Math.sin(12335) + Math.cos(12336) * 16;
+acc += Math.sin(12336) + Math.cos(12337) * 17;
+acc += Math.sin(12337) + Math.cos(12338) * 18;
+acc += Math.sin(12338) + Math.cos(12339) * 19;
+acc += Math.sin(12339) + Math.cos(12340) * 20;
+acc += Math.sin(12340) + Math.cos(12341) * 21;
+acc += Math.sin(12341) + Math.cos(12342) * 22;
+acc += Math.sin(12342) + Math.cos(12343) * 23;
+acc += Math.sin(12343) + Math.cos(12344) * 24;
+acc += Math.sin(12344) + Math.cos(12345) * 25;
+acc += Math.sin(12345) + Math.cos(12346) * 26;
+acc += Math.sin(12346) + Math.cos(12347) * 27;
+acc += Math.sin(12347) + Math.cos(12348) * 28;
+acc += Math.sin(12348) + Math.cos(12349) * 29;
+acc += Math.sin(12349) + Math.cos(12350) * 30;
+acc += Math.sin(12350) + Math.cos(12351) * 31;
+acc += Math.sin(12351) + Math.cos(12352) * 32;
+acc += Math.sin(12352) + Math.cos(12353) * 33;
+acc += Math.sin(12353) + Math.cos(12354) * 34;
+acc += Math.sin(12354) + Math.cos(12355) * 35;
+acc += Math.sin(12355) + Math.cos(12356) * 36;
+acc += Math.sin(12356) + Math.cos(12357) * 37;
+acc += Math.sin(12357) + Math.cos(12358) * 38;
+acc += Math.sin(12358) + Math.cos(12359) * 39;
+acc += Math.sin(12359) + Math.cos(12360) * 40;
+acc += Math.sin(12360) + Math.cos(12361) * 41;
+acc += Math.sin(12361) + Math.cos(12362) * 42;
+acc += Math.sin(12362) + Math.cos(12363) * 43;
+acc += Math.sin(12363) + Math.cos(12364) * 44;
+acc += Math.sin(12364) + Math.cos(12365) * 45;
+acc += Math.sin(12365) + Math.cos(12366) * 46;
+acc += Math.sin(12366) + Math.cos(12367) * 47;
+acc += Math.sin(12367) + Math.cos(12368) * 48;
+acc += Math.sin(12368) + Math.cos(12369) * 49;
+acc += Math.sin(12369) + Math.cos(12370) * 50;
+acc += Math.sin(12370) + Math.cos(12371) * 51;
+acc += Math.sin(12371) + Math.cos(12372) * 52;
+acc += Math.sin(12372) + Math.cos(12373) * 53;
+acc += Math.sin(12373) + Math.cos(12374) * 54;
+acc += Math.sin(12374) + Math.cos(12375) * 55;
+acc += Math.sin(12375) + Math.cos(12376) * 56;
+acc += Math.sin(12376) + Math.cos(12377) * 57;
+acc += Math.sin(12377) + Math.cos(12378) * 58;
+acc += Math.sin(12378) + Math.cos(12379) * 59;
+acc += Math.sin(12379) + Math.cos(12380) * 60;
+acc += Math.sin(12380) + Math.cos(12381) * 61;
+acc += Math.sin(12381) + Math.cos(12382) * 62;
+acc += Math.sin(12382) + Math.cos(12383) * 63;
+acc += Math.sin(12383) + Math.cos(12384) * 64;
+acc += Math.sin(12384) + Math.cos(12385) * 65;
+acc += Math.sin(12385) + Math.cos(12386) * 66;
+acc += Math.sin(12386) + Math.cos(12387) * 67;
+acc += Math.sin(12387) + Math.cos(12388) * 68;
+acc += Math.sin(12388) + Math.cos(12389) * 69;
+acc += Math.sin(12389) + Math.cos(12390) * 70;
+acc += Math.sin(12390) + Math.cos(12391) * 71;
+acc += Math.sin(12391) + Math.cos(12392) * 72;
+acc += Math.sin(12392) + Math.cos(12393) * 73;
+acc += Math.sin(12393) + Math.cos(12394) * 74;
+acc += Math.sin(12394) + Math.cos(12395) * 75;
+acc += Math.sin(12395) + Math.cos(12396) * 76;
+acc += Math.sin(12396) + Math.cos(12397) * 77;
+acc += Math.sin(12397) + Math.cos(12398) * 78;
+acc += Math.sin(12398) + Math.cos(12399) * 79;
+acc += Math.sin(12399) + Math.cos(12400) * 80;
+acc += Math.sin(12400) + Math.cos(12401) * 81;
+acc += Math.sin(12401) + Math.cos(12402) * 82;
+acc += Math.sin(12402) + Math.cos(12403) * 83;
+acc += Math.sin(12403) + Math.cos(12404) * 84;
+acc += Math.sin(12404) + Math.cos(12405) * 85;
+acc += Math.sin(12405) + Math.cos(12406) * 86;
+acc += Math.sin(12406) + Math.cos(12407) * 87;
+acc += Math.sin(12407) + Math.cos(12408) * 88;
+acc += Math.sin(12408) + Math.cos(12409) * 89;
+acc += Math.sin(12409) + Math.cos(12410) * 90;
+acc += Math.sin(12410) + Math.cos(12411) * 91;
+acc += Math.sin(12411) + Math.cos(12412) * 92;
+acc += Math.sin(12412) + Math.cos(12413) * 93;
+acc += Math.sin(12413) + Math.cos(12414) * 94;
+acc += Math.sin(12414) + Math.cos(12415) * 95;
+acc += Math.sin(12415) + Math.cos(12416) * 96;
+acc += Math.sin(12416) + Math.cos(12417) * 0;
+acc += Math.sin(12417) + Math.cos(12418) * 1;
+acc += Math.sin(12418) + Math.cos(12419) * 2;
+acc += Math.sin(12419) + Math.cos(12420) * 3;
+acc += Math.sin(12420) + Math.cos(12421) * 4;
+acc += Math.sin(12421) + Math.cos(12422) * 5;
+acc += Math.sin(12422) + Math.cos(12423) * 6;
+acc += Math.sin(12423) + Math.cos(12424) * 7;
+acc += Math.sin(12424) + Math.cos(12425) * 8;
+acc += Math.sin(12425) + Math.cos(12426) * 9;
+acc += Math.sin(12426) + Math.cos(12427) * 10;
+acc += Math.sin(12427) + Math.cos(12428) * 11;
+acc += Math.sin(12428) + Math.cos(12429) * 12;
+acc += Math.sin(12429) + Math.cos(12430) * 13;
+acc += Math.sin(12430) + Math.cos(12431) * 14;
+acc += Math.sin(12431) + Math.cos(12432) * 15;
+acc += Math.sin(12432) + Math.cos(12433) * 16;
+acc += Math.sin(12433) + Math.cos(12434) * 17;
+acc += Math.sin(12434) + Math.cos(12435) * 18;
+acc += Math.sin(12435) + Math.cos(12436) * 19;
+acc += Math.sin(12436) + Math.cos(12437) * 20;
+acc += Math.sin(12437) + Math.cos(12438) * 21;
+acc += Math.sin(12438) + Math.cos(12439) * 22;
+acc += Math.sin(12439) + Math.cos(12440) * 23;
+acc += Math.sin(12440) + Math.cos(12441) * 24;
+acc += Math.sin(12441) + Math.cos(12442) * 25;
+acc += Math.sin(12442) + Math.cos(12443) * 26;
+acc += Math.sin(12443) + Math.cos(12444) * 27;
+acc += Math.sin(12444) + Math.cos(12445) * 28;
+acc += Math.sin(12445) + Math.cos(12446) * 29;
+acc += Math.sin(12446) + Math.cos(12447) * 30;
+acc += Math.sin(12447) + Math.cos(12448) * 31;
+acc += Math.sin(12448) + Math.cos(12449) * 32;
+acc += Math.sin(12449) + Math.cos(12450) * 33;
+acc += Math.sin(12450) + Math.cos(12451) * 34;
+acc += Math.sin(12451) + Math.cos(12452) * 35;
+acc += Math.sin(12452) + Math.cos(12453) * 36;
+acc += Math.sin(12453) + Math.cos(12454) * 37;
+acc += Math.sin(12454) + Math.cos(12455) * 38;
+acc += Math.sin(12455) + Math.cos(12456) * 39;
+acc += Math.sin(12456) + Math.cos(12457) * 40;
+acc += Math.sin(12457) + Math.cos(12458) * 41;
+acc += Math.sin(12458) + Math.cos(12459) * 42;
+acc += Math.sin(12459) + Math.cos(12460) * 43;
+acc += Math.sin(12460) + Math.cos(12461) * 44;
+acc += Math.sin(12461) + Math.cos(12462) * 45;
+acc += Math.sin(12462) + Math.cos(12463) * 46;
+acc += Math.sin(12463) + Math.cos(12464) * 47;
+acc += Math.sin(12464) + Math.cos(12465) * 48;
+acc += Math.sin(12465) + Math.cos(12466) * 49;
+acc += Math.sin(12466) + Math.cos(12467) * 50;
+acc += Math.sin(12467) + Math.cos(12468) * 51;
+acc += Math.sin(12468) + Math.cos(12469) * 52;
+acc += Math.sin(12469) + Math.cos(12470) * 53;
+acc += Math.sin(12470) + Math.cos(12471) * 54;
+acc += Math.sin(12471) + Math.cos(12472) * 55;
+acc += Math.sin(12472) + Math.cos(12473) * 56;
+acc += Math.sin(12473) + Math.cos(12474) * 57;
+acc += Math.sin(12474) + Math.cos(12475) * 58;
+acc += Math.sin(12475) + Math.cos(12476) * 59;
+acc += Math.sin(12476) + Math.cos(12477) * 60;
+acc += Math.sin(12477) + Math.cos(12478) * 61;
+acc += Math.sin(12478) + Math.cos(12479) * 62;
+acc += Math.sin(12479) + Math.cos(12480) * 63;
+acc += Math.sin(12480) + Math.cos(12481) * 64;
+acc += Math.sin(12481) + Math.cos(12482) * 65;
+acc += Math.sin(12482) + Math.cos(12483) * 66;
+acc += Math.sin(12483) + Math.cos(12484) * 67;
+acc += Math.sin(12484) + Math.cos(12485) * 68;
+acc += Math.sin(12485) + Math.cos(12486) * 69;
+acc += Math.sin(12486) + Math.cos(12487) * 70;
+acc += Math.sin(12487) + Math.cos(12488) * 71;
+acc += Math.sin(12488) + Math.cos(12489) * 72;
+acc += Math.sin(12489) + Math.cos(12490) * 73;
+acc += Math.sin(12490) + Math.cos(12491) * 74;
+acc += Math.sin(12491) + Math.cos(12492) * 75;
+acc += Math.sin(12492) + Math.cos(12493) * 76;
+acc += Math.sin(12493) + Math.cos(12494) * 77;
+acc += Math.sin(12494) + Math.cos(12495) * 78;
+acc += Math.sin(12495) + Math.cos(12496) * 79;
+acc += Math.sin(12496) + Math.cos(12497) * 80;
+acc += Math.sin(12497) + Math.cos(12498) * 81;
+acc += Math.sin(12498) + Math.cos(12499) * 82;
+acc += Math.sin(12499) + Math.cos(12500) * 83;
+acc += Math.sin(12500) + Math.cos(12501) * 84;
+acc += Math.sin(12501) + Math.cos(12502) * 85;
+acc += Math.sin(12502) + Math.cos(12503) * 86;
+acc += Math.sin(12503) + Math.cos(12504) * 87;
+acc += Math.sin(12504) + Math.cos(12505) * 88;
+acc += Math.sin(12505) + Math.cos(12506) * 89;
+acc += Math.sin(12506) + Math.cos(12507) * 90;
+acc += Math.sin(12507) + Math.cos(12508) * 91;
+acc += Math.sin(12508) + Math.cos(12509) * 92;
+acc += Math.sin(12509) + Math.cos(12510) * 93;
+acc += Math.sin(12510) + Math.cos(12511) * 94;
+acc += Math.sin(12511) + Math.cos(12512) * 95;
+acc += Math.sin(12512) + Math.cos(12513) * 96;
+acc += Math.sin(12513) + Math.cos(12514) * 0;
+acc += Math.sin(12514) + Math.cos(12515) * 1;
+acc += Math.sin(12515) + Math.cos(12516) * 2;
+acc += Math.sin(12516) + Math.cos(12517) * 3;
+acc += Math.sin(12517) + Math.cos(12518) * 4;
+acc += Math.sin(12518) + Math.cos(12519) * 5;
+acc += Math.sin(12519) + Math.cos(12520) * 6;
+acc += Math.sin(12520) + Math.cos(12521) * 7;
+acc += Math.sin(12521) + Math.cos(12522) * 8;
+acc += Math.sin(12522) + Math.cos(12523) * 9;
+acc += Math.sin(12523) + Math.cos(12524) * 10;
+acc += Math.sin(12524) + Math.cos(12525) * 11;
+acc += Math.sin(12525) + Math.cos(12526) * 12;
+acc += Math.sin(12526) + Math.cos(12527) * 13;
+acc += Math.sin(12527) + Math.cos(12528) * 14;
+acc += Math.sin(12528) + Math.cos(12529) * 15;
+acc += Math.sin(12529) + Math.cos(12530) * 16;
+acc += Math.sin(12530) + Math.cos(12531) * 17;
+acc += Math.sin(12531) + Math.cos(12532) * 18;
+acc += Math.sin(12532) + Math.cos(12533) * 19;
+acc += Math.sin(12533) + Math.cos(12534) * 20;
+acc += Math.sin(12534) + Math.cos(12535) * 21;
+acc += Math.sin(12535) + Math.cos(12536) * 22;
+acc += Math.sin(12536) + Math.cos(12537) * 23;
+acc += Math.sin(12537) + Math.cos(12538) * 24;
+acc += Math.sin(12538) + Math.cos(12539) * 25;
+acc += Math.sin(12539) + Math.cos(12540) * 26;
+acc += Math.sin(12540) + Math.cos(12541) * 27;
+acc += Math.sin(12541) + Math.cos(12542) * 28;
+acc += Math.sin(12542) + Math.cos(12543) * 29;
+acc += Math.sin(12543) + Math.cos(12544) * 30;
+acc += Math.sin(12544) + Math.cos(12545) * 31;
+acc += Math.sin(12545) + Math.cos(12546) * 32;
+acc += Math.sin(12546) + Math.cos(12547) * 33;
+acc += Math.sin(12547) + Math.cos(12548) * 34;
+acc += Math.sin(12548) + Math.cos(12549) * 35;
+acc += Math.sin(12549) + Math.cos(12550) * 36;
+acc += Math.sin(12550) + Math.cos(12551) * 37;
+acc += Math.sin(12551) + Math.cos(12552) * 38;
+acc += Math.sin(12552) + Math.cos(12553) * 39;
+acc += Math.sin(12553) + Math.cos(12554) * 40;
+acc += Math.sin(12554) + Math.cos(12555) * 41;
+acc += Math.sin(12555) + Math.cos(12556) * 42;
+acc += Math.sin(12556) + Math.cos(12557) * 43;
+acc += Math.sin(12557) + Math.cos(12558) * 44;
+acc += Math.sin(12558) + Math.cos(12559) * 45;
+acc += Math.sin(12559) + Math.cos(12560) * 46;
+acc += Math.sin(12560) + Math.cos(12561) * 47;
+acc += Math.sin(12561) + Math.cos(12562) * 48;
+acc += Math.sin(12562) + Math.cos(12563) * 49;
+acc += Math.sin(12563) + Math.cos(12564) * 50;
+acc += Math.sin(12564) + Math.cos(12565) * 51;
+acc += Math.sin(12565) + Math.cos(12566) * 52;
+acc += Math.sin(12566) + Math.cos(12567) * 53;
+acc += Math.sin(12567) + Math.cos(12568) * 54;
+acc += Math.sin(12568) + Math.cos(12569) * 55;
+acc += Math.sin(12569) + Math.cos(12570) * 56;
+acc += Math.sin(12570) + Math.cos(12571) * 57;
+acc += Math.sin(12571) + Math.cos(12572) * 58;
+acc += Math.sin(12572) + Math.cos(12573) * 59;
+acc += Math.sin(12573) + Math.cos(12574) * 60;
+acc += Math.sin(12574) + Math.cos(12575) * 61;
+acc += Math.sin(12575) + Math.cos(12576) * 62;
+acc += Math.sin(12576) + Math.cos(12577) * 63;
+acc += Math.sin(12577) + Math.cos(12578) * 64;
+acc += Math.sin(12578) + Math.cos(12579) * 65;
+acc += Math.sin(12579) + Math.cos(12580) * 66;
+acc += Math.sin(12580) + Math.cos(12581) * 67;
+acc += Math.sin(12581) + Math.cos(12582) * 68;
+acc += Math.sin(12582) + Math.cos(12583) * 69;
+acc += Math.sin(12583) + Math.cos(12584) * 70;
+acc += Math.sin(12584) + Math.cos(12585) * 71;
+acc += Math.sin(12585) + Math.cos(12586) * 72;
+acc += Math.sin(12586) + Math.cos(12587) * 73;
+acc += Math.sin(12587) + Math.cos(12588) * 74;
+acc += Math.sin(12588) + Math.cos(12589) * 75;
+acc += Math.sin(12589) + Math.cos(12590) * 76;
+acc += Math.sin(12590) + Math.cos(12591) * 77;
+acc += Math.sin(12591) + Math.cos(12592) * 78;
+acc += Math.sin(12592) + Math.cos(12593) * 79;
+acc += Math.sin(12593) + Math.cos(12594) * 80;
+acc += Math.sin(12594) + Math.cos(12595) * 81;
+acc += Math.sin(12595) + Math.cos(12596) * 82;
+acc += Math.sin(12596) + Math.cos(12597) * 83;
+acc += Math.sin(12597) + Math.cos(12598) * 84;
+acc += Math.sin(12598) + Math.cos(12599) * 85;
+acc += Math.sin(12599) + Math.cos(12600) * 86;
+acc += Math.sin(12600) + Math.cos(12601) * 87;
+acc += Math.sin(12601) + Math.cos(12602) * 88;
+acc += Math.sin(12602) + Math.cos(12603) * 89;
+acc += Math.sin(12603) + Math.cos(12604) * 90;
+acc += Math.sin(12604) + Math.cos(12605) * 91;
+acc += Math.sin(12605) + Math.cos(12606) * 92;
+acc += Math.sin(12606) + Math.cos(12607) * 93;
+acc += Math.sin(12607) + Math.cos(12608) * 94;
+acc += Math.sin(12608) + Math.cos(12609) * 95;
+acc += Math.sin(12609) + Math.cos(12610) * 96;
+acc += Math.sin(12610) + Math.cos(12611) * 0;
+acc += Math.sin(12611) + Math.cos(12612) * 1;
+acc += Math.sin(12612) + Math.cos(12613) * 2;
+acc += Math.sin(12613) + Math.cos(12614) * 3;
+acc += Math.sin(12614) + Math.cos(12615) * 4;
+acc += Math.sin(12615) + Math.cos(12616) * 5;
+acc += Math.sin(12616) + Math.cos(12617) * 6;
+acc += Math.sin(12617) + Math.cos(12618) * 7;
+acc += Math.sin(12618) + Math.cos(12619) * 8;
+acc += Math.sin(12619) + Math.cos(12620) * 9;
+acc += Math.sin(12620) + Math.cos(12621) * 10;
+acc += Math.sin(12621) + Math.cos(12622) * 11;
+acc += Math.sin(12622) + Math.cos(12623) * 12;
+acc += Math.sin(12623) + Math.cos(12624) * 13;
+acc += Math.sin(12624) + Math.cos(12625) * 14;
+acc += Math.sin(12625) + Math.cos(12626) * 15;
+acc += Math.sin(12626) + Math.cos(12627) * 16;
+acc += Math.sin(12627) + Math.cos(12628) * 17;
+acc += Math.sin(12628) + Math.cos(12629) * 18;
+acc += Math.sin(12629) + Math.cos(12630) * 19;
+acc += Math.sin(12630) + Math.cos(12631) * 20;
+acc += Math.sin(12631) + Math.cos(12632) * 21;
+acc += Math.sin(12632) + Math.cos(12633) * 22;
+acc += Math.sin(12633) + Math.cos(12634) * 23;
+acc += Math.sin(12634) + Math.cos(12635) * 24;
+acc += Math.sin(12635) + Math.cos(12636) * 25;
+acc += Math.sin(12636) + Math.cos(12637) * 26;
+acc += Math.sin(12637) + Math.cos(12638) * 27;
+acc += Math.sin(12638) + Math.cos(12639) * 28;
+acc += Math.sin(12639) + Math.cos(12640) * 29;
+acc += Math.sin(12640) + Math.cos(12641) * 30;
+acc += Math.sin(12641) + Math.cos(12642) * 31;
+acc += Math.sin(12642) + Math.cos(12643) * 32;
+acc += Math.sin(12643) + Math.cos(12644) * 33;
+acc += Math.sin(12644) + Math.cos(12645) * 34;
+acc += Math.sin(12645) + Math.cos(12646) * 35;
+acc += Math.sin(12646) + Math.cos(12647) * 36;
+acc += Math.sin(12647) + Math.cos(12648) * 37;
+acc += Math.sin(12648) + Math.cos(12649) * 38;
+acc += Math.sin(12649) + Math.cos(12650) * 39;
+acc += Math.sin(12650) + Math.cos(12651) * 40;
+acc += Math.sin(12651) + Math.cos(12652) * 41;
+acc += Math.sin(12652) + Math.cos(12653) * 42;
+acc += Math.sin(12653) + Math.cos(12654) * 43;
+acc += Math.sin(12654) + Math.cos(12655) * 44;
+acc += Math.sin(12655) + Math.cos(12656) * 45;
+acc += Math.sin(12656) + Math.cos(12657) * 46;
+acc += Math.sin(12657) + Math.cos(12658) * 47;
+acc += Math.sin(12658) + Math.cos(12659) * 48;
+acc += Math.sin(12659) + Math.cos(12660) * 49;
+acc += Math.sin(12660) + Math.cos(12661) * 50;
+acc += Math.sin(12661) + Math.cos(12662) * 51;
+acc += Math.sin(12662) + Math.cos(12663) * 52;
+acc += Math.sin(12663) + Math.cos(12664) * 53;
+acc += Math.sin(12664) + Math.cos(12665) * 54;
+acc += Math.sin(12665) + Math.cos(12666) * 55;
+acc += Math.sin(12666) + Math.cos(12667) * 56;
+acc += Math.sin(12667) + Math.cos(12668) * 57;
+acc += Math.sin(12668) + Math.cos(12669) * 58;
+acc += Math.sin(12669) + Math.cos(12670) * 59;
+acc += Math.sin(12670) + Math.cos(12671) * 60;
+acc += Math.sin(12671) + Math.cos(12672) * 61;
+acc += Math.sin(12672) + Math.cos(12673) * 62;
+acc += Math.sin(12673) + Math.cos(12674) * 63;
+acc += Math.sin(12674) + Math.cos(12675) * 64;
+acc += Math.sin(12675) + Math.cos(12676) * 65;
+acc += Math.sin(12676) + Math.cos(12677) * 66;
+acc += Math.sin(12677) + Math.cos(12678) * 67;
+acc += Math.sin(12678) + Math.cos(12679) * 68;
+acc += Math.sin(12679) + Math.cos(12680) * 69;
+acc += Math.sin(12680) + Math.cos(12681) * 70;
+acc += Math.sin(12681) + Math.cos(12682) * 71;
+acc += Math.sin(12682) + Math.cos(12683) * 72;
+acc += Math.sin(12683) + Math.cos(12684) * 73;
+acc += Math.sin(12684) + Math.cos(12685) * 74;
+acc += Math.sin(12685) + Math.cos(12686) * 75;
+acc += Math.sin(12686) + Math.cos(12687) * 76;
+acc += Math.sin(12687) + Math.cos(12688) * 77;
+acc += Math.sin(12688) + Math.cos(12689) * 78;
+acc += Math.sin(12689) + Math.cos(12690) * 79;
+acc += Math.sin(12690) + Math.cos(12691) * 80;
+acc += Math.sin(12691) + Math.cos(12692) * 81;
+acc += Math.sin(12692) + Math.cos(12693) * 82;
+acc += Math.sin(12693) + Math.cos(12694) * 83;
+acc += Math.sin(12694) + Math.cos(12695) * 84;
+acc += Math.sin(12695) + Math.cos(12696) * 85;
+acc += Math.sin(12696) + Math.cos(12697) * 86;
+acc += Math.sin(12697) + Math.cos(12698) * 87;
+acc += Math.sin(12698) + Math.cos(12699) * 88;
+acc += Math.sin(12699) + Math.cos(12700) * 89;
+acc += Math.sin(12700) + Math.cos(12701) * 90;
+acc += Math.sin(12701) + Math.cos(12702) * 91;
+acc += Math.sin(12702) + Math.cos(12703) * 92;
+acc += Math.sin(12703) + Math.cos(12704) * 93;
+acc += Math.sin(12704) + Math.cos(12705) * 94;
+acc += Math.sin(12705) + Math.cos(12706) * 95;
+acc += Math.sin(12706) + Math.cos(12707) * 96;
+acc += Math.sin(12707) + Math.cos(12708) * 0;
+acc += Math.sin(12708) + Math.cos(12709) * 1;
+acc += Math.sin(12709) + Math.cos(12710) * 2;
+acc += Math.sin(12710) + Math.cos(12711) * 3;
+acc += Math.sin(12711) + Math.cos(12712) * 4;
+acc += Math.sin(12712) + Math.cos(12713) * 5;
+acc += Math.sin(12713) + Math.cos(12714) * 6;
+acc += Math.sin(12714) + Math.cos(12715) * 7;
+acc += Math.sin(12715) + Math.cos(12716) * 8;
+acc += Math.sin(12716) + Math.cos(12717) * 9;
+acc += Math.sin(12717) + Math.cos(12718) * 10;
+acc += Math.sin(12718) + Math.cos(12719) * 11;
+acc += Math.sin(12719) + Math.cos(12720) * 12;
+acc += Math.sin(12720) + Math.cos(12721) * 13;
+acc += Math.sin(12721) + Math.cos(12722) * 14;
+acc += Math.sin(12722) + Math.cos(12723) * 15;
+acc += Math.sin(12723) + Math.cos(12724) * 16;
+acc += Math.sin(12724) + Math.cos(12725) * 17;
+acc += Math.sin(12725) + Math.cos(12726) * 18;
+acc += Math.sin(12726) + Math.cos(12727) * 19;
+acc += Math.sin(12727) + Math.cos(12728) * 20;
+acc += Math.sin(12728) + Math.cos(12729) * 21;
+acc += Math.sin(12729) + Math.cos(12730) * 22;
+acc += Math.sin(12730) + Math.cos(12731) * 23;
+acc += Math.sin(12731) + Math.cos(12732) * 24;
+acc += Math.sin(12732) + Math.cos(12733) * 25;
+acc += Math.sin(12733) + Math.cos(12734) * 26;
+acc += Math.sin(12734) + Math.cos(12735) * 27;
+acc += Math.sin(12735) + Math.cos(12736) * 28;
+acc += Math.sin(12736) + Math.cos(12737) * 29;
+acc += Math.sin(12737) + Math.cos(12738) * 30;
+acc += Math.sin(12738) + Math.cos(12739) * 31;
+acc += Math.sin(12739) + Math.cos(12740) * 32;
+acc += Math.sin(12740) + Math.cos(12741) * 33;
+acc += Math.sin(12741) + Math.cos(12742) * 34;
+acc += Math.sin(12742) + Math.cos(12743) * 35;
+acc += Math.sin(12743) + Math.cos(12744) * 36;
+acc += Math.sin(12744) + Math.cos(12745) * 37;
+acc += Math.sin(12745) + Math.cos(12746) * 38;
+acc += Math.sin(12746) + Math.cos(12747) * 39;
+acc += Math.sin(12747) + Math.cos(12748) * 40;
+acc += Math.sin(12748) + Math.cos(12749) * 41;
+acc += Math.sin(12749) + Math.cos(12750) * 42;
+acc += Math.sin(12750) + Math.cos(12751) * 43;
+acc += Math.sin(12751) + Math.cos(12752) * 44;
+acc += Math.sin(12752) + Math.cos(12753) * 45;
+acc += Math.sin(12753) + Math.cos(12754) * 46;
+acc += Math.sin(12754) + Math.cos(12755) * 47;
+acc += Math.sin(12755) + Math.cos(12756) * 48;
+acc += Math.sin(12756) + Math.cos(12757) * 49;
+acc += Math.sin(12757) + Math.cos(12758) * 50;
+acc += Math.sin(12758) + Math.cos(12759) * 51;
+acc += Math.sin(12759) + Math.cos(12760) * 52;
+acc += Math.sin(12760) + Math.cos(12761) * 53;
+acc += Math.sin(12761) + Math.cos(12762) * 54;
+acc += Math.sin(12762) + Math.cos(12763) * 55;
+acc += Math.sin(12763) + Math.cos(12764) * 56;
+acc += Math.sin(12764) + Math.cos(12765) * 57;
+acc += Math.sin(12765) + Math.cos(12766) * 58;
+acc += Math.sin(12766) + Math.cos(12767) * 59;
+acc += Math.sin(12767) + Math.cos(12768) * 60;
+acc += Math.sin(12768) + Math.cos(12769) * 61;
+acc += Math.sin(12769) + Math.cos(12770) * 62;
+acc += Math.sin(12770) + Math.cos(12771) * 63;
+acc += Math.sin(12771) + Math.cos(12772) * 64;
+acc += Math.sin(12772) + Math.cos(12773) * 65;
+acc += Math.sin(12773) + Math.cos(12774) * 66;
+acc += Math.sin(12774) + Math.cos(12775) * 67;
+acc += Math.sin(12775) + Math.cos(12776) * 68;
+acc += Math.sin(12776) + Math.cos(12777) * 69;
+acc += Math.sin(12777) + Math.cos(12778) * 70;
+acc += Math.sin(12778) + Math.cos(12779) * 71;
+acc += Math.sin(12779) + Math.cos(12780) * 72;
+acc += Math.sin(12780) + Math.cos(12781) * 73;
+acc += Math.sin(12781) + Math.cos(12782) * 74;
+acc += Math.sin(12782) + Math.cos(12783) * 75;
+acc += Math.sin(12783) + Math.cos(12784) * 76;
+acc += Math.sin(12784) + Math.cos(12785) * 77;
+acc += Math.sin(12785) + Math.cos(12786) * 78;
+acc += Math.sin(12786) + Math.cos(12787) * 79;
+acc += Math.sin(12787) + Math.cos(12788) * 80;
+acc += Math.sin(12788) + Math.cos(12789) * 81;
+acc += Math.sin(12789) + Math.cos(12790) * 82;
+acc += Math.sin(12790) + Math.cos(12791) * 83;
+acc += Math.sin(12791) + Math.cos(12792) * 84;
+acc += Math.sin(12792) + Math.cos(12793) * 85;
+acc += Math.sin(12793) + Math.cos(12794) * 86;
+acc += Math.sin(12794) + Math.cos(12795) * 87;
+acc += Math.sin(12795) + Math.cos(12796) * 88;
+acc += Math.sin(12796) + Math.cos(12797) * 89;
+acc += Math.sin(12797) + Math.cos(12798) * 90;
+acc += Math.sin(12798) + Math.cos(12799) * 91;
+acc += Math.sin(12799) + Math.cos(12800) * 92;
+acc += Math.sin(12800) + Math.cos(12801) * 93;
+acc += Math.sin(12801) + Math.cos(12802) * 94;
+acc += Math.sin(12802) + Math.cos(12803) * 95;
+acc += Math.sin(12803) + Math.cos(12804) * 96;
+acc += Math.sin(12804) + Math.cos(12805) * 0;
+acc += Math.sin(12805) + Math.cos(12806) * 1;
+acc += Math.sin(12806) + Math.cos(12807) * 2;
+acc += Math.sin(12807) + Math.cos(12808) * 3;
+acc += Math.sin(12808) + Math.cos(12809) * 4;
+acc += Math.sin(12809) + Math.cos(12810) * 5;
+acc += Math.sin(12810) + Math.cos(12811) * 6;
+acc += Math.sin(12811) + Math.cos(12812) * 7;
+acc += Math.sin(12812) + Math.cos(12813) * 8;
+acc += Math.sin(12813) + Math.cos(12814) * 9;
+acc += Math.sin(12814) + Math.cos(12815) * 10;
+acc += Math.sin(12815) + Math.cos(12816) * 11;
+acc += Math.sin(12816) + Math.cos(12817) * 12;
+acc += Math.sin(12817) + Math.cos(12818) * 13;
+acc += Math.sin(12818) + Math.cos(12819) * 14;
+acc += Math.sin(12819) + Math.cos(12820) * 15;
+acc += Math.sin(12820) + Math.cos(12821) * 16;
+acc += Math.sin(12821) + Math.cos(12822) * 17;
+acc += Math.sin(12822) + Math.cos(12823) * 18;
+acc += Math.sin(12823) + Math.cos(12824) * 19;
+acc += Math.sin(12824) + Math.cos(12825) * 20;
+acc += Math.sin(12825) + Math.cos(12826) * 21;
+acc += Math.sin(12826) + Math.cos(12827) * 22;
+acc += Math.sin(12827) + Math.cos(12828) * 23;
+acc += Math.sin(12828) + Math.cos(12829) * 24;
+acc += Math.sin(12829) + Math.cos(12830) * 25;
+acc += Math.sin(12830) + Math.cos(12831) * 26;
+acc += Math.sin(12831) + Math.cos(12832) * 27;
+acc += Math.sin(12832) + Math.cos(12833) * 28;
+acc += Math.sin(12833) + Math.cos(12834) * 29;
+acc += Math.sin(12834) + Math.cos(12835) * 30;
+acc += Math.sin(12835) + Math.cos(12836) * 31;
+acc += Math.sin(12836) + Math.cos(12837) * 32;
+acc += Math.sin(12837) + Math.cos(12838) * 33;
+acc += Math.sin(12838) + Math.cos(12839) * 34;
+acc += Math.sin(12839) + Math.cos(12840) * 35;
+acc += Math.sin(12840) + Math.cos(12841) * 36;
+acc += Math.sin(12841) + Math.cos(12842) * 37;
+acc += Math.sin(12842) + Math.cos(12843) * 38;
+acc += Math.sin(12843) + Math.cos(12844) * 39;
+acc += Math.sin(12844) + Math.cos(12845) * 40;
+acc += Math.sin(12845) + Math.cos(12846) * 41;
+acc += Math.sin(12846) + Math.cos(12847) * 42;
+acc += Math.sin(12847) + Math.cos(12848) * 43;
+acc += Math.sin(12848) + Math.cos(12849) * 44;
+acc += Math.sin(12849) + Math.cos(12850) * 45;
+acc += Math.sin(12850) + Math.cos(12851) * 46;
+acc += Math.sin(12851) + Math.cos(12852) * 47;
+acc += Math.sin(12852) + Math.cos(12853) * 48;
+acc += Math.sin(12853) + Math.cos(12854) * 49;
+acc += Math.sin(12854) + Math.cos(12855) * 50;
+acc += Math.sin(12855) + Math.cos(12856) * 51;
+acc += Math.sin(12856) + Math.cos(12857) * 52;
+acc += Math.sin(12857) + Math.cos(12858) * 53;
+acc += Math.sin(12858) + Math.cos(12859) * 54;
+acc += Math.sin(12859) + Math.cos(12860) * 55;
+acc += Math.sin(12860) + Math.cos(12861) * 56;
+acc += Math.sin(12861) + Math.cos(12862) * 57;
+acc += Math.sin(12862) + Math.cos(12863) * 58;
+acc += Math.sin(12863) + Math.cos(12864) * 59;
+acc += Math.sin(12864) + Math.cos(12865) * 60;
+acc += Math.sin(12865) + Math.cos(12866) * 61;
+acc += Math.sin(12866) + Math.cos(12867) * 62;
+acc += Math.sin(12867) + Math.cos(12868) * 63;
+acc += Math.sin(12868) + Math.cos(12869) * 64;
+acc += Math.sin(12869) + Math.cos(12870) * 65;
+acc += Math.sin(12870) + Math.cos(12871) * 66;
+acc += Math.sin(12871) + Math.cos(12872) * 67;
+acc += Math.sin(12872) + Math.cos(12873) * 68;
+acc += Math.sin(12873) + Math.cos(12874) * 69;
+acc += Math.sin(12874) + Math.cos(12875) * 70;
+acc += Math.sin(12875) + Math.cos(12876) * 71;
+acc += Math.sin(12876) + Math.cos(12877) * 72;
+acc += Math.sin(12877) + Math.cos(12878) * 73;
+acc += Math.sin(12878) + Math.cos(12879) * 74;
+acc += Math.sin(12879) + Math.cos(12880) * 75;
+acc += Math.sin(12880) + Math.cos(12881) * 76;
+acc += Math.sin(12881) + Math.cos(12882) * 77;
+acc += Math.sin(12882) + Math.cos(12883) * 78;
+acc += Math.sin(12883) + Math.cos(12884) * 79;
+acc += Math.sin(12884) + Math.cos(12885) * 80;
+acc += Math.sin(12885) + Math.cos(12886) * 81;
+acc += Math.sin(12886) + Math.cos(12887) * 82;
+acc += Math.sin(12887) + Math.cos(12888) * 83;
+acc += Math.sin(12888) + Math.cos(12889) * 84;
+acc += Math.sin(12889) + Math.cos(12890) * 85;
+acc += Math.sin(12890) + Math.cos(12891) * 86;
+acc += Math.sin(12891) + Math.cos(12892) * 87;
+acc += Math.sin(12892) + Math.cos(12893) * 88;
+acc += Math.sin(12893) + Math.cos(12894) * 89;
+acc += Math.sin(12894) + Math.cos(12895) * 90;
+acc += Math.sin(12895) + Math.cos(12896) * 91;
+acc += Math.sin(12896) + Math.cos(12897) * 92;
+acc += Math.sin(12897) + Math.cos(12898) * 93;
+acc += Math.sin(12898) + Math.cos(12899) * 94;
+acc += Math.sin(12899) + Math.cos(12900) * 95;
+acc += Math.sin(12900) + Math.cos(12901) * 96;
+acc += Math.sin(12901) + Math.cos(12902) * 0;
+acc += Math.sin(12902) + Math.cos(12903) * 1;
+acc += Math.sin(12903) + Math.cos(12904) * 2;
+acc += Math.sin(12904) + Math.cos(12905) * 3;
+acc += Math.sin(12905) + Math.cos(12906) * 4;
+acc += Math.sin(12906) + Math.cos(12907) * 5;
+acc += Math.sin(12907) + Math.cos(12908) * 6;
+acc += Math.sin(12908) + Math.cos(12909) * 7;
+acc += Math.sin(12909) + Math.cos(12910) * 8;
+acc += Math.sin(12910) + Math.cos(12911) * 9;
+acc += Math.sin(12911) + Math.cos(12912) * 10;
+acc += Math.sin(12912) + Math.cos(12913) * 11;
+acc += Math.sin(12913) + Math.cos(12914) * 12;
+acc += Math.sin(12914) + Math.cos(12915) * 13;
+acc += Math.sin(12915) + Math.cos(12916) * 14;
+acc += Math.sin(12916) + Math.cos(12917) * 15;
+acc += Math.sin(12917) + Math.cos(12918) * 16;
+acc += Math.sin(12918) + Math.cos(12919) * 17;
+acc += Math.sin(12919) + Math.cos(12920) * 18;
+acc += Math.sin(12920) + Math.cos(12921) * 19;
+acc += Math.sin(12921) + Math.cos(12922) * 20;
+acc += Math.sin(12922) + Math.cos(12923) * 21;
+acc += Math.sin(12923) + Math.cos(12924) * 22;
+acc += Math.sin(12924) + Math.cos(12925) * 23;
+acc += Math.sin(12925) + Math.cos(12926) * 24;
+acc += Math.sin(12926) + Math.cos(12927) * 25;
+acc += Math.sin(12927) + Math.cos(12928) * 26;
+acc += Math.sin(12928) + Math.cos(12929) * 27;
+acc += Math.sin(12929) + Math.cos(12930) * 28;
+acc += Math.sin(12930) + Math.cos(12931) * 29;
+acc += Math.sin(12931) + Math.cos(12932) * 30;
+acc += Math.sin(12932) + Math.cos(12933) * 31;
+acc += Math.sin(12933) + Math.cos(12934) * 32;
+acc += Math.sin(12934) + Math.cos(12935) * 33;
+acc += Math.sin(12935) + Math.cos(12936) * 34;
+acc += Math.sin(12936) + Math.cos(12937) * 35;
+acc += Math.sin(12937) + Math.cos(12938) * 36;
+acc += Math.sin(12938) + Math.cos(12939) * 37;
+acc += Math.sin(12939) + Math.cos(12940) * 38;
+acc += Math.sin(12940) + Math.cos(12941) * 39;
+acc += Math.sin(12941) + Math.cos(12942) * 40;
+acc += Math.sin(12942) + Math.cos(12943) * 41;
+acc += Math.sin(12943) + Math.cos(12944) * 42;
+acc += Math.sin(12944) + Math.cos(12945) * 43;
+acc += Math.sin(12945) + Math.cos(12946) * 44;
+acc += Math.sin(12946) + Math.cos(12947) * 45;
+acc += Math.sin(12947) + Math.cos(12948) * 46;
+acc += Math.sin(12948) + Math.cos(12949) * 47;
+acc += Math.sin(12949) + Math.cos(12950) * 48;
+acc += Math.sin(12950) + Math.cos(12951) * 49;
+acc += Math.sin(12951) + Math.cos(12952) * 50;
+acc += Math.sin(12952) + Math.cos(12953) * 51;
+acc += Math.sin(12953) + Math.cos(12954) * 52;
+acc += Math.sin(12954) + Math.cos(12955) * 53;
+acc += Math.sin(12955) + Math.cos(12956) * 54;
+acc += Math.sin(12956) + Math.cos(12957) * 55;
+acc += Math.sin(12957) + Math.cos(12958) * 56;
+acc += Math.sin(12958) + Math.cos(12959) * 57;
+acc += Math.sin(12959) + Math.cos(12960) * 58;
+acc += Math.sin(12960) + Math.cos(12961) * 59;
+acc += Math.sin(12961) + Math.cos(12962) * 60;
+acc += Math.sin(12962) + Math.cos(12963) * 61;
+acc += Math.sin(12963) + Math.cos(12964) * 62;
+acc += Math.sin(12964) + Math.cos(12965) * 63;
+acc += Math.sin(12965) + Math.cos(12966) * 64;
+acc += Math.sin(12966) + Math.cos(12967) * 65;
+acc += Math.sin(12967) + Math.cos(12968) * 66;
+acc += Math.sin(12968) + Math.cos(12969) * 67;
+acc += Math.sin(12969) + Math.cos(12970) * 68;
+acc += Math.sin(12970) + Math.cos(12971) * 69;
+acc += Math.sin(12971) + Math.cos(12972) * 70;
+acc += Math.sin(12972) + Math.cos(12973) * 71;
+acc += Math.sin(12973) + Math.cos(12974) * 72;
+acc += Math.sin(12974) + Math.cos(12975) * 73;
+acc += Math.sin(12975) + Math.cos(12976) * 74;
+acc += Math.sin(12976) + Math.cos(12977) * 75;
+acc += Math.sin(12977) + Math.cos(12978) * 76;
+acc += Math.sin(12978) + Math.cos(12979) * 77;
+acc += Math.sin(12979) + Math.cos(12980) * 78;
+acc += Math.sin(12980) + Math.cos(12981) * 79;
+acc += Math.sin(12981) + Math.cos(12982) * 80;
+acc += Math.sin(12982) + Math.cos(12983) * 81;
+acc += Math.sin(12983) + Math.cos(12984) * 82;
+acc += Math.sin(12984) + Math.cos(12985) * 83;
+acc += Math.sin(12985) + Math.cos(12986) * 84;
+acc += Math.sin(12986) + Math.cos(12987) * 85;
+acc += Math.sin(12987) + Math.cos(12988) * 86;
+acc += Math.sin(12988) + Math.cos(12989) * 87;
+acc += Math.sin(12989) + Math.cos(12990) * 88;
+acc += Math.sin(12990) + Math.cos(12991) * 89;
+acc += Math.sin(12991) + Math.cos(12992) * 90;
+acc += Math.sin(12992) + Math.cos(12993) * 91;
+acc += Math.sin(12993) + Math.cos(12994) * 92;
+acc += Math.sin(12994) + Math.cos(12995) * 93;
+acc += Math.sin(12995) + Math.cos(12996) * 94;
+acc += Math.sin(12996) + Math.cos(12997) * 95;
+acc += Math.sin(12997) + Math.cos(12998) * 96;
+acc += Math.sin(12998) + Math.cos(12999) * 0;
+acc += Math.sin(12999) + Math.cos(13000) * 1;
+acc += Math.sin(13000) + Math.cos(13001) * 2;
+acc += Math.sin(13001) + Math.cos(13002) * 3;
+acc += Math.sin(13002) + Math.cos(13003) * 4;
+acc += Math.sin(13003) + Math.cos(13004) * 5;
+acc += Math.sin(13004) + Math.cos(13005) * 6;
+acc += Math.sin(13005) + Math.cos(13006) * 7;
+acc += Math.sin(13006) + Math.cos(13007) * 8;
+acc += Math.sin(13007) + Math.cos(13008) * 9;
+acc += Math.sin(13008) + Math.cos(13009) * 10;
+acc += Math.sin(13009) + Math.cos(13010) * 11;
+acc += Math.sin(13010) + Math.cos(13011) * 12;
+acc += Math.sin(13011) + Math.cos(13012) * 13;
+acc += Math.sin(13012) + Math.cos(13013) * 14;
+acc += Math.sin(13013) + Math.cos(13014) * 15;
+acc += Math.sin(13014) + Math.cos(13015) * 16;
+acc += Math.sin(13015) + Math.cos(13016) * 17;
+acc += Math.sin(13016) + Math.cos(13017) * 18;
+acc += Math.sin(13017) + Math.cos(13018) * 19;
+acc += Math.sin(13018) + Math.cos(13019) * 20;
+acc += Math.sin(13019) + Math.cos(13020) * 21;
+acc += Math.sin(13020) + Math.cos(13021) * 22;
+acc += Math.sin(13021) + Math.cos(13022) * 23;
+acc += Math.sin(13022) + Math.cos(13023) * 24;
+acc += Math.sin(13023) + Math.cos(13024) * 25;
+acc += Math.sin(13024) + Math.cos(13025) * 26;
+acc += Math.sin(13025) + Math.cos(13026) * 27;
+acc += Math.sin(13026) + Math.cos(13027) * 28;
+acc += Math.sin(13027) + Math.cos(13028) * 29;
+acc += Math.sin(13028) + Math.cos(13029) * 30;
+acc += Math.sin(13029) + Math.cos(13030) * 31;
+acc += Math.sin(13030) + Math.cos(13031) * 32;
+acc += Math.sin(13031) + Math.cos(13032) * 33;
+acc += Math.sin(13032) + Math.cos(13033) * 34;
+acc += Math.sin(13033) + Math.cos(13034) * 35;
+acc += Math.sin(13034) + Math.cos(13035) * 36;
+acc += Math.sin(13035) + Math.cos(13036) * 37;
+acc += Math.sin(13036) + Math.cos(13037) * 38;
+acc += Math.sin(13037) + Math.cos(13038) * 39;
+acc += Math.sin(13038) + Math.cos(13039) * 40;
+acc += Math.sin(13039) + Math.cos(13040) * 41;
+acc += Math.sin(13040) + Math.cos(13041) * 42;
+acc += Math.sin(13041) + Math.cos(13042) * 43;
+acc += Math.sin(13042) + Math.cos(13043) * 44;
+acc += Math.sin(13043) + Math.cos(13044) * 45;
+acc += Math.sin(13044) + Math.cos(13045) * 46;
+acc += Math.sin(13045) + Math.cos(13046) * 47;
+acc += Math.sin(13046) + Math.cos(13047) * 48;
+acc += Math.sin(13047) + Math.cos(13048) * 49;
+acc += Math.sin(13048) + Math.cos(13049) * 50;
+acc += Math.sin(13049) + Math.cos(13050) * 51;
+acc += Math.sin(13050) + Math.cos(13051) * 52;
+acc += Math.sin(13051) + Math.cos(13052) * 53;
+acc += Math.sin(13052) + Math.cos(13053) * 54;
+acc += Math.sin(13053) + Math.cos(13054) * 55;
+acc += Math.sin(13054) + Math.cos(13055) * 56;
+acc += Math.sin(13055) + Math.cos(13056) * 57;
+acc += Math.sin(13056) + Math.cos(13057) * 58;
+acc += Math.sin(13057) + Math.cos(13058) * 59;
+acc += Math.sin(13058) + Math.cos(13059) * 60;
+acc += Math.sin(13059) + Math.cos(13060) * 61;
+acc += Math.sin(13060) + Math.cos(13061) * 62;
+acc += Math.sin(13061) + Math.cos(13062) * 63;
+acc += Math.sin(13062) + Math.cos(13063) * 64;
+acc += Math.sin(13063) + Math.cos(13064) * 65;
+acc += Math.sin(13064) + Math.cos(13065) * 66;
+acc += Math.sin(13065) + Math.cos(13066) * 67;
+acc += Math.sin(13066) + Math.cos(13067) * 68;
+acc += Math.sin(13067) + Math.cos(13068) * 69;
+acc += Math.sin(13068) + Math.cos(13069) * 70;
+acc += Math.sin(13069) + Math.cos(13070) * 71;
+acc += Math.sin(13070) + Math.cos(13071) * 72;
+acc += Math.sin(13071) + Math.cos(13072) * 73;
+acc += Math.sin(13072) + Math.cos(13073) * 74;
+acc += Math.sin(13073) + Math.cos(13074) * 75;
+acc += Math.sin(13074) + Math.cos(13075) * 76;
+acc += Math.sin(13075) + Math.cos(13076) * 77;
+acc += Math.sin(13076) + Math.cos(13077) * 78;
+acc += Math.sin(13077) + Math.cos(13078) * 79;
+acc += Math.sin(13078) + Math.cos(13079) * 80;
+acc += Math.sin(13079) + Math.cos(13080) * 81;
+acc += Math.sin(13080) + Math.cos(13081) * 82;
+acc += Math.sin(13081) + Math.cos(13082) * 83;
+acc += Math.sin(13082) + Math.cos(13083) * 84;
+acc += Math.sin(13083) + Math.cos(13084) * 85;
+acc += Math.sin(13084) + Math.cos(13085) * 86;
+acc += Math.sin(13085) + Math.cos(13086) * 87;
+acc += Math.sin(13086) + Math.cos(13087) * 88;
+acc += Math.sin(13087) + Math.cos(13088) * 89;
+acc += Math.sin(13088) + Math.cos(13089) * 90;
+acc += Math.sin(13089) + Math.cos(13090) * 91;
+acc += Math.sin(13090) + Math.cos(13091) * 92;
+acc += Math.sin(13091) + Math.cos(13092) * 93;
+acc += Math.sin(13092) + Math.cos(13093) * 94;
+acc += Math.sin(13093) + Math.cos(13094) * 95;
+acc += Math.sin(13094) + Math.cos(13095) * 96;
+acc += Math.sin(13095) + Math.cos(13096) * 0;
+acc += Math.sin(13096) + Math.cos(13097) * 1;
+acc += Math.sin(13097) + Math.cos(13098) * 2;
+acc += Math.sin(13098) + Math.cos(13099) * 3;
+acc += Math.sin(13099) + Math.cos(13100) * 4;
+acc += Math.sin(13100) + Math.cos(13101) * 5;
+acc += Math.sin(13101) + Math.cos(13102) * 6;
+acc += Math.sin(13102) + Math.cos(13103) * 7;
+acc += Math.sin(13103) + Math.cos(13104) * 8;
+acc += Math.sin(13104) + Math.cos(13105) * 9;
+acc += Math.sin(13105) + Math.cos(13106) * 10;
+acc += Math.sin(13106) + Math.cos(13107) * 11;
+acc += Math.sin(13107) + Math.cos(13108) * 12;
+acc += Math.sin(13108) + Math.cos(13109) * 13;
+acc += Math.sin(13109) + Math.cos(13110) * 14;
+acc += Math.sin(13110) + Math.cos(13111) * 15;
+acc += Math.sin(13111) + Math.cos(13112) * 16;
+acc += Math.sin(13112) + Math.cos(13113) * 17;
+acc += Math.sin(13113) + Math.cos(13114) * 18;
+acc += Math.sin(13114) + Math.cos(13115) * 19;
+acc += Math.sin(13115) + Math.cos(13116) * 20;
+acc += Math.sin(13116) + Math.cos(13117) * 21;
+acc += Math.sin(13117) + Math.cos(13118) * 22;
+acc += Math.sin(13118) + Math.cos(13119) * 23;
+acc += Math.sin(13119) + Math.cos(13120) * 24;
+acc += Math.sin(13120) + Math.cos(13121) * 25;
+acc += Math.sin(13121) + Math.cos(13122) * 26;
+acc += Math.sin(13122) + Math.cos(13123) * 27;
+acc += Math.sin(13123) + Math.cos(13124) * 28;
+acc += Math.sin(13124) + Math.cos(13125) * 29;
+acc += Math.sin(13125) + Math.cos(13126) * 30;
+acc += Math.sin(13126) + Math.cos(13127) * 31;
+acc += Math.sin(13127) + Math.cos(13128) * 32;
+acc += Math.sin(13128) + Math.cos(13129) * 33;
+acc += Math.sin(13129) + Math.cos(13130) * 34;
+acc += Math.sin(13130) + Math.cos(13131) * 35;
+acc += Math.sin(13131) + Math.cos(13132) * 36;
+acc += Math.sin(13132) + Math.cos(13133) * 37;
+acc += Math.sin(13133) + Math.cos(13134) * 38;
+acc += Math.sin(13134) + Math.cos(13135) * 39;
+acc += Math.sin(13135) + Math.cos(13136) * 40;
+acc += Math.sin(13136) + Math.cos(13137) * 41;
+acc += Math.sin(13137) + Math.cos(13138) * 42;
+acc += Math.sin(13138) + Math.cos(13139) * 43;
+acc += Math.sin(13139) + Math.cos(13140) * 44;
+acc += Math.sin(13140) + Math.cos(13141) * 45;
+acc += Math.sin(13141) + Math.cos(13142) * 46;
+acc += Math.sin(13142) + Math.cos(13143) * 47;
+acc += Math.sin(13143) + Math.cos(13144) * 48;
+acc += Math.sin(13144) + Math.cos(13145) * 49;
+acc += Math.sin(13145) + Math.cos(13146) * 50;
+acc += Math.sin(13146) + Math.cos(13147) * 51;
+acc += Math.sin(13147) + Math.cos(13148) * 52;
+acc += Math.sin(13148) + Math.cos(13149) * 53;
+acc += Math.sin(13149) + Math.cos(13150) * 54;
+acc += Math.sin(13150) + Math.cos(13151) * 55;
+acc += Math.sin(13151) + Math.cos(13152) * 56;
+acc += Math.sin(13152) + Math.cos(13153) * 57;
+acc += Math.sin(13153) + Math.cos(13154) * 58;
+acc += Math.sin(13154) + Math.cos(13155) * 59;
+acc += Math.sin(13155) + Math.cos(13156) * 60;
+acc += Math.sin(13156) + Math.cos(13157) * 61;
+acc += Math.sin(13157) + Math.cos(13158) * 62;
+acc += Math.sin(13158) + Math.cos(13159) * 63;
+acc += Math.sin(13159) + Math.cos(13160) * 64;
+acc += Math.sin(13160) + Math.cos(13161) * 65;
+acc += Math.sin(13161) + Math.cos(13162) * 66;
+acc += Math.sin(13162) + Math.cos(13163) * 67;
+acc += Math.sin(13163) + Math.cos(13164) * 68;
+acc += Math.sin(13164) + Math.cos(13165) * 69;
+acc += Math.sin(13165) + Math.cos(13166) * 70;
+acc += Math.sin(13166) + Math.cos(13167) * 71;
+acc += Math.sin(13167) + Math.cos(13168) * 72;
+acc += Math.sin(13168) + Math.cos(13169) * 73;
+acc += Math.sin(13169) + Math.cos(13170) * 74;
+acc += Math.sin(13170) + Math.cos(13171) * 75;
+acc += Math.sin(13171) + Math.cos(13172) * 76;
+acc += Math.sin(13172) + Math.cos(13173) * 77;
+acc += Math.sin(13173) + Math.cos(13174) * 78;
+acc += Math.sin(13174) + Math.cos(13175) * 79;
+acc += Math.sin(13175) + Math.cos(13176) * 80;
+acc += Math.sin(13176) + Math.cos(13177) * 81;
+acc += Math.sin(13177) + Math.cos(13178) * 82;
+acc += Math.sin(13178) + Math.cos(13179) * 83;
+acc += Math.sin(13179) + Math.cos(13180) * 84;
+acc += Math.sin(13180) + Math.cos(13181) * 85;
+acc += Math.sin(13181) + Math.cos(13182) * 86;
+acc += Math.sin(13182) + Math.cos(13183) * 87;
+acc += Math.sin(13183) + Math.cos(13184) * 88;
+acc += Math.sin(13184) + Math.cos(13185) * 89;
+acc += Math.sin(13185) + Math.cos(13186) * 90;
+acc += Math.sin(13186) + Math.cos(13187) * 91;
+acc += Math.sin(13187) + Math.cos(13188) * 92;
+acc += Math.sin(13188) + Math.cos(13189) * 93;
+acc += Math.sin(13189) + Math.cos(13190) * 94;
+acc += Math.sin(13190) + Math.cos(13191) * 95;
+acc += Math.sin(13191) + Math.cos(13192) * 96;
+acc += Math.sin(13192) + Math.cos(13193) * 0;
+acc += Math.sin(13193) + Math.cos(13194) * 1;
+acc += Math.sin(13194) + Math.cos(13195) * 2;
+acc += Math.sin(13195) + Math.cos(13196) * 3;
+acc += Math.sin(13196) + Math.cos(13197) * 4;
+acc += Math.sin(13197) + Math.cos(13198) * 5;
+acc += Math.sin(13198) + Math.cos(13199) * 6;
+acc += Math.sin(13199) + Math.cos(13200) * 7;
+acc += Math.sin(13200) + Math.cos(13201) * 8;
+acc += Math.sin(13201) + Math.cos(13202) * 9;
+acc += Math.sin(13202) + Math.cos(13203) * 10;
+acc += Math.sin(13203) + Math.cos(13204) * 11;
+acc += Math.sin(13204) + Math.cos(13205) * 12;
+acc += Math.sin(13205) + Math.cos(13206) * 13;
+acc += Math.sin(13206) + Math.cos(13207) * 14;
+acc += Math.sin(13207) + Math.cos(13208) * 15;
+acc += Math.sin(13208) + Math.cos(13209) * 16;
+acc += Math.sin(13209) + Math.cos(13210) * 17;
+acc += Math.sin(13210) + Math.cos(13211) * 18;
+acc += Math.sin(13211) + Math.cos(13212) * 19;
+acc += Math.sin(13212) + Math.cos(13213) * 20;
+acc += Math.sin(13213) + Math.cos(13214) * 21;
+acc += Math.sin(13214) + Math.cos(13215) * 22;
+acc += Math.sin(13215) + Math.cos(13216) * 23;
+acc += Math.sin(13216) + Math.cos(13217) * 24;
+acc += Math.sin(13217) + Math.cos(13218) * 25;
+acc += Math.sin(13218) + Math.cos(13219) * 26;
+acc += Math.sin(13219) + Math.cos(13220) * 27;
+acc += Math.sin(13220) + Math.cos(13221) * 28;
+acc += Math.sin(13221) + Math.cos(13222) * 29;
+acc += Math.sin(13222) + Math.cos(13223) * 30;
+acc += Math.sin(13223) + Math.cos(13224) * 31;
+acc += Math.sin(13224) + Math.cos(13225) * 32;
+acc += Math.sin(13225) + Math.cos(13226) * 33;
+acc += Math.sin(13226) + Math.cos(13227) * 34;
+acc += Math.sin(13227) + Math.cos(13228) * 35;
+acc += Math.sin(13228) + Math.cos(13229) * 36;
+acc += Math.sin(13229) + Math.cos(13230) * 37;
+acc += Math.sin(13230) + Math.cos(13231) * 38;
+acc += Math.sin(13231) + Math.cos(13232) * 39;
+acc += Math.sin(13232) + Math.cos(13233) * 40;
+acc += Math.sin(13233) + Math.cos(13234) * 41;
+acc += Math.sin(13234) + Math.cos(13235) * 42;
+acc += Math.sin(13235) + Math.cos(13236) * 43;
+acc += Math.sin(13236) + Math.cos(13237) * 44;
+acc += Math.sin(13237) + Math.cos(13238) * 45;
+acc += Math.sin(13238) + Math.cos(13239) * 46;
+acc += Math.sin(13239) + Math.cos(13240) * 47;
+acc += Math.sin(13240) + Math.cos(13241) * 48;
+acc += Math.sin(13241) + Math.cos(13242) * 49;
+acc += Math.sin(13242) + Math.cos(13243) * 50;
+acc += Math.sin(13243) + Math.cos(13244) * 51;
+acc += Math.sin(13244) + Math.cos(13245) * 52;
+acc += Math.sin(13245) + Math.cos(13246) * 53;
+acc += Math.sin(13246) + Math.cos(13247) * 54;
+acc += Math.sin(13247) + Math.cos(13248) * 55;
+acc += Math.sin(13248) + Math.cos(13249) * 56;
+acc += Math.sin(13249) + Math.cos(13250) * 57;
+acc += Math.sin(13250) + Math.cos(13251) * 58;
+acc += Math.sin(13251) + Math.cos(13252) * 59;
+acc += Math.sin(13252) + Math.cos(13253) * 60;
+acc += Math.sin(13253) + Math.cos(13254) * 61;
+acc += Math.sin(13254) + Math.cos(13255) * 62;
+acc += Math.sin(13255) + Math.cos(13256) * 63;
+acc += Math.sin(13256) + Math.cos(13257) * 64;
+acc += Math.sin(13257) + Math.cos(13258) * 65;
+acc += Math.sin(13258) + Math.cos(13259) * 66;
+acc += Math.sin(13259) + Math.cos(13260) * 67;
+acc += Math.sin(13260) + Math.cos(13261) * 68;
+acc += Math.sin(13261) + Math.cos(13262) * 69;
+acc += Math.sin(13262) + Math.cos(13263) * 70;
+acc += Math.sin(13263) + Math.cos(13264) * 71;
+acc += Math.sin(13264) + Math.cos(13265) * 72;
+acc += Math.sin(13265) + Math.cos(13266) * 73;
+acc += Math.sin(13266) + Math.cos(13267) * 74;
+acc += Math.sin(13267) + Math.cos(13268) * 75;
+acc += Math.sin(13268) + Math.cos(13269) * 76;
+acc += Math.sin(13269) + Math.cos(13270) * 77;
+acc += Math.sin(13270) + Math.cos(13271) * 78;
+acc += Math.sin(13271) + Math.cos(13272) * 79;
+acc += Math.sin(13272) + Math.cos(13273) * 80;
+acc += Math.sin(13273) + Math.cos(13274) * 81;
+acc += Math.sin(13274) + Math.cos(13275) * 82;
+acc += Math.sin(13275) + Math.cos(13276) * 83;
+acc += Math.sin(13276) + Math.cos(13277) * 84;
+acc += Math.sin(13277) + Math.cos(13278) * 85;
+acc += Math.sin(13278) + Math.cos(13279) * 86;
+acc += Math.sin(13279) + Math.cos(13280) * 87;
+acc += Math.sin(13280) + Math.cos(13281) * 88;
+acc += Math.sin(13281) + Math.cos(13282) * 89;
+acc += Math.sin(13282) + Math.cos(13283) * 90;
+acc += Math.sin(13283) + Math.cos(13284) * 91;
+acc += Math.sin(13284) + Math.cos(13285) * 92;
+acc += Math.sin(13285) + Math.cos(13286) * 93;
+acc += Math.sin(13286) + Math.cos(13287) * 94;
+acc += Math.sin(13287) + Math.cos(13288) * 95;
+acc += Math.sin(13288) + Math.cos(13289) * 96;
+acc += Math.sin(13289) + Math.cos(13290) * 0;
+acc += Math.sin(13290) + Math.cos(13291) * 1;
+acc += Math.sin(13291) + Math.cos(13292) * 2;
+acc += Math.sin(13292) + Math.cos(13293) * 3;
+acc += Math.sin(13293) + Math.cos(13294) * 4;
+acc += Math.sin(13294) + Math.cos(13295) * 5;
+acc += Math.sin(13295) + Math.cos(13296) * 6;
+acc += Math.sin(13296) + Math.cos(13297) * 7;
+acc += Math.sin(13297) + Math.cos(13298) * 8;
+acc += Math.sin(13298) + Math.cos(13299) * 9;
+acc += Math.sin(13299) + Math.cos(13300) * 10;
+acc += Math.sin(13300) + Math.cos(13301) * 11;
+acc += Math.sin(13301) + Math.cos(13302) * 12;
+acc += Math.sin(13302) + Math.cos(13303) * 13;
+acc += Math.sin(13303) + Math.cos(13304) * 14;
+acc += Math.sin(13304) + Math.cos(13305) * 15;
+acc += Math.sin(13305) + Math.cos(13306) * 16;
+acc += Math.sin(13306) + Math.cos(13307) * 17;
+acc += Math.sin(13307) + Math.cos(13308) * 18;
+acc += Math.sin(13308) + Math.cos(13309) * 19;
+acc += Math.sin(13309) + Math.cos(13310) * 20;
+acc += Math.sin(13310) + Math.cos(13311) * 21;
+acc += Math.sin(13311) + Math.cos(13312) * 22;
+acc += Math.sin(13312) + Math.cos(13313) * 23;
+acc += Math.sin(13313) + Math.cos(13314) * 24;
+acc += Math.sin(13314) + Math.cos(13315) * 25;
+acc += Math.sin(13315) + Math.cos(13316) * 26;
+acc += Math.sin(13316) + Math.cos(13317) * 27;
+acc += Math.sin(13317) + Math.cos(13318) * 28;
+acc += Math.sin(13318) + Math.cos(13319) * 29;
+acc += Math.sin(13319) + Math.cos(13320) * 30;
+acc += Math.sin(13320) + Math.cos(13321) * 31;
+acc += Math.sin(13321) + Math.cos(13322) * 32;
+acc += Math.sin(13322) + Math.cos(13323) * 33;
+acc += Math.sin(13323) + Math.cos(13324) * 34;
+acc += Math.sin(13324) + Math.cos(13325) * 35;
+acc += Math.sin(13325) + Math.cos(13326) * 36;
+acc += Math.sin(13326) + Math.cos(13327) * 37;
+acc += Math.sin(13327) + Math.cos(13328) * 38;
+acc += Math.sin(13328) + Math.cos(13329) * 39;
+acc += Math.sin(13329) + Math.cos(13330) * 40;
+acc += Math.sin(13330) + Math.cos(13331) * 41;
+acc += Math.sin(13331) + Math.cos(13332) * 42;
+acc += Math.sin(13332) + Math.cos(13333) * 43;
+acc += Math.sin(13333) + Math.cos(13334) * 44;
+acc += Math.sin(13334) + Math.cos(13335) * 45;
+acc += Math.sin(13335) + Math.cos(13336) * 46;
+acc += Math.sin(13336) + Math.cos(13337) * 47;
+acc += Math.sin(13337) + Math.cos(13338) * 48;
+acc += Math.sin(13338) + Math.cos(13339) * 49;
+acc += Math.sin(13339) + Math.cos(13340) * 50;
+acc += Math.sin(13340) + Math.cos(13341) * 51;
+acc += Math.sin(13341) + Math.cos(13342) * 52;
+acc += Math.sin(13342) + Math.cos(13343) * 53;
+acc += Math.sin(13343) + Math.cos(13344) * 54;
+acc += Math.sin(13344) + Math.cos(13345) * 55;
+acc += Math.sin(13345) + Math.cos(13346) * 56;
+acc += Math.sin(13346) + Math.cos(13347) * 57;
+acc += Math.sin(13347) + Math.cos(13348) * 58;
+acc += Math.sin(13348) + Math.cos(13349) * 59;
+acc += Math.sin(13349) + Math.cos(13350) * 60;
+acc += Math.sin(13350) + Math.cos(13351) * 61;
+acc += Math.sin(13351) + Math.cos(13352) * 62;
+acc += Math.sin(13352) + Math.cos(13353) * 63;
+acc += Math.sin(13353) + Math.cos(13354) * 64;
+acc += Math.sin(13354) + Math.cos(13355) * 65;
+acc += Math.sin(13355) + Math.cos(13356) * 66;
+acc += Math.sin(13356) + Math.cos(13357) * 67;
+acc += Math.sin(13357) + Math.cos(13358) * 68;
+acc += Math.sin(13358) + Math.cos(13359) * 69;
+acc += Math.sin(13359) + Math.cos(13360) * 70;
+acc += Math.sin(13360) + Math.cos(13361) * 71;
+acc += Math.sin(13361) + Math.cos(13362) * 72;
+acc += Math.sin(13362) + Math.cos(13363) * 73;
+acc += Math.sin(13363) + Math.cos(13364) * 74;
+acc += Math.sin(13364) + Math.cos(13365) * 75;
+acc += Math.sin(13365) + Math.cos(13366) * 76;
+acc += Math.sin(13366) + Math.cos(13367) * 77;
+acc += Math.sin(13367) + Math.cos(13368) * 78;
+acc += Math.sin(13368) + Math.cos(13369) * 79;
+acc += Math.sin(13369) + Math.cos(13370) * 80;
+acc += Math.sin(13370) + Math.cos(13371) * 81;
+acc += Math.sin(13371) + Math.cos(13372) * 82;
+acc += Math.sin(13372) + Math.cos(13373) * 83;
+acc += Math.sin(13373) + Math.cos(13374) * 84;
+acc += Math.sin(13374) + Math.cos(13375) * 85;
+acc += Math.sin(13375) + Math.cos(13376) * 86;
+acc += Math.sin(13376) + Math.cos(13377) * 87;
+acc += Math.sin(13377) + Math.cos(13378) * 88;
+acc += Math.sin(13378) + Math.cos(13379) * 89;
+acc += Math.sin(13379) + Math.cos(13380) * 90;
+acc += Math.sin(13380) + Math.cos(13381) * 91;
+acc += Math.sin(13381) + Math.cos(13382) * 92;
+acc += Math.sin(13382) + Math.cos(13383) * 93;
+acc += Math.sin(13383) + Math.cos(13384) * 94;
+acc += Math.sin(13384) + Math.cos(13385) * 95;
+acc += Math.sin(13385) + Math.cos(13386) * 96;
+acc += Math.sin(13386) + Math.cos(13387) * 0;
+acc += Math.sin(13387) + Math.cos(13388) * 1;
+acc += Math.sin(13388) + Math.cos(13389) * 2;
+acc += Math.sin(13389) + Math.cos(13390) * 3;
+acc += Math.sin(13390) + Math.cos(13391) * 4;
+acc += Math.sin(13391) + Math.cos(13392) * 5;
+acc += Math.sin(13392) + Math.cos(13393) * 6;
+acc += Math.sin(13393) + Math.cos(13394) * 7;
+acc += Math.sin(13394) + Math.cos(13395) * 8;
+acc += Math.sin(13395) + Math.cos(13396) * 9;
+acc += Math.sin(13396) + Math.cos(13397) * 10;
+acc += Math.sin(13397) + Math.cos(13398) * 11;
+acc += Math.sin(13398) + Math.cos(13399) * 12;
+acc += Math.sin(13399) + Math.cos(13400) * 13;
+acc += Math.sin(13400) + Math.cos(13401) * 14;
+acc += Math.sin(13401) + Math.cos(13402) * 15;
+acc += Math.sin(13402) + Math.cos(13403) * 16;
+acc += Math.sin(13403) + Math.cos(13404) * 17;
+acc += Math.sin(13404) + Math.cos(13405) * 18;
+acc += Math.sin(13405) + Math.cos(13406) * 19;
+acc += Math.sin(13406) + Math.cos(13407) * 20;
+acc += Math.sin(13407) + Math.cos(13408) * 21;
+acc += Math.sin(13408) + Math.cos(13409) * 22;
+acc += Math.sin(13409) + Math.cos(13410) * 23;
+acc += Math.sin(13410) + Math.cos(13411) * 24;
+acc += Math.sin(13411) + Math.cos(13412) * 25;
+acc += Math.sin(13412) + Math.cos(13413) * 26;
+acc += Math.sin(13413) + Math.cos(13414) * 27;
+acc += Math.sin(13414) + Math.cos(13415) * 28;
+acc += Math.sin(13415) + Math.cos(13416) * 29;
+acc += Math.sin(13416) + Math.cos(13417) * 30;
+acc += Math.sin(13417) + Math.cos(13418) * 31;
+acc += Math.sin(13418) + Math.cos(13419) * 32;
+acc += Math.sin(13419) + Math.cos(13420) * 33;
+acc += Math.sin(13420) + Math.cos(13421) * 34;
+acc += Math.sin(13421) + Math.cos(13422) * 35;
+acc += Math.sin(13422) + Math.cos(13423) * 36;
+acc += Math.sin(13423) + Math.cos(13424) * 37;
+acc += Math.sin(13424) + Math.cos(13425) * 38;
+acc += Math.sin(13425) + Math.cos(13426) * 39;
+acc += Math.sin(13426) + Math.cos(13427) * 40;
+acc += Math.sin(13427) + Math.cos(13428) * 41;
+acc += Math.sin(13428) + Math.cos(13429) * 42;
+acc += Math.sin(13429) + Math.cos(13430) * 43;
+acc += Math.sin(13430) + Math.cos(13431) * 44;
+acc += Math.sin(13431) + Math.cos(13432) * 45;
+acc += Math.sin(13432) + Math.cos(13433) * 46;
+acc += Math.sin(13433) + Math.cos(13434) * 47;
+acc += Math.sin(13434) + Math.cos(13435) * 48;
+acc += Math.sin(13435) + Math.cos(13436) * 49;
+acc += Math.sin(13436) + Math.cos(13437) * 50;
+acc += Math.sin(13437) + Math.cos(13438) * 51;
+acc += Math.sin(13438) + Math.cos(13439) * 52;
+acc += Math.sin(13439) + Math.cos(13440) * 53;
+acc += Math.sin(13440) + Math.cos(13441) * 54;
+acc += Math.sin(13441) + Math.cos(13442) * 55;
+acc += Math.sin(13442) + Math.cos(13443) * 56;
+acc += Math.sin(13443) + Math.cos(13444) * 57;
+acc += Math.sin(13444) + Math.cos(13445) * 58;
+acc += Math.sin(13445) + Math.cos(13446) * 59;
+acc += Math.sin(13446) + Math.cos(13447) * 60;
+acc += Math.sin(13447) + Math.cos(13448) * 61;
+acc += Math.sin(13448) + Math.cos(13449) * 62;
+acc += Math.sin(13449) + Math.cos(13450) * 63;
+acc += Math.sin(13450) + Math.cos(13451) * 64;
+acc += Math.sin(13451) + Math.cos(13452) * 65;
+acc += Math.sin(13452) + Math.cos(13453) * 66;
+acc += Math.sin(13453) + Math.cos(13454) * 67;
+acc += Math.sin(13454) + Math.cos(13455) * 68;
+acc += Math.sin(13455) + Math.cos(13456) * 69;
+acc += Math.sin(13456) + Math.cos(13457) * 70;
+acc += Math.sin(13457) + Math.cos(13458) * 71;
+acc += Math.sin(13458) + Math.cos(13459) * 72;
+acc += Math.sin(13459) + Math.cos(13460) * 73;
+acc += Math.sin(13460) + Math.cos(13461) * 74;
+acc += Math.sin(13461) + Math.cos(13462) * 75;
+acc += Math.sin(13462) + Math.cos(13463) * 76;
+acc += Math.sin(13463) + Math.cos(13464) * 77;
+acc += Math.sin(13464) + Math.cos(13465) * 78;
+acc += Math.sin(13465) + Math.cos(13466) * 79;
+acc += Math.sin(13466) + Math.cos(13467) * 80;
+acc += Math.sin(13467) + Math.cos(13468) * 81;
+acc += Math.sin(13468) + Math.cos(13469) * 82;
+acc += Math.sin(13469) + Math.cos(13470) * 83;
+acc += Math.sin(13470) + Math.cos(13471) * 84;
+acc += Math.sin(13471) + Math.cos(13472) * 85;
+acc += Math.sin(13472) + Math.cos(13473) * 86;
+acc += Math.sin(13473) + Math.cos(13474) * 87;
+acc += Math.sin(13474) + Math.cos(13475) * 88;
+acc += Math.sin(13475) + Math.cos(13476) * 89;
+acc += Math.sin(13476) + Math.cos(13477) * 90;
+acc += Math.sin(13477) + Math.cos(13478) * 91;
+acc += Math.sin(13478) + Math.cos(13479) * 92;
+acc += Math.sin(13479) + Math.cos(13480) * 93;
+acc += Math.sin(13480) + Math.cos(13481) * 94;
+acc += Math.sin(13481) + Math.cos(13482) * 95;
+acc += Math.sin(13482) + Math.cos(13483) * 96;
+acc += Math.sin(13483) + Math.cos(13484) * 0;
+acc += Math.sin(13484) + Math.cos(13485) * 1;
+acc += Math.sin(13485) + Math.cos(13486) * 2;
+acc += Math.sin(13486) + Math.cos(13487) * 3;
+acc += Math.sin(13487) + Math.cos(13488) * 4;
+acc += Math.sin(13488) + Math.cos(13489) * 5;
+acc += Math.sin(13489) + Math.cos(13490) * 6;
+acc += Math.sin(13490) + Math.cos(13491) * 7;
+acc += Math.sin(13491) + Math.cos(13492) * 8;
+acc += Math.sin(13492) + Math.cos(13493) * 9;
+acc += Math.sin(13493) + Math.cos(13494) * 10;
+acc += Math.sin(13494) + Math.cos(13495) * 11;
+acc += Math.sin(13495) + Math.cos(13496) * 12;
+acc += Math.sin(13496) + Math.cos(13497) * 13;
+acc += Math.sin(13497) + Math.cos(13498) * 14;
+acc += Math.sin(13498) + Math.cos(13499) * 15;
+acc += Math.sin(13499) + Math.cos(13500) * 16;
+acc += Math.sin(13500) + Math.cos(13501) * 17;
+acc += Math.sin(13501) + Math.cos(13502) * 18;
+acc += Math.sin(13502) + Math.cos(13503) * 19;
+acc += Math.sin(13503) + Math.cos(13504) * 20;
+acc += Math.sin(13504) + Math.cos(13505) * 21;
+acc += Math.sin(13505) + Math.cos(13506) * 22;
+acc += Math.sin(13506) + Math.cos(13507) * 23;
+acc += Math.sin(13507) + Math.cos(13508) * 24;
+acc += Math.sin(13508) + Math.cos(13509) * 25;
+acc += Math.sin(13509) + Math.cos(13510) * 26;
+acc += Math.sin(13510) + Math.cos(13511) * 27;
+acc += Math.sin(13511) + Math.cos(13512) * 28;
+acc += Math.sin(13512) + Math.cos(13513) * 29;
+acc += Math.sin(13513) + Math.cos(13514) * 30;
+acc += Math.sin(13514) + Math.cos(13515) * 31;
+acc += Math.sin(13515) + Math.cos(13516) * 32;
+acc += Math.sin(13516) + Math.cos(13517) * 33;
+acc += Math.sin(13517) + Math.cos(13518) * 34;
+acc += Math.sin(13518) + Math.cos(13519) * 35;
+acc += Math.sin(13519) + Math.cos(13520) * 36;
+acc += Math.sin(13520) + Math.cos(13521) * 37;
+acc += Math.sin(13521) + Math.cos(13522) * 38;
+acc += Math.sin(13522) + Math.cos(13523) * 39;
+acc += Math.sin(13523) + Math.cos(13524) * 40;
+acc += Math.sin(13524) + Math.cos(13525) * 41;
+acc += Math.sin(13525) + Math.cos(13526) * 42;
+acc += Math.sin(13526) + Math.cos(13527) * 43;
+acc += Math.sin(13527) + Math.cos(13528) * 44;
+acc += Math.sin(13528) + Math.cos(13529) * 45;
+acc += Math.sin(13529) + Math.cos(13530) * 46;
+acc += Math.sin(13530) + Math.cos(13531) * 47;
+acc += Math.sin(13531) + Math.cos(13532) * 48;
+acc += Math.sin(13532) + Math.cos(13533) * 49;
+acc += Math.sin(13533) + Math.cos(13534) * 50;
+acc += Math.sin(13534) + Math.cos(13535) * 51;
+acc += Math.sin(13535) + Math.cos(13536) * 52;
+acc += Math.sin(13536) + Math.cos(13537) * 53;
+acc += Math.sin(13537) + Math.cos(13538) * 54;
+acc += Math.sin(13538) + Math.cos(13539) * 55;
+acc += Math.sin(13539) + Math.cos(13540) * 56;
+acc += Math.sin(13540) + Math.cos(13541) * 57;
+acc += Math.sin(13541) + Math.cos(13542) * 58;
+acc += Math.sin(13542) + Math.cos(13543) * 59;
+acc += Math.sin(13543) + Math.cos(13544) * 60;
+acc += Math.sin(13544) + Math.cos(13545) * 61;
+acc += Math.sin(13545) + Math.cos(13546) * 62;
+acc += Math.sin(13546) + Math.cos(13547) * 63;
+acc += Math.sin(13547) + Math.cos(13548) * 64;
+acc += Math.sin(13548) + Math.cos(13549) * 65;
+acc += Math.sin(13549) + Math.cos(13550) * 66;
+acc += Math.sin(13550) + Math.cos(13551) * 67;
+acc += Math.sin(13551) + Math.cos(13552) * 68;
+acc += Math.sin(13552) + Math.cos(13553) * 69;
+acc += Math.sin(13553) + Math.cos(13554) * 70;
+acc += Math.sin(13554) + Math.cos(13555) * 71;
+acc += Math.sin(13555) + Math.cos(13556) * 72;
+acc += Math.sin(13556) + Math.cos(13557) * 73;
+acc += Math.sin(13557) + Math.cos(13558) * 74;
+acc += Math.sin(13558) + Math.cos(13559) * 75;
+acc += Math.sin(13559) + Math.cos(13560) * 76;
+acc += Math.sin(13560) + Math.cos(13561) * 77;
+acc += Math.sin(13561) + Math.cos(13562) * 78;
+acc += Math.sin(13562) + Math.cos(13563) * 79;
+acc += Math.sin(13563) + Math.cos(13564) * 80;
+acc += Math.sin(13564) + Math.cos(13565) * 81;
+acc += Math.sin(13565) + Math.cos(13566) * 82;
+acc += Math.sin(13566) + Math.cos(13567) * 83;
+acc += Math.sin(13567) + Math.cos(13568) * 84;
+acc += Math.sin(13568) + Math.cos(13569) * 85;
+acc += Math.sin(13569) + Math.cos(13570) * 86;
+acc += Math.sin(13570) + Math.cos(13571) * 87;
+acc += Math.sin(13571) + Math.cos(13572) * 88;
+acc += Math.sin(13572) + Math.cos(13573) * 89;
+acc += Math.sin(13573) + Math.cos(13574) * 90;
+acc += Math.sin(13574) + Math.cos(13575) * 91;
+acc += Math.sin(13575) + Math.cos(13576) * 92;
+acc += Math.sin(13576) + Math.cos(13577) * 93;
+acc += Math.sin(13577) + Math.cos(13578) * 94;
+acc += Math.sin(13578) + Math.cos(13579) * 95;
+acc += Math.sin(13579) + Math.cos(13580) * 96;
+acc += Math.sin(13580) + Math.cos(13581) * 0;
+acc += Math.sin(13581) + Math.cos(13582) * 1;
+acc += Math.sin(13582) + Math.cos(13583) * 2;
+acc += Math.sin(13583) + Math.cos(13584) * 3;
+acc += Math.sin(13584) + Math.cos(13585) * 4;
+acc += Math.sin(13585) + Math.cos(13586) * 5;
+acc += Math.sin(13586) + Math.cos(13587) * 6;
+acc += Math.sin(13587) + Math.cos(13588) * 7;
+acc += Math.sin(13588) + Math.cos(13589) * 8;
+acc += Math.sin(13589) + Math.cos(13590) * 9;
+acc += Math.sin(13590) + Math.cos(13591) * 10;
+acc += Math.sin(13591) + Math.cos(13592) * 11;
+acc += Math.sin(13592) + Math.cos(13593) * 12;
+acc += Math.sin(13593) + Math.cos(13594) * 13;
+acc += Math.sin(13594) + Math.cos(13595) * 14;
+acc += Math.sin(13595) + Math.cos(13596) * 15;
+acc += Math.sin(13596) + Math.cos(13597) * 16;
+acc += Math.sin(13597) + Math.cos(13598) * 17;
+acc += Math.sin(13598) + Math.cos(13599) * 18;
+acc += Math.sin(13599) + Math.cos(13600) * 19;
+acc += Math.sin(13600) + Math.cos(13601) * 20;
+acc += Math.sin(13601) + Math.cos(13602) * 21;
+acc += Math.sin(13602) + Math.cos(13603) * 22;
+acc += Math.sin(13603) + Math.cos(13604) * 23;
+acc += Math.sin(13604) + Math.cos(13605) * 24;
+acc += Math.sin(13605) + Math.cos(13606) * 25;
+acc += Math.sin(13606) + Math.cos(13607) * 26;
+acc += Math.sin(13607) + Math.cos(13608) * 27;
+acc += Math.sin(13608) + Math.cos(13609) * 28;
+acc += Math.sin(13609) + Math.cos(13610) * 29;
+acc += Math.sin(13610) + Math.cos(13611) * 30;
+acc += Math.sin(13611) + Math.cos(13612) * 31;
+acc += Math.sin(13612) + Math.cos(13613) * 32;
+acc += Math.sin(13613) + Math.cos(13614) * 33;
+acc += Math.sin(13614) + Math.cos(13615) * 34;
+acc += Math.sin(13615) + Math.cos(13616) * 35;
+acc += Math.sin(13616) + Math.cos(13617) * 36;
+acc += Math.sin(13617) + Math.cos(13618) * 37;
+acc += Math.sin(13618) + Math.cos(13619) * 38;
+acc += Math.sin(13619) + Math.cos(13620) * 39;
+acc += Math.sin(13620) + Math.cos(13621) * 40;
+acc += Math.sin(13621) + Math.cos(13622) * 41;
+acc += Math.sin(13622) + Math.cos(13623) * 42;
+acc += Math.sin(13623) + Math.cos(13624) * 43;
+acc += Math.sin(13624) + Math.cos(13625) * 44;
+acc += Math.sin(13625) + Math.cos(13626) * 45;
+acc += Math.sin(13626) + Math.cos(13627) * 46;
+acc += Math.sin(13627) + Math.cos(13628) * 47;
+acc += Math.sin(13628) + Math.cos(13629) * 48;
+acc += Math.sin(13629) + Math.cos(13630) * 49;
+acc += Math.sin(13630) + Math.cos(13631) * 50;
+acc += Math.sin(13631) + Math.cos(13632) * 51;
+acc += Math.sin(13632) + Math.cos(13633) * 52;
+acc += Math.sin(13633) + Math.cos(13634) * 53;
+acc += Math.sin(13634) + Math.cos(13635) * 54;
+acc += Math.sin(13635) + Math.cos(13636) * 55;
+acc += Math.sin(13636) + Math.cos(13637) * 56;
+acc += Math.sin(13637) + Math.cos(13638) * 57;
+acc += Math.sin(13638) + Math.cos(13639) * 58;
+acc += Math.sin(13639) + Math.cos(13640) * 59;
+acc += Math.sin(13640) + Math.cos(13641) * 60;
+acc += Math.sin(13641) + Math.cos(13642) * 61;
+acc += Math.sin(13642) + Math.cos(13643) * 62;
+acc += Math.sin(13643) + Math.cos(13644) * 63;
+acc += Math.sin(13644) + Math.cos(13645) * 64;
+acc += Math.sin(13645) + Math.cos(13646) * 65;
+acc += Math.sin(13646) + Math.cos(13647) * 66;
+acc += Math.sin(13647) + Math.cos(13648) * 67;
+acc += Math.sin(13648) + Math.cos(13649) * 68;
+acc += Math.sin(13649) + Math.cos(13650) * 69;
+acc += Math.sin(13650) + Math.cos(13651) * 70;
+acc += Math.sin(13651) + Math.cos(13652) * 71;
+acc += Math.sin(13652) + Math.cos(13653) * 72;
+acc += Math.sin(13653) + Math.cos(13654) * 73;
+acc += Math.sin(13654) + Math.cos(13655) * 74;
+acc += Math.sin(13655) + Math.cos(13656) * 75;
+acc += Math.sin(13656) + Math.cos(13657) * 76;
+acc += Math.sin(13657) + Math.cos(13658) * 77;
+acc += Math.sin(13658) + Math.cos(13659) * 78;
+acc += Math.sin(13659) + Math.cos(13660) * 79;
+acc += Math.sin(13660) + Math.cos(13661) * 80;
+acc += Math.sin(13661) + Math.cos(13662) * 81;
+acc += Math.sin(13662) + Math.cos(13663) * 82;
+acc += Math.sin(13663) + Math.cos(13664) * 83;
+acc += Math.sin(13664) + Math.cos(13665) * 84;
+acc += Math.sin(13665) + Math.cos(13666) * 85;
+acc += Math.sin(13666) + Math.cos(13667) * 86;
+acc += Math.sin(13667) + Math.cos(13668) * 87;
+acc += Math.sin(13668) + Math.cos(13669) * 88;
+acc += Math.sin(13669) + Math.cos(13670) * 89;
+acc += Math.sin(13670) + Math.cos(13671) * 90;
+acc += Math.sin(13671) + Math.cos(13672) * 91;
+acc += Math.sin(13672) + Math.cos(13673) * 92;
+acc += Math.sin(13673) + Math.cos(13674) * 93;
+acc += Math.sin(13674) + Math.cos(13675) * 94;
+acc += Math.sin(13675) + Math.cos(13676) * 95;
+acc += Math.sin(13676) + Math.cos(13677) * 96;
+acc += Math.sin(13677) + Math.cos(13678) * 0;
+acc += Math.sin(13678) + Math.cos(13679) * 1;
+acc += Math.sin(13679) + Math.cos(13680) * 2;
+acc += Math.sin(13680) + Math.cos(13681) * 3;
+acc += Math.sin(13681) + Math.cos(13682) * 4;
+acc += Math.sin(13682) + Math.cos(13683) * 5;
+acc += Math.sin(13683) + Math.cos(13684) * 6;
+acc += Math.sin(13684) + Math.cos(13685) * 7;
+acc += Math.sin(13685) + Math.cos(13686) * 8;
+acc += Math.sin(13686) + Math.cos(13687) * 9;
+acc += Math.sin(13687) + Math.cos(13688) * 10;
+acc += Math.sin(13688) + Math.cos(13689) * 11;
+acc += Math.sin(13689) + Math.cos(13690) * 12;
+acc += Math.sin(13690) + Math.cos(13691) * 13;
+acc += Math.sin(13691) + Math.cos(13692) * 14;
+acc += Math.sin(13692) + Math.cos(13693) * 15;
+acc += Math.sin(13693) + Math.cos(13694) * 16;
+acc += Math.sin(13694) + Math.cos(13695) * 17;
+acc += Math.sin(13695) + Math.cos(13696) * 18;
+acc += Math.sin(13696) + Math.cos(13697) * 19;
+acc += Math.sin(13697) + Math.cos(13698) * 20;
+acc += Math.sin(13698) + Math.cos(13699) * 21;
+acc += Math.sin(13699) + Math.cos(13700) * 22;
+acc += Math.sin(13700) + Math.cos(13701) * 23;
+acc += Math.sin(13701) + Math.cos(13702) * 24;
+acc += Math.sin(13702) + Math.cos(13703) * 25;
+acc += Math.sin(13703) + Math.cos(13704) * 26;
+acc += Math.sin(13704) + Math.cos(13705) * 27;
+acc += Math.sin(13705) + Math.cos(13706) * 28;
+acc += Math.sin(13706) + Math.cos(13707) * 29;
+acc += Math.sin(13707) + Math.cos(13708) * 30;
+acc += Math.sin(13708) + Math.cos(13709) * 31;
+acc += Math.sin(13709) + Math.cos(13710) * 32;
+acc += Math.sin(13710) + Math.cos(13711) * 33;
+acc += Math.sin(13711) + Math.cos(13712) * 34;
+acc += Math.sin(13712) + Math.cos(13713) * 35;
+acc += Math.sin(13713) + Math.cos(13714) * 36;
+acc += Math.sin(13714) + Math.cos(13715) * 37;
+acc += Math.sin(13715) + Math.cos(13716) * 38;
+acc += Math.sin(13716) + Math.cos(13717) * 39;
+acc += Math.sin(13717) + Math.cos(13718) * 40;
+acc += Math.sin(13718) + Math.cos(13719) * 41;
+acc += Math.sin(13719) + Math.cos(13720) * 42;
+acc += Math.sin(13720) + Math.cos(13721) * 43;
+acc += Math.sin(13721) + Math.cos(13722) * 44;
+acc += Math.sin(13722) + Math.cos(13723) * 45;
+acc += Math.sin(13723) + Math.cos(13724) * 46;
+acc += Math.sin(13724) + Math.cos(13725) * 47;
+acc += Math.sin(13725) + Math.cos(13726) * 48;
+acc += Math.sin(13726) + Math.cos(13727) * 49;
+acc += Math.sin(13727) + Math.cos(13728) * 50;
+acc += Math.sin(13728) + Math.cos(13729) * 51;
+acc += Math.sin(13729) + Math.cos(13730) * 52;
+acc += Math.sin(13730) + Math.cos(13731) * 53;
+acc += Math.sin(13731) + Math.cos(13732) * 54;
+acc += Math.sin(13732) + Math.cos(13733) * 55;
+acc += Math.sin(13733) + Math.cos(13734) * 56;
+acc += Math.sin(13734) + Math.cos(13735) * 57;
+acc += Math.sin(13735) + Math.cos(13736) * 58;
+acc += Math.sin(13736) + Math.cos(13737) * 59;
+acc += Math.sin(13737) + Math.cos(13738) * 60;
+acc += Math.sin(13738) + Math.cos(13739) * 61;
+acc += Math.sin(13739) + Math.cos(13740) * 62;
+acc += Math.sin(13740) + Math.cos(13741) * 63;
+acc += Math.sin(13741) + Math.cos(13742) * 64;
+acc += Math.sin(13742) + Math.cos(13743) * 65;
+acc += Math.sin(13743) + Math.cos(13744) * 66;
+acc += Math.sin(13744) + Math.cos(13745) * 67;
+acc += Math.sin(13745) + Math.cos(13746) * 68;
+acc += Math.sin(13746) + Math.cos(13747) * 69;
+acc += Math.sin(13747) + Math.cos(13748) * 70;
+acc += Math.sin(13748) + Math.cos(13749) * 71;
+acc += Math.sin(13749) + Math.cos(13750) * 72;
+acc += Math.sin(13750) + Math.cos(13751) * 73;
+acc += Math.sin(13751) + Math.cos(13752) * 74;
+acc += Math.sin(13752) + Math.cos(13753) * 75;
+acc += Math.sin(13753) + Math.cos(13754) * 76;
+acc += Math.sin(13754) + Math.cos(13755) * 77;
+acc += Math.sin(13755) + Math.cos(13756) * 78;
+acc += Math.sin(13756) + Math.cos(13757) * 79;
+acc += Math.sin(13757) + Math.cos(13758) * 80;
+acc += Math.sin(13758) + Math.cos(13759) * 81;
+acc += Math.sin(13759) + Math.cos(13760) * 82;
+acc += Math.sin(13760) + Math.cos(13761) * 83;
+acc += Math.sin(13761) + Math.cos(13762) * 84;
+acc += Math.sin(13762) + Math.cos(13763) * 85;
+acc += Math.sin(13763) + Math.cos(13764) * 86;
+acc += Math.sin(13764) + Math.cos(13765) * 87;
+acc += Math.sin(13765) + Math.cos(13766) * 88;
+acc += Math.sin(13766) + Math.cos(13767) * 89;
+acc += Math.sin(13767) + Math.cos(13768) * 90;
+acc += Math.sin(13768) + Math.cos(13769) * 91;
+acc += Math.sin(13769) + Math.cos(13770) * 92;
+acc += Math.sin(13770) + Math.cos(13771) * 93;
+acc += Math.sin(13771) + Math.cos(13772) * 94;
+acc += Math.sin(13772) + Math.cos(13773) * 95;
+acc += Math.sin(13773) + Math.cos(13774) * 96;
+acc += Math.sin(13774) + Math.cos(13775) * 0;
+acc += Math.sin(13775) + Math.cos(13776) * 1;
+acc += Math.sin(13776) + Math.cos(13777) * 2;
+acc += Math.sin(13777) + Math.cos(13778) * 3;
+acc += Math.sin(13778) + Math.cos(13779) * 4;
+acc += Math.sin(13779) + Math.cos(13780) * 5;
+acc += Math.sin(13780) + Math.cos(13781) * 6;
+acc += Math.sin(13781) + Math.cos(13782) * 7;
+acc += Math.sin(13782) + Math.cos(13783) * 8;
+acc += Math.sin(13783) + Math.cos(13784) * 9;
+acc += Math.sin(13784) + Math.cos(13785) * 10;
+acc += Math.sin(13785) + Math.cos(13786) * 11;
+acc += Math.sin(13786) + Math.cos(13787) * 12;
+acc += Math.sin(13787) + Math.cos(13788) * 13;
+acc += Math.sin(13788) + Math.cos(13789) * 14;
+acc += Math.sin(13789) + Math.cos(13790) * 15;
+acc += Math.sin(13790) + Math.cos(13791) * 16;
+acc += Math.sin(13791) + Math.cos(13792) * 17;
+acc += Math.sin(13792) + Math.cos(13793) * 18;
+acc += Math.sin(13793) + Math.cos(13794) * 19;
+acc += Math.sin(13794) + Math.cos(13795) * 20;
+acc += Math.sin(13795) + Math.cos(13796) * 21;
+acc += Math.sin(13796) + Math.cos(13797) * 22;
+acc += Math.sin(13797) + Math.cos(13798) * 23;
+acc += Math.sin(13798) + Math.cos(13799) * 24;
+acc += Math.sin(13799) + Math.cos(13800) * 25;
+acc += Math.sin(13800) + Math.cos(13801) * 26;
+acc += Math.sin(13801) + Math.cos(13802) * 27;
+acc += Math.sin(13802) + Math.cos(13803) * 28;
+acc += Math.sin(13803) + Math.cos(13804) * 29;
+acc += Math.sin(13804) + Math.cos(13805) * 30;
+acc += Math.sin(13805) + Math.cos(13806) * 31;
+acc += Math.sin(13806) + Math.cos(13807) * 32;
+acc += Math.sin(13807) + Math.cos(13808) * 33;
+acc += Math.sin(13808) + Math.cos(13809) * 34;
+acc += Math.sin(13809) + Math.cos(13810) * 35;
+acc += Math.sin(13810) + Math.cos(13811) * 36;
+acc += Math.sin(13811) + Math.cos(13812) * 37;
+acc += Math.sin(13812) + Math.cos(13813) * 38;
+acc += Math.sin(13813) + Math.cos(13814) * 39;
+acc += Math.sin(13814) + Math.cos(13815) * 40;
+acc += Math.sin(13815) + Math.cos(13816) * 41;
+acc += Math.sin(13816) + Math.cos(13817) * 42;
+acc += Math.sin(13817) + Math.cos(13818) * 43;
+acc += Math.sin(13818) + Math.cos(13819) * 44;
+acc += Math.sin(13819) + Math.cos(13820) * 45;
+acc += Math.sin(13820) + Math.cos(13821) * 46;
+acc += Math.sin(13821) + Math.cos(13822) * 47;
+acc += Math.sin(13822) + Math.cos(13823) * 48;
+acc += Math.sin(13823) + Math.cos(13824) * 49;
+acc += Math.sin(13824) + Math.cos(13825) * 50;
+acc += Math.sin(13825) + Math.cos(13826) * 51;
+acc += Math.sin(13826) + Math.cos(13827) * 52;
+acc += Math.sin(13827) + Math.cos(13828) * 53;
+acc += Math.sin(13828) + Math.cos(13829) * 54;
+acc += Math.sin(13829) + Math.cos(13830) * 55;
+acc += Math.sin(13830) + Math.cos(13831) * 56;
+acc += Math.sin(13831) + Math.cos(13832) * 57;
+acc += Math.sin(13832) + Math.cos(13833) * 58;
+acc += Math.sin(13833) + Math.cos(13834) * 59;
+acc += Math.sin(13834) + Math.cos(13835) * 60;
+acc += Math.sin(13835) + Math.cos(13836) * 61;
+acc += Math.sin(13836) + Math.cos(13837) * 62;
+acc += Math.sin(13837) + Math.cos(13838) * 63;
+acc += Math.sin(13838) + Math.cos(13839) * 64;
+acc += Math.sin(13839) + Math.cos(13840) * 65;
+acc += Math.sin(13840) + Math.cos(13841) * 66;
+acc += Math.sin(13841) + Math.cos(13842) * 67;
+acc += Math.sin(13842) + Math.cos(13843) * 68;
+acc += Math.sin(13843) + Math.cos(13844) * 69;
+acc += Math.sin(13844) + Math.cos(13845) * 70;
+acc += Math.sin(13845) + Math.cos(13846) * 71;
+acc += Math.sin(13846) + Math.cos(13847) * 72;
+acc += Math.sin(13847) + Math.cos(13848) * 73;
+acc += Math.sin(13848) + Math.cos(13849) * 74;
+acc += Math.sin(13849) + Math.cos(13850) * 75;
+acc += Math.sin(13850) + Math.cos(13851) * 76;
+acc += Math.sin(13851) + Math.cos(13852) * 77;
+acc += Math.sin(13852) + Math.cos(13853) * 78;
+acc += Math.sin(13853) + Math.cos(13854) * 79;
+acc += Math.sin(13854) + Math.cos(13855) * 80;
+acc += Math.sin(13855) + Math.cos(13856) * 81;
+acc += Math.sin(13856) + Math.cos(13857) * 82;
+acc += Math.sin(13857) + Math.cos(13858) * 83;
+acc += Math.sin(13858) + Math.cos(13859) * 84;
+acc += Math.sin(13859) + Math.cos(13860) * 85;
+acc += Math.sin(13860) + Math.cos(13861) * 86;
+acc += Math.sin(13861) + Math.cos(13862) * 87;
+acc += Math.sin(13862) + Math.cos(13863) * 88;
+acc += Math.sin(13863) + Math.cos(13864) * 89;
+acc += Math.sin(13864) + Math.cos(13865) * 90;
+acc += Math.sin(13865) + Math.cos(13866) * 91;
+acc += Math.sin(13866) + Math.cos(13867) * 92;
+acc += Math.sin(13867) + Math.cos(13868) * 93;
+acc += Math.sin(13868) + Math.cos(13869) * 94;
+acc += Math.sin(13869) + Math.cos(13870) * 95;
+acc += Math.sin(13870) + Math.cos(13871) * 96;
+acc += Math.sin(13871) + Math.cos(13872) * 0;
+acc += Math.sin(13872) + Math.cos(13873) * 1;
+acc += Math.sin(13873) + Math.cos(13874) * 2;
+acc += Math.sin(13874) + Math.cos(13875) * 3;
+acc += Math.sin(13875) + Math.cos(13876) * 4;
+acc += Math.sin(13876) + Math.cos(13877) * 5;
+acc += Math.sin(13877) + Math.cos(13878) * 6;
+acc += Math.sin(13878) + Math.cos(13879) * 7;
+acc += Math.sin(13879) + Math.cos(13880) * 8;
+acc += Math.sin(13880) + Math.cos(13881) * 9;
+acc += Math.sin(13881) + Math.cos(13882) * 10;
+acc += Math.sin(13882) + Math.cos(13883) * 11;
+acc += Math.sin(13883) + Math.cos(13884) * 12;
+acc += Math.sin(13884) + Math.cos(13885) * 13;
+acc += Math.sin(13885) + Math.cos(13886) * 14;
+acc += Math.sin(13886) + Math.cos(13887) * 15;
+acc += Math.sin(13887) + Math.cos(13888) * 16;
+acc += Math.sin(13888) + Math.cos(13889) * 17;
+acc += Math.sin(13889) + Math.cos(13890) * 18;
+acc += Math.sin(13890) + Math.cos(13891) * 19;
+acc += Math.sin(13891) + Math.cos(13892) * 20;
+acc += Math.sin(13892) + Math.cos(13893) * 21;
+acc += Math.sin(13893) + Math.cos(13894) * 22;
+acc += Math.sin(13894) + Math.cos(13895) * 23;
+acc += Math.sin(13895) + Math.cos(13896) * 24;
+acc += Math.sin(13896) + Math.cos(13897) * 25;
+acc += Math.sin(13897) + Math.cos(13898) * 26;
+acc += Math.sin(13898) + Math.cos(13899) * 27;
+acc += Math.sin(13899) + Math.cos(13900) * 28;
+acc += Math.sin(13900) + Math.cos(13901) * 29;
+acc += Math.sin(13901) + Math.cos(13902) * 30;
+acc += Math.sin(13902) + Math.cos(13903) * 31;
+acc += Math.sin(13903) + Math.cos(13904) * 32;
+acc += Math.sin(13904) + Math.cos(13905) * 33;
+acc += Math.sin(13905) + Math.cos(13906) * 34;
+acc += Math.sin(13906) + Math.cos(13907) * 35;
+acc += Math.sin(13907) + Math.cos(13908) * 36;
+acc += Math.sin(13908) + Math.cos(13909) * 37;
+acc += Math.sin(13909) + Math.cos(13910) * 38;
+acc += Math.sin(13910) + Math.cos(13911) * 39;
+acc += Math.sin(13911) + Math.cos(13912) * 40;
+acc += Math.sin(13912) + Math.cos(13913) * 41;
+acc += Math.sin(13913) + Math.cos(13914) * 42;
+acc += Math.sin(13914) + Math.cos(13915) * 43;
+acc += Math.sin(13915) + Math.cos(13916) * 44;
+acc += Math.sin(13916) + Math.cos(13917) * 45;
+acc += Math.sin(13917) + Math.cos(13918) * 46;
+acc += Math.sin(13918) + Math.cos(13919) * 47;
+acc += Math.sin(13919) + Math.cos(13920) * 48;
+acc += Math.sin(13920) + Math.cos(13921) * 49;
+acc += Math.sin(13921) + Math.cos(13922) * 50;
+acc += Math.sin(13922) + Math.cos(13923) * 51;
+acc += Math.sin(13923) + Math.cos(13924) * 52;
+acc += Math.sin(13924) + Math.cos(13925) * 53;
+acc += Math.sin(13925) + Math.cos(13926) * 54;
+acc += Math.sin(13926) + Math.cos(13927) * 55;
+acc += Math.sin(13927) + Math.cos(13928) * 56;
+acc += Math.sin(13928) + Math.cos(13929) * 57;
+acc += Math.sin(13929) + Math.cos(13930) * 58;
+acc += Math.sin(13930) + Math.cos(13931) * 59;
+acc += Math.sin(13931) + Math.cos(13932) * 60;
+acc += Math.sin(13932) + Math.cos(13933) * 61;
+acc += Math.sin(13933) + Math.cos(13934) * 62;
+acc += Math.sin(13934) + Math.cos(13935) * 63;
+acc += Math.sin(13935) + Math.cos(13936) * 64;
+acc += Math.sin(13936) + Math.cos(13937) * 65;
+acc += Math.sin(13937) + Math.cos(13938) * 66;
+acc += Math.sin(13938) + Math.cos(13939) * 67;
+acc += Math.sin(13939) + Math.cos(13940) * 68;
+acc += Math.sin(13940) + Math.cos(13941) * 69;
+acc += Math.sin(13941) + Math.cos(13942) * 70;
+acc += Math.sin(13942) + Math.cos(13943) * 71;
+acc += Math.sin(13943) + Math.cos(13944) * 72;
+acc += Math.sin(13944) + Math.cos(13945) * 73;
+acc += Math.sin(13945) + Math.cos(13946) * 74;
+acc += Math.sin(13946) + Math.cos(13947) * 75;
+acc += Math.sin(13947) + Math.cos(13948) * 76;
+acc += Math.sin(13948) + Math.cos(13949) * 77;
+acc += Math.sin(13949) + Math.cos(13950) * 78;
+acc += Math.sin(13950) + Math.cos(13951) * 79;
+acc += Math.sin(13951) + Math.cos(13952) * 80;
+acc += Math.sin(13952) + Math.cos(13953) * 81;
+acc += Math.sin(13953) + Math.cos(13954) * 82;
+acc += Math.sin(13954) + Math.cos(13955) * 83;
+acc += Math.sin(13955) + Math.cos(13956) * 84;
+acc += Math.sin(13956) + Math.cos(13957) * 85;
+acc += Math.sin(13957) + Math.cos(13958) * 86;
+acc += Math.sin(13958) + Math.cos(13959) * 87;
+acc += Math.sin(13959) + Math.cos(13960) * 88;
+acc += Math.sin(13960) + Math.cos(13961) * 89;
+acc += Math.sin(13961) + Math.cos(13962) * 90;
+acc += Math.sin(13962) + Math.cos(13963) * 91;
+acc += Math.sin(13963) + Math.cos(13964) * 92;
+acc += Math.sin(13964) + Math.cos(13965) * 93;
+acc += Math.sin(13965) + Math.cos(13966) * 94;
+acc += Math.sin(13966) + Math.cos(13967) * 95;
+acc += Math.sin(13967) + Math.cos(13968) * 96;
+acc += Math.sin(13968) + Math.cos(13969) * 0;
+acc += Math.sin(13969) + Math.cos(13970) * 1;
+acc += Math.sin(13970) + Math.cos(13971) * 2;
+acc += Math.sin(13971) + Math.cos(13972) * 3;
+acc += Math.sin(13972) + Math.cos(13973) * 4;
+acc += Math.sin(13973) + Math.cos(13974) * 5;
+acc += Math.sin(13974) + Math.cos(13975) * 6;
+acc += Math.sin(13975) + Math.cos(13976) * 7;
+acc += Math.sin(13976) + Math.cos(13977) * 8;
+acc += Math.sin(13977) + Math.cos(13978) * 9;
+acc += Math.sin(13978) + Math.cos(13979) * 10;
+acc += Math.sin(13979) + Math.cos(13980) * 11;
+acc += Math.sin(13980) + Math.cos(13981) * 12;
+acc += Math.sin(13981) + Math.cos(13982) * 13;
+acc += Math.sin(13982) + Math.cos(13983) * 14;
+acc += Math.sin(13983) + Math.cos(13984) * 15;
+acc += Math.sin(13984) + Math.cos(13985) * 16;
+acc += Math.sin(13985) + Math.cos(13986) * 17;
+acc += Math.sin(13986) + Math.cos(13987) * 18;
+acc += Math.sin(13987) + Math.cos(13988) * 19;
+acc += Math.sin(13988) + Math.cos(13989) * 20;
+acc += Math.sin(13989) + Math.cos(13990) * 21;
+acc += Math.sin(13990) + Math.cos(13991) * 22;
+acc += Math.sin(13991) + Math.cos(13992) * 23;
+acc += Math.sin(13992) + Math.cos(13993) * 24;
+acc += Math.sin(13993) + Math.cos(13994) * 25;
+acc += Math.sin(13994) + Math.cos(13995) * 26;
+acc += Math.sin(13995) + Math.cos(13996) * 27;
+acc += Math.sin(13996) + Math.cos(13997) * 28;
+acc += Math.sin(13997) + Math.cos(13998) * 29;
+acc += Math.sin(13998) + Math.cos(13999) * 30;
+acc += Math.sin(13999) + Math.cos(14000) * 31;
+acc += Math.sin(14000) + Math.cos(14001) * 32;
+acc += Math.sin(14001) + Math.cos(14002) * 33;
+acc += Math.sin(14002) + Math.cos(14003) * 34;
+acc += Math.sin(14003) + Math.cos(14004) * 35;
+acc += Math.sin(14004) + Math.cos(14005) * 36;
+acc += Math.sin(14005) + Math.cos(14006) * 37;
+acc += Math.sin(14006) + Math.cos(14007) * 38;
+acc += Math.sin(14007) + Math.cos(14008) * 39;
+acc += Math.sin(14008) + Math.cos(14009) * 40;
+acc += Math.sin(14009) + Math.cos(14010) * 41;
+acc += Math.sin(14010) + Math.cos(14011) * 42;
+acc += Math.sin(14011) + Math.cos(14012) * 43;
+acc += Math.sin(14012) + Math.cos(14013) * 44;
+acc += Math.sin(14013) + Math.cos(14014) * 45;
+acc += Math.sin(14014) + Math.cos(14015) * 46;
+acc += Math.sin(14015) + Math.cos(14016) * 47;
+acc += Math.sin(14016) + Math.cos(14017) * 48;
+acc += Math.sin(14017) + Math.cos(14018) * 49;
+acc += Math.sin(14018) + Math.cos(14019) * 50;
+acc += Math.sin(14019) + Math.cos(14020) * 51;
+acc += Math.sin(14020) + Math.cos(14021) * 52;
+acc += Math.sin(14021) + Math.cos(14022) * 53;
+acc += Math.sin(14022) + Math.cos(14023) * 54;
+acc += Math.sin(14023) + Math.cos(14024) * 55;
+acc += Math.sin(14024) + Math.cos(14025) * 56;
+acc += Math.sin(14025) + Math.cos(14026) * 57;
+acc += Math.sin(14026) + Math.cos(14027) * 58;
+acc += Math.sin(14027) + Math.cos(14028) * 59;
+acc += Math.sin(14028) + Math.cos(14029) * 60;
+acc += Math.sin(14029) + Math.cos(14030) * 61;
+acc += Math.sin(14030) + Math.cos(14031) * 62;
+acc += Math.sin(14031) + Math.cos(14032) * 63;
+acc += Math.sin(14032) + Math.cos(14033) * 64;
+acc += Math.sin(14033) + Math.cos(14034) * 65;
+acc += Math.sin(14034) + Math.cos(14035) * 66;
+acc += Math.sin(14035) + Math.cos(14036) * 67;
+acc += Math.sin(14036) + Math.cos(14037) * 68;
+acc += Math.sin(14037) + Math.cos(14038) * 69;
+acc += Math.sin(14038) + Math.cos(14039) * 70;
+acc += Math.sin(14039) + Math.cos(14040) * 71;
+acc += Math.sin(14040) + Math.cos(14041) * 72;
+acc += Math.sin(14041) + Math.cos(14042) * 73;
+acc += Math.sin(14042) + Math.cos(14043) * 74;
+acc += Math.sin(14043) + Math.cos(14044) * 75;
+acc += Math.sin(14044) + Math.cos(14045) * 76;
+acc += Math.sin(14045) + Math.cos(14046) * 77;
+acc += Math.sin(14046) + Math.cos(14047) * 78;
+acc += Math.sin(14047) + Math.cos(14048) * 79;
+acc += Math.sin(14048) + Math.cos(14049) * 80;
+acc += Math.sin(14049) + Math.cos(14050) * 81;
+acc += Math.sin(14050) + Math.cos(14051) * 82;
+acc += Math.sin(14051) + Math.cos(14052) * 83;
+acc += Math.sin(14052) + Math.cos(14053) * 84;
+acc += Math.sin(14053) + Math.cos(14054) * 85;
+acc += Math.sin(14054) + Math.cos(14055) * 86;
+acc += Math.sin(14055) + Math.cos(14056) * 87;
+acc += Math.sin(14056) + Math.cos(14057) * 88;
+acc += Math.sin(14057) + Math.cos(14058) * 89;
+acc += Math.sin(14058) + Math.cos(14059) * 90;
+acc += Math.sin(14059) + Math.cos(14060) * 91;
+acc += Math.sin(14060) + Math.cos(14061) * 92;
+acc += Math.sin(14061) + Math.cos(14062) * 93;
+acc += Math.sin(14062) + Math.cos(14063) * 94;
+acc += Math.sin(14063) + Math.cos(14064) * 95;
+acc += Math.sin(14064) + Math.cos(14065) * 96;
+acc += Math.sin(14065) + Math.cos(14066) * 0;
+acc += Math.sin(14066) + Math.cos(14067) * 1;
+acc += Math.sin(14067) + Math.cos(14068) * 2;
+acc += Math.sin(14068) + Math.cos(14069) * 3;
+acc += Math.sin(14069) + Math.cos(14070) * 4;
+acc += Math.sin(14070) + Math.cos(14071) * 5;
+acc += Math.sin(14071) + Math.cos(14072) * 6;
+acc += Math.sin(14072) + Math.cos(14073) * 7;
+acc += Math.sin(14073) + Math.cos(14074) * 8;
+acc += Math.sin(14074) + Math.cos(14075) * 9;
+acc += Math.sin(14075) + Math.cos(14076) * 10;
+acc += Math.sin(14076) + Math.cos(14077) * 11;
+acc += Math.sin(14077) + Math.cos(14078) * 12;
+acc += Math.sin(14078) + Math.cos(14079) * 13;
+acc += Math.sin(14079) + Math.cos(14080) * 14;
+acc += Math.sin(14080) + Math.cos(14081) * 15;
+acc += Math.sin(14081) + Math.cos(14082) * 16;
+acc += Math.sin(14082) + Math.cos(14083) * 17;
+acc += Math.sin(14083) + Math.cos(14084) * 18;
+acc += Math.sin(14084) + Math.cos(14085) * 19;
+acc += Math.sin(14085) + Math.cos(14086) * 20;
+acc += Math.sin(14086) + Math.cos(14087) * 21;
+acc += Math.sin(14087) + Math.cos(14088) * 22;
+acc += Math.sin(14088) + Math.cos(14089) * 23;
+acc += Math.sin(14089) + Math.cos(14090) * 24;
+acc += Math.sin(14090) + Math.cos(14091) * 25;
+acc += Math.sin(14091) + Math.cos(14092) * 26;
+acc += Math.sin(14092) + Math.cos(14093) * 27;
+acc += Math.sin(14093) + Math.cos(14094) * 28;
+acc += Math.sin(14094) + Math.cos(14095) * 29;
+acc += Math.sin(14095) + Math.cos(14096) * 30;
+acc += Math.sin(14096) + Math.cos(14097) * 31;
+acc += Math.sin(14097) + Math.cos(14098) * 32;
+acc += Math.sin(14098) + Math.cos(14099) * 33;
+acc += Math.sin(14099) + Math.cos(14100) * 34;
+acc += Math.sin(14100) + Math.cos(14101) * 35;
+acc += Math.sin(14101) + Math.cos(14102) * 36;
+acc += Math.sin(14102) + Math.cos(14103) * 37;
+acc += Math.sin(14103) + Math.cos(14104) * 38;
+acc += Math.sin(14104) + Math.cos(14105) * 39;
+acc += Math.sin(14105) + Math.cos(14106) * 40;
+acc += Math.sin(14106) + Math.cos(14107) * 41;
+acc += Math.sin(14107) + Math.cos(14108) * 42;
+acc += Math.sin(14108) + Math.cos(14109) * 43;
+acc += Math.sin(14109) + Math.cos(14110) * 44;
+acc += Math.sin(14110) + Math.cos(14111) * 45;
+acc += Math.sin(14111) + Math.cos(14112) * 46;
+acc += Math.sin(14112) + Math.cos(14113) * 47;
+acc += Math.sin(14113) + Math.cos(14114) * 48;
+acc += Math.sin(14114) + Math.cos(14115) * 49;
+acc += Math.sin(14115) + Math.cos(14116) * 50;
+acc += Math.sin(14116) + Math.cos(14117) * 51;
+acc += Math.sin(14117) + Math.cos(14118) * 52;
+acc += Math.sin(14118) + Math.cos(14119) * 53;
+acc += Math.sin(14119) + Math.cos(14120) * 54;
+acc += Math.sin(14120) + Math.cos(14121) * 55;
+acc += Math.sin(14121) + Math.cos(14122) * 56;
+acc += Math.sin(14122) + Math.cos(14123) * 57;
+acc += Math.sin(14123) + Math.cos(14124) * 58;
+acc += Math.sin(14124) + Math.cos(14125) * 59;
+acc += Math.sin(14125) + Math.cos(14126) * 60;
+acc += Math.sin(14126) + Math.cos(14127) * 61;
+acc += Math.sin(14127) + Math.cos(14128) * 62;
+acc += Math.sin(14128) + Math.cos(14129) * 63;
+acc += Math.sin(14129) + Math.cos(14130) * 64;
+acc += Math.sin(14130) + Math.cos(14131) * 65;
+acc += Math.sin(14131) + Math.cos(14132) * 66;
+acc += Math.sin(14132) + Math.cos(14133) * 67;
+acc += Math.sin(14133) + Math.cos(14134) * 68;
+acc += Math.sin(14134) + Math.cos(14135) * 69;
+acc += Math.sin(14135) + Math.cos(14136) * 70;
+acc += Math.sin(14136) + Math.cos(14137) * 71;
+acc += Math.sin(14137) + Math.cos(14138) * 72;
+acc += Math.sin(14138) + Math.cos(14139) * 73;
+acc += Math.sin(14139) + Math.cos(14140) * 74;
+acc += Math.sin(14140) + Math.cos(14141) * 75;
+acc += Math.sin(14141) + Math.cos(14142) * 76;
+acc += Math.sin(14142) + Math.cos(14143) * 77;
+acc += Math.sin(14143) + Math.cos(14144) * 78;
+acc += Math.sin(14144) + Math.cos(14145) * 79;
+acc += Math.sin(14145) + Math.cos(14146) * 80;
+acc += Math.sin(14146) + Math.cos(14147) * 81;
+acc += Math.sin(14147) + Math.cos(14148) * 82;
+acc += Math.sin(14148) + Math.cos(14149) * 83;
+acc += Math.sin(14149) + Math.cos(14150) * 84;
+acc += Math.sin(14150) + Math.cos(14151) * 85;
+acc += Math.sin(14151) + Math.cos(14152) * 86;
+acc += Math.sin(14152) + Math.cos(14153) * 87;
+acc += Math.sin(14153) + Math.cos(14154) * 88;
+acc += Math.sin(14154) + Math.cos(14155) * 89;
+acc += Math.sin(14155) + Math.cos(14156) * 90;
+acc += Math.sin(14156) + Math.cos(14157) * 91;
+acc += Math.sin(14157) + Math.cos(14158) * 92;
+acc += Math.sin(14158) + Math.cos(14159) * 93;
+acc += Math.sin(14159) + Math.cos(14160) * 94;
+acc += Math.sin(14160) + Math.cos(14161) * 95;
+acc += Math.sin(14161) + Math.cos(14162) * 96;
+acc += Math.sin(14162) + Math.cos(14163) * 0;
+acc += Math.sin(14163) + Math.cos(14164) * 1;
+acc += Math.sin(14164) + Math.cos(14165) * 2;
+acc += Math.sin(14165) + Math.cos(14166) * 3;
+acc += Math.sin(14166) + Math.cos(14167) * 4;
+acc += Math.sin(14167) + Math.cos(14168) * 5;
+acc += Math.sin(14168) + Math.cos(14169) * 6;
+acc += Math.sin(14169) + Math.cos(14170) * 7;
+acc += Math.sin(14170) + Math.cos(14171) * 8;
+acc += Math.sin(14171) + Math.cos(14172) * 9;
+acc += Math.sin(14172) + Math.cos(14173) * 10;
+acc += Math.sin(14173) + Math.cos(14174) * 11;
+acc += Math.sin(14174) + Math.cos(14175) * 12;
+acc += Math.sin(14175) + Math.cos(14176) * 13;
+acc += Math.sin(14176) + Math.cos(14177) * 14;
+acc += Math.sin(14177) + Math.cos(14178) * 15;
+acc += Math.sin(14178) + Math.cos(14179) * 16;
+acc += Math.sin(14179) + Math.cos(14180) * 17;
+acc += Math.sin(14180) + Math.cos(14181) * 18;
+acc += Math.sin(14181) + Math.cos(14182) * 19;
+acc += Math.sin(14182) + Math.cos(14183) * 20;
+acc += Math.sin(14183) + Math.cos(14184) * 21;
+acc += Math.sin(14184) + Math.cos(14185) * 22;
+acc += Math.sin(14185) + Math.cos(14186) * 23;
+acc += Math.sin(14186) + Math.cos(14187) * 24;
+acc += Math.sin(14187) + Math.cos(14188) * 25;
+acc += Math.sin(14188) + Math.cos(14189) * 26;
+acc += Math.sin(14189) + Math.cos(14190) * 27;
+acc += Math.sin(14190) + Math.cos(14191) * 28;
+acc += Math.sin(14191) + Math.cos(14192) * 29;
+acc += Math.sin(14192) + Math.cos(14193) * 30;
+acc += Math.sin(14193) + Math.cos(14194) * 31;
+acc += Math.sin(14194) + Math.cos(14195) * 32;
+acc += Math.sin(14195) + Math.cos(14196) * 33;
+acc += Math.sin(14196) + Math.cos(14197) * 34;
+acc += Math.sin(14197) + Math.cos(14198) * 35;
+acc += Math.sin(14198) + Math.cos(14199) * 36;
+acc += Math.sin(14199) + Math.cos(14200) * 37;
+acc += Math.sin(14200) + Math.cos(14201) * 38;
+acc += Math.sin(14201) + Math.cos(14202) * 39;
+acc += Math.sin(14202) + Math.cos(14203) * 40;
+acc += Math.sin(14203) + Math.cos(14204) * 41;
+acc += Math.sin(14204) + Math.cos(14205) * 42;
+acc += Math.sin(14205) + Math.cos(14206) * 43;
+acc += Math.sin(14206) + Math.cos(14207) * 44;
+acc += Math.sin(14207) + Math.cos(14208) * 45;
+acc += Math.sin(14208) + Math.cos(14209) * 46;
+acc += Math.sin(14209) + Math.cos(14210) * 47;
+acc += Math.sin(14210) + Math.cos(14211) * 48;
+acc += Math.sin(14211) + Math.cos(14212) * 49;
+acc += Math.sin(14212) + Math.cos(14213) * 50;
+acc += Math.sin(14213) + Math.cos(14214) * 51;
+acc += Math.sin(14214) + Math.cos(14215) * 52;
+acc += Math.sin(14215) + Math.cos(14216) * 53;
+acc += Math.sin(14216) + Math.cos(14217) * 54;
+acc += Math.sin(14217) + Math.cos(14218) * 55;
+acc += Math.sin(14218) + Math.cos(14219) * 56;
+acc += Math.sin(14219) + Math.cos(14220) * 57;
+acc += Math.sin(14220) + Math.cos(14221) * 58;
+acc += Math.sin(14221) + Math.cos(14222) * 59;
+acc += Math.sin(14222) + Math.cos(14223) * 60;
+acc += Math.sin(14223) + Math.cos(14224) * 61;
+acc += Math.sin(14224) + Math.cos(14225) * 62;
+acc += Math.sin(14225) + Math.cos(14226) * 63;
+acc += Math.sin(14226) + Math.cos(14227) * 64;
+acc += Math.sin(14227) + Math.cos(14228) * 65;
+acc += Math.sin(14228) + Math.cos(14229) * 66;
+acc += Math.sin(14229) + Math.cos(14230) * 67;
+acc += Math.sin(14230) + Math.cos(14231) * 68;
+acc += Math.sin(14231) + Math.cos(14232) * 69;
+acc += Math.sin(14232) + Math.cos(14233) * 70;
+acc += Math.sin(14233) + Math.cos(14234) * 71;
+acc += Math.sin(14234) + Math.cos(14235) * 72;
+acc += Math.sin(14235) + Math.cos(14236) * 73;
+acc += Math.sin(14236) + Math.cos(14237) * 74;
+acc += Math.sin(14237) + Math.cos(14238) * 75;
+acc += Math.sin(14238) + Math.cos(14239) * 76;
+acc += Math.sin(14239) + Math.cos(14240) * 77;
+acc += Math.sin(14240) + Math.cos(14241) * 78;
+acc += Math.sin(14241) + Math.cos(14242) * 79;
+acc += Math.sin(14242) + Math.cos(14243) * 80;
+acc += Math.sin(14243) + Math.cos(14244) * 81;
+acc += Math.sin(14244) + Math.cos(14245) * 82;
+acc += Math.sin(14245) + Math.cos(14246) * 83;
+acc += Math.sin(14246) + Math.cos(14247) * 84;
+acc += Math.sin(14247) + Math.cos(14248) * 85;
+acc += Math.sin(14248) + Math.cos(14249) * 86;
+acc += Math.sin(14249) + Math.cos(14250) * 87;
+acc += Math.sin(14250) + Math.cos(14251) * 88;
+acc += Math.sin(14251) + Math.cos(14252) * 89;
+acc += Math.sin(14252) + Math.cos(14253) * 90;
+acc += Math.sin(14253) + Math.cos(14254) * 91;
+acc += Math.sin(14254) + Math.cos(14255) * 92;
+acc += Math.sin(14255) + Math.cos(14256) * 93;
+acc += Math.sin(14256) + Math.cos(14257) * 94;
+acc += Math.sin(14257) + Math.cos(14258) * 95;
+acc += Math.sin(14258) + Math.cos(14259) * 96;
+acc += Math.sin(14259) + Math.cos(14260) * 0;
+acc += Math.sin(14260) + Math.cos(14261) * 1;
+acc += Math.sin(14261) + Math.cos(14262) * 2;
+acc += Math.sin(14262) + Math.cos(14263) * 3;
+acc += Math.sin(14263) + Math.cos(14264) * 4;
+acc += Math.sin(14264) + Math.cos(14265) * 5;
+acc += Math.sin(14265) + Math.cos(14266) * 6;
+acc += Math.sin(14266) + Math.cos(14267) * 7;
+acc += Math.sin(14267) + Math.cos(14268) * 8;
+acc += Math.sin(14268) + Math.cos(14269) * 9;
+acc += Math.sin(14269) + Math.cos(14270) * 10;
+acc += Math.sin(14270) + Math.cos(14271) * 11;
+acc += Math.sin(14271) + Math.cos(14272) * 12;
+acc += Math.sin(14272) + Math.cos(14273) * 13;
+acc += Math.sin(14273) + Math.cos(14274) * 14;
+acc += Math.sin(14274) + Math.cos(14275) * 15;
+acc += Math.sin(14275) + Math.cos(14276) * 16;
+acc += Math.sin(14276) + Math.cos(14277) * 17;
+acc += Math.sin(14277) + Math.cos(14278) * 18;
+acc += Math.sin(14278) + Math.cos(14279) * 19;
+acc += Math.sin(14279) + Math.cos(14280) * 20;
+acc += Math.sin(14280) + Math.cos(14281) * 21;
+acc += Math.sin(14281) + Math.cos(14282) * 22;
+acc += Math.sin(14282) + Math.cos(14283) * 23;
+acc += Math.sin(14283) + Math.cos(14284) * 24;
+acc += Math.sin(14284) + Math.cos(14285) * 25;
+acc += Math.sin(14285) + Math.cos(14286) * 26;
+acc += Math.sin(14286) + Math.cos(14287) * 27;
+acc += Math.sin(14287) + Math.cos(14288) * 28;
+acc += Math.sin(14288) + Math.cos(14289) * 29;
+acc += Math.sin(14289) + Math.cos(14290) * 30;
+acc += Math.sin(14290) + Math.cos(14291) * 31;
+acc += Math.sin(14291) + Math.cos(14292) * 32;
+acc += Math.sin(14292) + Math.cos(14293) * 33;
+acc += Math.sin(14293) + Math.cos(14294) * 34;
+acc += Math.sin(14294) + Math.cos(14295) * 35;
+acc += Math.sin(14295) + Math.cos(14296) * 36;
+acc += Math.sin(14296) + Math.cos(14297) * 37;
+acc += Math.sin(14297) + Math.cos(14298) * 38;
+acc += Math.sin(14298) + Math.cos(14299) * 39;
+acc += Math.sin(14299) + Math.cos(14300) * 40;
+acc += Math.sin(14300) + Math.cos(14301) * 41;
+acc += Math.sin(14301) + Math.cos(14302) * 42;
+acc += Math.sin(14302) + Math.cos(14303) * 43;
+acc += Math.sin(14303) + Math.cos(14304) * 44;
+acc += Math.sin(14304) + Math.cos(14305) * 45;
+acc += Math.sin(14305) + Math.cos(14306) * 46;
+acc += Math.sin(14306) + Math.cos(14307) * 47;
+acc += Math.sin(14307) + Math.cos(14308) * 48;
+acc += Math.sin(14308) + Math.cos(14309) * 49;
+acc += Math.sin(14309) + Math.cos(14310) * 50;
+acc += Math.sin(14310) + Math.cos(14311) * 51;
+acc += Math.sin(14311) + Math.cos(14312) * 52;
+acc += Math.sin(14312) + Math.cos(14313) * 53;
+acc += Math.sin(14313) + Math.cos(14314) * 54;
+acc += Math.sin(14314) + Math.cos(14315) * 55;
+acc += Math.sin(14315) + Math.cos(14316) * 56;
+acc += Math.sin(14316) + Math.cos(14317) * 57;
+acc += Math.sin(14317) + Math.cos(14318) * 58;
+acc += Math.sin(14318) + Math.cos(14319) * 59;
+acc += Math.sin(14319) + Math.cos(14320) * 60;
+acc += Math.sin(14320) + Math.cos(14321) * 61;
+acc += Math.sin(14321) + Math.cos(14322) * 62;
+acc += Math.sin(14322) + Math.cos(14323) * 63;
+acc += Math.sin(14323) + Math.cos(14324) * 64;
+acc += Math.sin(14324) + Math.cos(14325) * 65;
+acc += Math.sin(14325) + Math.cos(14326) * 66;
+acc += Math.sin(14326) + Math.cos(14327) * 67;
+acc += Math.sin(14327) + Math.cos(14328) * 68;
+acc += Math.sin(14328) + Math.cos(14329) * 69;
+acc += Math.sin(14329) + Math.cos(14330) * 70;
+acc += Math.sin(14330) + Math.cos(14331) * 71;
+acc += Math.sin(14331) + Math.cos(14332) * 72;
+acc += Math.sin(14332) + Math.cos(14333) * 73;
+acc += Math.sin(14333) + Math.cos(14334) * 74;
+acc += Math.sin(14334) + Math.cos(14335) * 75;
+acc += Math.sin(14335) + Math.cos(14336) * 76;
+acc += Math.sin(14336) + Math.cos(14337) * 77;
+acc += Math.sin(14337) + Math.cos(14338) * 78;
+acc += Math.sin(14338) + Math.cos(14339) * 79;
+acc += Math.sin(14339) + Math.cos(14340) * 80;
+acc += Math.sin(14340) + Math.cos(14341) * 81;
+acc += Math.sin(14341) + Math.cos(14342) * 82;
+acc += Math.sin(14342) + Math.cos(14343) * 83;
+acc += Math.sin(14343) + Math.cos(14344) * 84;
+acc += Math.sin(14344) + Math.cos(14345) * 85;
+acc += Math.sin(14345) + Math.cos(14346) * 86;
+acc += Math.sin(14346) + Math.cos(14347) * 87;
+acc += Math.sin(14347) + Math.cos(14348) * 88;
+acc += Math.sin(14348) + Math.cos(14349) * 89;
+acc += Math.sin(14349) + Math.cos(14350) * 90;
+acc += Math.sin(14350) + Math.cos(14351) * 91;
+acc += Math.sin(14351) + Math.cos(14352) * 92;
+acc += Math.sin(14352) + Math.cos(14353) * 93;
+acc += Math.sin(14353) + Math.cos(14354) * 94;
+acc += Math.sin(14354) + Math.cos(14355) * 95;
+acc += Math.sin(14355) + Math.cos(14356) * 96;
+acc += Math.sin(14356) + Math.cos(14357) * 0;
+acc += Math.sin(14357) + Math.cos(14358) * 1;
+acc += Math.sin(14358) + Math.cos(14359) * 2;
+acc += Math.sin(14359) + Math.cos(14360) * 3;
+acc += Math.sin(14360) + Math.cos(14361) * 4;
+acc += Math.sin(14361) + Math.cos(14362) * 5;
+acc += Math.sin(14362) + Math.cos(14363) * 6;
+acc += Math.sin(14363) + Math.cos(14364) * 7;
+acc += Math.sin(14364) + Math.cos(14365) * 8;
+acc += Math.sin(14365) + Math.cos(14366) * 9;
+acc += Math.sin(14366) + Math.cos(14367) * 10;
+acc += Math.sin(14367) + Math.cos(14368) * 11;
+acc += Math.sin(14368) + Math.cos(14369) * 12;
+acc += Math.sin(14369) + Math.cos(14370) * 13;
+acc += Math.sin(14370) + Math.cos(14371) * 14;
+acc += Math.sin(14371) + Math.cos(14372) * 15;
+acc += Math.sin(14372) + Math.cos(14373) * 16;
+acc += Math.sin(14373) + Math.cos(14374) * 17;
+acc += Math.sin(14374) + Math.cos(14375) * 18;
+acc += Math.sin(14375) + Math.cos(14376) * 19;
+acc += Math.sin(14376) + Math.cos(14377) * 20;
+acc += Math.sin(14377) + Math.cos(14378) * 21;
+acc += Math.sin(14378) + Math.cos(14379) * 22;
+acc += Math.sin(14379) + Math.cos(14380) * 23;
+acc += Math.sin(14380) + Math.cos(14381) * 24;
+acc += Math.sin(14381) + Math.cos(14382) * 25;
+acc += Math.sin(14382) + Math.cos(14383) * 26;
+acc += Math.sin(14383) + Math.cos(14384) * 27;
+acc += Math.sin(14384) + Math.cos(14385) * 28;
+acc += Math.sin(14385) + Math.cos(14386) * 29;
+acc += Math.sin(14386) + Math.cos(14387) * 30;
+acc += Math.sin(14387) + Math.cos(14388) * 31;
+acc += Math.sin(14388) + Math.cos(14389) * 32;
+acc += Math.sin(14389) + Math.cos(14390) * 33;
+acc += Math.sin(14390) + Math.cos(14391) * 34;
+acc += Math.sin(14391) + Math.cos(14392) * 35;
+acc += Math.sin(14392) + Math.cos(14393) * 36;
+acc += Math.sin(14393) + Math.cos(14394) * 37;
+acc += Math.sin(14394) + Math.cos(14395) * 38;
+acc += Math.sin(14395) + Math.cos(14396) * 39;
+acc += Math.sin(14396) + Math.cos(14397) * 40;
+acc += Math.sin(14397) + Math.cos(14398) * 41;
+acc += Math.sin(14398) + Math.cos(14399) * 42;
+acc += Math.sin(14399) + Math.cos(14400) * 43;
+acc += Math.sin(14400) + Math.cos(14401) * 44;
+acc += Math.sin(14401) + Math.cos(14402) * 45;
+acc += Math.sin(14402) + Math.cos(14403) * 46;
+acc += Math.sin(14403) + Math.cos(14404) * 47;
+acc += Math.sin(14404) + Math.cos(14405) * 48;
+acc += Math.sin(14405) + Math.cos(14406) * 49;
+acc += Math.sin(14406) + Math.cos(14407) * 50;
+acc += Math.sin(14407) + Math.cos(14408) * 51;
+acc += Math.sin(14408) + Math.cos(14409) * 52;
+acc += Math.sin(14409) + Math.cos(14410) * 53;
+acc += Math.sin(14410) + Math.cos(14411) * 54;
+acc += Math.sin(14411) + Math.cos(14412) * 55;
+acc += Math.sin(14412) + Math.cos(14413) * 56;
+acc += Math.sin(14413) + Math.cos(14414) * 57;
+acc += Math.sin(14414) + Math.cos(14415) * 58;
+acc += Math.sin(14415) + Math.cos(14416) * 59;
+acc += Math.sin(14416) + Math.cos(14417) * 60;
+acc += Math.sin(14417) + Math.cos(14418) * 61;
+acc += Math.sin(14418) + Math.cos(14419) * 62;
+acc += Math.sin(14419) + Math.cos(14420) * 63;
+acc += Math.sin(14420) + Math.cos(14421) * 64;
+acc += Math.sin(14421) + Math.cos(14422) * 65;
+acc += Math.sin(14422) + Math.cos(14423) * 66;
+acc += Math.sin(14423) + Math.cos(14424) * 67;
+acc += Math.sin(14424) + Math.cos(14425) * 68;
+acc += Math.sin(14425) + Math.cos(14426) * 69;
+acc += Math.sin(14426) + Math.cos(14427) * 70;
+acc += Math.sin(14427) + Math.cos(14428) * 71;
+acc += Math.sin(14428) + Math.cos(14429) * 72;
+acc += Math.sin(14429) + Math.cos(14430) * 73;
+acc += Math.sin(14430) + Math.cos(14431) * 74;
+acc += Math.sin(14431) + Math.cos(14432) * 75;
+acc += Math.sin(14432) + Math.cos(14433) * 76;
+acc += Math.sin(14433) + Math.cos(14434) * 77;
+acc += Math.sin(14434) + Math.cos(14435) * 78;
+acc += Math.sin(14435) + Math.cos(14436) * 79;
+acc += Math.sin(14436) + Math.cos(14437) * 80;
+acc += Math.sin(14437) + Math.cos(14438) * 81;
+acc += Math.sin(14438) + Math.cos(14439) * 82;
+acc += Math.sin(14439) + Math.cos(14440) * 83;
+acc += Math.sin(14440) + Math.cos(14441) * 84;
+acc += Math.sin(14441) + Math.cos(14442) * 85;
+acc += Math.sin(14442) + Math.cos(14443) * 86;
+acc += Math.sin(14443) + Math.cos(14444) * 87;
+acc += Math.sin(14444) + Math.cos(14445) * 88;
+acc += Math.sin(14445) + Math.cos(14446) * 89;
+acc += Math.sin(14446) + Math.cos(14447) * 90;
+acc += Math.sin(14447) + Math.cos(14448) * 91;
+acc += Math.sin(14448) + Math.cos(14449) * 92;
+acc += Math.sin(14449) + Math.cos(14450) * 93;
+acc += Math.sin(14450) + Math.cos(14451) * 94;
+acc += Math.sin(14451) + Math.cos(14452) * 95;
+acc += Math.sin(14452) + Math.cos(14453) * 96;
+acc += Math.sin(14453) + Math.cos(14454) * 0;
+acc += Math.sin(14454) + Math.cos(14455) * 1;
+acc += Math.sin(14455) + Math.cos(14456) * 2;
+acc += Math.sin(14456) + Math.cos(14457) * 3;
+acc += Math.sin(14457) + Math.cos(14458) * 4;
+acc += Math.sin(14458) + Math.cos(14459) * 5;
+acc += Math.sin(14459) + Math.cos(14460) * 6;
+acc += Math.sin(14460) + Math.cos(14461) * 7;
+acc += Math.sin(14461) + Math.cos(14462) * 8;
+acc += Math.sin(14462) + Math.cos(14463) * 9;
+acc += Math.sin(14463) + Math.cos(14464) * 10;
+acc += Math.sin(14464) + Math.cos(14465) * 11;
+acc += Math.sin(14465) + Math.cos(14466) * 12;
+acc += Math.sin(14466) + Math.cos(14467) * 13;
+acc += Math.sin(14467) + Math.cos(14468) * 14;
+acc += Math.sin(14468) + Math.cos(14469) * 15;
+acc += Math.sin(14469) + Math.cos(14470) * 16;
+acc += Math.sin(14470) + Math.cos(14471) * 17;
+acc += Math.sin(14471) + Math.cos(14472) * 18;
+acc += Math.sin(14472) + Math.cos(14473) * 19;
+acc += Math.sin(14473) + Math.cos(14474) * 20;
+acc += Math.sin(14474) + Math.cos(14475) * 21;
+acc += Math.sin(14475) + Math.cos(14476) * 22;
+acc += Math.sin(14476) + Math.cos(14477) * 23;
+acc += Math.sin(14477) + Math.cos(14478) * 24;
+acc += Math.sin(14478) + Math.cos(14479) * 25;
+acc += Math.sin(14479) + Math.cos(14480) * 26;
+acc += Math.sin(14480) + Math.cos(14481) * 27;
+acc += Math.sin(14481) + Math.cos(14482) * 28;
+acc += Math.sin(14482) + Math.cos(14483) * 29;
+acc += Math.sin(14483) + Math.cos(14484) * 30;
+acc += Math.sin(14484) + Math.cos(14485) * 31;
+acc += Math.sin(14485) + Math.cos(14486) * 32;
+acc += Math.sin(14486) + Math.cos(14487) * 33;
+acc += Math.sin(14487) + Math.cos(14488) * 34;
+acc += Math.sin(14488) + Math.cos(14489) * 35;
+acc += Math.sin(14489) + Math.cos(14490) * 36;
+acc += Math.sin(14490) + Math.cos(14491) * 37;
+acc += Math.sin(14491) + Math.cos(14492) * 38;
+acc += Math.sin(14492) + Math.cos(14493) * 39;
+acc += Math.sin(14493) + Math.cos(14494) * 40;
+acc += Math.sin(14494) + Math.cos(14495) * 41;
+acc += Math.sin(14495) + Math.cos(14496) * 42;
+acc += Math.sin(14496) + Math.cos(14497) * 43;
+acc += Math.sin(14497) + Math.cos(14498) * 44;
+acc += Math.sin(14498) + Math.cos(14499) * 45;
+acc += Math.sin(14499) + Math.cos(14500) * 46;
+acc += Math.sin(14500) + Math.cos(14501) * 47;
+acc += Math.sin(14501) + Math.cos(14502) * 48;
+acc += Math.sin(14502) + Math.cos(14503) * 49;
+acc += Math.sin(14503) + Math.cos(14504) * 50;
+acc += Math.sin(14504) + Math.cos(14505) * 51;
+acc += Math.sin(14505) + Math.cos(14506) * 52;
+acc += Math.sin(14506) + Math.cos(14507) * 53;
+acc += Math.sin(14507) + Math.cos(14508) * 54;
+acc += Math.sin(14508) + Math.cos(14509) * 55;
+acc += Math.sin(14509) + Math.cos(14510) * 56;
+acc += Math.sin(14510) + Math.cos(14511) * 57;
+acc += Math.sin(14511) + Math.cos(14512) * 58;
+acc += Math.sin(14512) + Math.cos(14513) * 59;
+acc += Math.sin(14513) + Math.cos(14514) * 60;
+acc += Math.sin(14514) + Math.cos(14515) * 61;
+acc += Math.sin(14515) + Math.cos(14516) * 62;
+acc += Math.sin(14516) + Math.cos(14517) * 63;
+acc += Math.sin(14517) + Math.cos(14518) * 64;
+acc += Math.sin(14518) + Math.cos(14519) * 65;
+acc += Math.sin(14519) + Math.cos(14520) * 66;
+acc += Math.sin(14520) + Math.cos(14521) * 67;
+acc += Math.sin(14521) + Math.cos(14522) * 68;
+acc += Math.sin(14522) + Math.cos(14523) * 69;
+acc += Math.sin(14523) + Math.cos(14524) * 70;
+acc += Math.sin(14524) + Math.cos(14525) * 71;
+acc += Math.sin(14525) + Math.cos(14526) * 72;
+acc += Math.sin(14526) + Math.cos(14527) * 73;
+acc += Math.sin(14527) + Math.cos(14528) * 74;
+acc += Math.sin(14528) + Math.cos(14529) * 75;
+acc += Math.sin(14529) + Math.cos(14530) * 76;
+acc += Math.sin(14530) + Math.cos(14531) * 77;
+acc += Math.sin(14531) + Math.cos(14532) * 78;
+acc += Math.sin(14532) + Math.cos(14533) * 79;
+acc += Math.sin(14533) + Math.cos(14534) * 80;
+acc += Math.sin(14534) + Math.cos(14535) * 81;
+acc += Math.sin(14535) + Math.cos(14536) * 82;
+acc += Math.sin(14536) + Math.cos(14537) * 83;
+acc += Math.sin(14537) + Math.cos(14538) * 84;
+acc += Math.sin(14538) + Math.cos(14539) * 85;
+acc += Math.sin(14539) + Math.cos(14540) * 86;
+acc += Math.sin(14540) + Math.cos(14541) * 87;
+acc += Math.sin(14541) + Math.cos(14542) * 88;
+acc += Math.sin(14542) + Math.cos(14543) * 89;
+acc += Math.sin(14543) + Math.cos(14544) * 90;
+acc += Math.sin(14544) + Math.cos(14545) * 91;
+acc += Math.sin(14545) + Math.cos(14546) * 92;
+acc += Math.sin(14546) + Math.cos(14547) * 93;
+acc += Math.sin(14547) + Math.cos(14548) * 94;
+acc += Math.sin(14548) + Math.cos(14549) * 95;
+acc += Math.sin(14549) + Math.cos(14550) * 96;
+acc += Math.sin(14550) + Math.cos(14551) * 0;
+acc += Math.sin(14551) + Math.cos(14552) * 1;
+acc += Math.sin(14552) + Math.cos(14553) * 2;
+acc += Math.sin(14553) + Math.cos(14554) * 3;
+acc += Math.sin(14554) + Math.cos(14555) * 4;
+acc += Math.sin(14555) + Math.cos(14556) * 5;
+acc += Math.sin(14556) + Math.cos(14557) * 6;
+acc += Math.sin(14557) + Math.cos(14558) * 7;
+acc += Math.sin(14558) + Math.cos(14559) * 8;
+acc += Math.sin(14559) + Math.cos(14560) * 9;
+acc += Math.sin(14560) + Math.cos(14561) * 10;
+acc += Math.sin(14561) + Math.cos(14562) * 11;
+acc += Math.sin(14562) + Math.cos(14563) * 12;
+acc += Math.sin(14563) + Math.cos(14564) * 13;
+acc += Math.sin(14564) + Math.cos(14565) * 14;
+acc += Math.sin(14565) + Math.cos(14566) * 15;
+acc += Math.sin(14566) + Math.cos(14567) * 16;
+acc += Math.sin(14567) + Math.cos(14568) * 17;
+acc += Math.sin(14568) + Math.cos(14569) * 18;
+acc += Math.sin(14569) + Math.cos(14570) * 19;
+acc += Math.sin(14570) + Math.cos(14571) * 20;
+acc += Math.sin(14571) + Math.cos(14572) * 21;
+acc += Math.sin(14572) + Math.cos(14573) * 22;
+acc += Math.sin(14573) + Math.cos(14574) * 23;
+acc += Math.sin(14574) + Math.cos(14575) * 24;
+acc += Math.sin(14575) + Math.cos(14576) * 25;
+acc += Math.sin(14576) + Math.cos(14577) * 26;
+acc += Math.sin(14577) + Math.cos(14578) * 27;
+acc += Math.sin(14578) + Math.cos(14579) * 28;
+acc += Math.sin(14579) + Math.cos(14580) * 29;
+acc += Math.sin(14580) + Math.cos(14581) * 30;
+acc += Math.sin(14581) + Math.cos(14582) * 31;
+acc += Math.sin(14582) + Math.cos(14583) * 32;
+acc += Math.sin(14583) + Math.cos(14584) * 33;
+acc += Math.sin(14584) + Math.cos(14585) * 34;
+acc += Math.sin(14585) + Math.cos(14586) * 35;
+acc += Math.sin(14586) + Math.cos(14587) * 36;
+acc += Math.sin(14587) + Math.cos(14588) * 37;
+acc += Math.sin(14588) + Math.cos(14589) * 38;
+acc += Math.sin(14589) + Math.cos(14590) * 39;
+acc += Math.sin(14590) + Math.cos(14591) * 40;
+acc += Math.sin(14591) + Math.cos(14592) * 41;
+acc += Math.sin(14592) + Math.cos(14593) * 42;
+acc += Math.sin(14593) + Math.cos(14594) * 43;
+acc += Math.sin(14594) + Math.cos(14595) * 44;
+acc += Math.sin(14595) + Math.cos(14596) * 45;
+acc += Math.sin(14596) + Math.cos(14597) * 46;
+acc += Math.sin(14597) + Math.cos(14598) * 47;
+acc += Math.sin(14598) + Math.cos(14599) * 48;
+acc += Math.sin(14599) + Math.cos(14600) * 49;
+acc += Math.sin(14600) + Math.cos(14601) * 50;
+acc += Math.sin(14601) + Math.cos(14602) * 51;
+acc += Math.sin(14602) + Math.cos(14603) * 52;
+acc += Math.sin(14603) + Math.cos(14604) * 53;
+acc += Math.sin(14604) + Math.cos(14605) * 54;
+acc += Math.sin(14605) + Math.cos(14606) * 55;
+acc += Math.sin(14606) + Math.cos(14607) * 56;
+acc += Math.sin(14607) + Math.cos(14608) * 57;
+acc += Math.sin(14608) + Math.cos(14609) * 58;
+acc += Math.sin(14609) + Math.cos(14610) * 59;
+acc += Math.sin(14610) + Math.cos(14611) * 60;
+acc += Math.sin(14611) + Math.cos(14612) * 61;
+acc += Math.sin(14612) + Math.cos(14613) * 62;
+acc += Math.sin(14613) + Math.cos(14614) * 63;
+acc += Math.sin(14614) + Math.cos(14615) * 64;
+acc += Math.sin(14615) + Math.cos(14616) * 65;
+acc += Math.sin(14616) + Math.cos(14617) * 66;
+acc += Math.sin(14617) + Math.cos(14618) * 67;
+acc += Math.sin(14618) + Math.cos(14619) * 68;
+acc += Math.sin(14619) + Math.cos(14620) * 69;
+acc += Math.sin(14620) + Math.cos(14621) * 70;
+acc += Math.sin(14621) + Math.cos(14622) * 71;
+acc += Math.sin(14622) + Math.cos(14623) * 72;
+acc += Math.sin(14623) + Math.cos(14624) * 73;
+acc += Math.sin(14624) + Math.cos(14625) * 74;
+acc += Math.sin(14625) + Math.cos(14626) * 75;
+acc += Math.sin(14626) + Math.cos(14627) * 76;
+acc += Math.sin(14627) + Math.cos(14628) * 77;
+acc += Math.sin(14628) + Math.cos(14629) * 78;
+acc += Math.sin(14629) + Math.cos(14630) * 79;
+acc += Math.sin(14630) + Math.cos(14631) * 80;
+acc += Math.sin(14631) + Math.cos(14632) * 81;
+acc += Math.sin(14632) + Math.cos(14633) * 82;
+acc += Math.sin(14633) + Math.cos(14634) * 83;
+acc += Math.sin(14634) + Math.cos(14635) * 84;
+acc += Math.sin(14635) + Math.cos(14636) * 85;
+acc += Math.sin(14636) + Math.cos(14637) * 86;
+acc += Math.sin(14637) + Math.cos(14638) * 87;
+acc += Math.sin(14638) + Math.cos(14639) * 88;
+acc += Math.sin(14639) + Math.cos(14640) * 89;
+acc += Math.sin(14640) + Math.cos(14641) * 90;
+acc += Math.sin(14641) + Math.cos(14642) * 91;
+acc += Math.sin(14642) + Math.cos(14643) * 92;
+acc += Math.sin(14643) + Math.cos(14644) * 93;
+acc += Math.sin(14644) + Math.cos(14645) * 94;
+acc += Math.sin(14645) + Math.cos(14646) * 95;
+acc += Math.sin(14646) + Math.cos(14647) * 96;
+acc += Math.sin(14647) + Math.cos(14648) * 0;
+acc += Math.sin(14648) + Math.cos(14649) * 1;
+acc += Math.sin(14649) + Math.cos(14650) * 2;
+acc += Math.sin(14650) + Math.cos(14651) * 3;
+acc += Math.sin(14651) + Math.cos(14652) * 4;
+acc += Math.sin(14652) + Math.cos(14653) * 5;
+acc += Math.sin(14653) + Math.cos(14654) * 6;
+acc += Math.sin(14654) + Math.cos(14655) * 7;
+acc += Math.sin(14655) + Math.cos(14656) * 8;
+acc += Math.sin(14656) + Math.cos(14657) * 9;
+acc += Math.sin(14657) + Math.cos(14658) * 10;
+acc += Math.sin(14658) + Math.cos(14659) * 11;
+acc += Math.sin(14659) + Math.cos(14660) * 12;
+acc += Math.sin(14660) + Math.cos(14661) * 13;
+acc += Math.sin(14661) + Math.cos(14662) * 14;
+acc += Math.sin(14662) + Math.cos(14663) * 15;
+acc += Math.sin(14663) + Math.cos(14664) * 16;
+acc += Math.sin(14664) + Math.cos(14665) * 17;
+acc += Math.sin(14665) + Math.cos(14666) * 18;
+acc += Math.sin(14666) + Math.cos(14667) * 19;
+acc += Math.sin(14667) + Math.cos(14668) * 20;
+acc += Math.sin(14668) + Math.cos(14669) * 21;
+acc += Math.sin(14669) + Math.cos(14670) * 22;
+acc += Math.sin(14670) + Math.cos(14671) * 23;
+acc += Math.sin(14671) + Math.cos(14672) * 24;
+acc += Math.sin(14672) + Math.cos(14673) * 25;
+acc += Math.sin(14673) + Math.cos(14674) * 26;
+acc += Math.sin(14674) + Math.cos(14675) * 27;
+acc += Math.sin(14675) + Math.cos(14676) * 28;
+acc += Math.sin(14676) + Math.cos(14677) * 29;
+acc += Math.sin(14677) + Math.cos(14678) * 30;
+acc += Math.sin(14678) + Math.cos(14679) * 31;
+acc += Math.sin(14679) + Math.cos(14680) * 32;
+acc += Math.sin(14680) + Math.cos(14681) * 33;
+acc += Math.sin(14681) + Math.cos(14682) * 34;
+acc += Math.sin(14682) + Math.cos(14683) * 35;
+acc += Math.sin(14683) + Math.cos(14684) * 36;
+acc += Math.sin(14684) + Math.cos(14685) * 37;
+acc += Math.sin(14685) + Math.cos(14686) * 38;
+acc += Math.sin(14686) + Math.cos(14687) * 39;
+acc += Math.sin(14687) + Math.cos(14688) * 40;
+acc += Math.sin(14688) + Math.cos(14689) * 41;
+acc += Math.sin(14689) + Math.cos(14690) * 42;
+acc += Math.sin(14690) + Math.cos(14691) * 43;
+acc += Math.sin(14691) + Math.cos(14692) * 44;
+acc += Math.sin(14692) + Math.cos(14693) * 45;
+acc += Math.sin(14693) + Math.cos(14694) * 46;
+acc += Math.sin(14694) + Math.cos(14695) * 47;
+acc += Math.sin(14695) + Math.cos(14696) * 48;
+acc += Math.sin(14696) + Math.cos(14697) * 49;
+acc += Math.sin(14697) + Math.cos(14698) * 50;
+acc += Math.sin(14698) + Math.cos(14699) * 51;
+acc += Math.sin(14699) + Math.cos(14700) * 52;
+acc += Math.sin(14700) + Math.cos(14701) * 53;
+acc += Math.sin(14701) + Math.cos(14702) * 54;
+acc += Math.sin(14702) + Math.cos(14703) * 55;
+acc += Math.sin(14703) + Math.cos(14704) * 56;
+acc += Math.sin(14704) + Math.cos(14705) * 57;
+acc += Math.sin(14705) + Math.cos(14706) * 58;
+acc += Math.sin(14706) + Math.cos(14707) * 59;
+acc += Math.sin(14707) + Math.cos(14708) * 60;
+acc += Math.sin(14708) + Math.cos(14709) * 61;
+acc += Math.sin(14709) + Math.cos(14710) * 62;
+acc += Math.sin(14710) + Math.cos(14711) * 63;
+acc += Math.sin(14711) + Math.cos(14712) * 64;
+acc += Math.sin(14712) + Math.cos(14713) * 65;
+acc += Math.sin(14713) + Math.cos(14714) * 66;
+acc += Math.sin(14714) + Math.cos(14715) * 67;
+acc += Math.sin(14715) + Math.cos(14716) * 68;
+acc += Math.sin(14716) + Math.cos(14717) * 69;
+acc += Math.sin(14717) + Math.cos(14718) * 70;
+acc += Math.sin(14718) + Math.cos(14719) * 71;
+acc += Math.sin(14719) + Math.cos(14720) * 72;
+acc += Math.sin(14720) + Math.cos(14721) * 73;
+acc += Math.sin(14721) + Math.cos(14722) * 74;
+acc += Math.sin(14722) + Math.cos(14723) * 75;
+acc += Math.sin(14723) + Math.cos(14724) * 76;
+acc += Math.sin(14724) + Math.cos(14725) * 77;
+acc += Math.sin(14725) + Math.cos(14726) * 78;
+acc += Math.sin(14726) + Math.cos(14727) * 79;
+acc += Math.sin(14727) + Math.cos(14728) * 80;
+acc += Math.sin(14728) + Math.cos(14729) * 81;
+acc += Math.sin(14729) + Math.cos(14730) * 82;
+acc += Math.sin(14730) + Math.cos(14731) * 83;
+acc += Math.sin(14731) + Math.cos(14732) * 84;
+acc += Math.sin(14732) + Math.cos(14733) * 85;
+acc += Math.sin(14733) + Math.cos(14734) * 86;
+acc += Math.sin(14734) + Math.cos(14735) * 87;
+acc += Math.sin(14735) + Math.cos(14736) * 88;
+acc += Math.sin(14736) + Math.cos(14737) * 89;
+acc += Math.sin(14737) + Math.cos(14738) * 90;
+acc += Math.sin(14738) + Math.cos(14739) * 91;
+acc += Math.sin(14739) + Math.cos(14740) * 92;
+acc += Math.sin(14740) + Math.cos(14741) * 93;
+acc += Math.sin(14741) + Math.cos(14742) * 94;
+acc += Math.sin(14742) + Math.cos(14743) * 95;
+acc += Math.sin(14743) + Math.cos(14744) * 96;
+acc += Math.sin(14744) + Math.cos(14745) * 0;
+acc += Math.sin(14745) + Math.cos(14746) * 1;
+acc += Math.sin(14746) + Math.cos(14747) * 2;
+acc += Math.sin(14747) + Math.cos(14748) * 3;
+acc += Math.sin(14748) + Math.cos(14749) * 4;
+acc += Math.sin(14749) + Math.cos(14750) * 5;
+acc += Math.sin(14750) + Math.cos(14751) * 6;
+acc += Math.sin(14751) + Math.cos(14752) * 7;
+acc += Math.sin(14752) + Math.cos(14753) * 8;
+acc += Math.sin(14753) + Math.cos(14754) * 9;
+acc += Math.sin(14754) + Math.cos(14755) * 10;
+acc += Math.sin(14755) + Math.cos(14756) * 11;
+acc += Math.sin(14756) + Math.cos(14757) * 12;
+acc += Math.sin(14757) + Math.cos(14758) * 13;
+acc += Math.sin(14758) + Math.cos(14759) * 14;
+acc += Math.sin(14759) + Math.cos(14760) * 15;
+acc += Math.sin(14760) + Math.cos(14761) * 16;
+acc += Math.sin(14761) + Math.cos(14762) * 17;
+acc += Math.sin(14762) + Math.cos(14763) * 18;
+acc += Math.sin(14763) + Math.cos(14764) * 19;
+acc += Math.sin(14764) + Math.cos(14765) * 20;
+acc += Math.sin(14765) + Math.cos(14766) * 21;
+acc += Math.sin(14766) + Math.cos(14767) * 22;
+acc += Math.sin(14767) + Math.cos(14768) * 23;
+acc += Math.sin(14768) + Math.cos(14769) * 24;
+acc += Math.sin(14769) + Math.cos(14770) * 25;
+acc += Math.sin(14770) + Math.cos(14771) * 26;
+acc += Math.sin(14771) + Math.cos(14772) * 27;
+acc += Math.sin(14772) + Math.cos(14773) * 28;
+acc += Math.sin(14773) + Math.cos(14774) * 29;
+acc += Math.sin(14774) + Math.cos(14775) * 30;
+acc += Math.sin(14775) + Math.cos(14776) * 31;
+acc += Math.sin(14776) + Math.cos(14777) * 32;
+acc += Math.sin(14777) + Math.cos(14778) * 33;
+acc += Math.sin(14778) + Math.cos(14779) * 34;
+acc += Math.sin(14779) + Math.cos(14780) * 35;
+acc += Math.sin(14780) + Math.cos(14781) * 36;
+acc += Math.sin(14781) + Math.cos(14782) * 37;
+acc += Math.sin(14782) + Math.cos(14783) * 38;
+acc += Math.sin(14783) + Math.cos(14784) * 39;
+acc += Math.sin(14784) + Math.cos(14785) * 40;
+acc += Math.sin(14785) + Math.cos(14786) * 41;
+acc += Math.sin(14786) + Math.cos(14787) * 42;
+acc += Math.sin(14787) + Math.cos(14788) * 43;
+acc += Math.sin(14788) + Math.cos(14789) * 44;
+acc += Math.sin(14789) + Math.cos(14790) * 45;
+acc += Math.sin(14790) + Math.cos(14791) * 46;
+acc += Math.sin(14791) + Math.cos(14792) * 47;
+acc += Math.sin(14792) + Math.cos(14793) * 48;
+acc += Math.sin(14793) + Math.cos(14794) * 49;
+acc += Math.sin(14794) + Math.cos(14795) * 50;
+acc += Math.sin(14795) + Math.cos(14796) * 51;
+acc += Math.sin(14796) + Math.cos(14797) * 52;
+acc += Math.sin(14797) + Math.cos(14798) * 53;
+acc += Math.sin(14798) + Math.cos(14799) * 54;
+acc += Math.sin(14799) + Math.cos(14800) * 55;
+acc += Math.sin(14800) + Math.cos(14801) * 56;
+acc += Math.sin(14801) + Math.cos(14802) * 57;
+acc += Math.sin(14802) + Math.cos(14803) * 58;
+acc += Math.sin(14803) + Math.cos(14804) * 59;
+acc += Math.sin(14804) + Math.cos(14805) * 60;
+acc += Math.sin(14805) + Math.cos(14806) * 61;
+acc += Math.sin(14806) + Math.cos(14807) * 62;
+acc += Math.sin(14807) + Math.cos(14808) * 63;
+acc += Math.sin(14808) + Math.cos(14809) * 64;
+acc += Math.sin(14809) + Math.cos(14810) * 65;
+acc += Math.sin(14810) + Math.cos(14811) * 66;
+acc += Math.sin(14811) + Math.cos(14812) * 67;
+acc += Math.sin(14812) + Math.cos(14813) * 68;
+acc += Math.sin(14813) + Math.cos(14814) * 69;
+acc += Math.sin(14814) + Math.cos(14815) * 70;
+acc += Math.sin(14815) + Math.cos(14816) * 71;
+acc += Math.sin(14816) + Math.cos(14817) * 72;
+acc += Math.sin(14817) + Math.cos(14818) * 73;
+acc += Math.sin(14818) + Math.cos(14819) * 74;
+acc += Math.sin(14819) + Math.cos(14820) * 75;
+acc += Math.sin(14820) + Math.cos(14821) * 76;
+acc += Math.sin(14821) + Math.cos(14822) * 77;
+acc += Math.sin(14822) + Math.cos(14823) * 78;
+acc += Math.sin(14823) + Math.cos(14824) * 79;
+acc += Math.sin(14824) + Math.cos(14825) * 80;
+acc += Math.sin(14825) + Math.cos(14826) * 81;
+acc += Math.sin(14826) + Math.cos(14827) * 82;
+acc += Math.sin(14827) + Math.cos(14828) * 83;
+acc += Math.sin(14828) + Math.cos(14829) * 84;
+acc += Math.sin(14829) + Math.cos(14830) * 85;
+acc += Math.sin(14830) + Math.cos(14831) * 86;
+acc += Math.sin(14831) + Math.cos(14832) * 87;
+acc += Math.sin(14832) + Math.cos(14833) * 88;
+acc += Math.sin(14833) + Math.cos(14834) * 89;
+acc += Math.sin(14834) + Math.cos(14835) * 90;
+acc += Math.sin(14835) + Math.cos(14836) * 91;
+acc += Math.sin(14836) + Math.cos(14837) * 92;
+acc += Math.sin(14837) + Math.cos(14838) * 93;
+acc += Math.sin(14838) + Math.cos(14839) * 94;
+acc += Math.sin(14839) + Math.cos(14840) * 95;
+acc += Math.sin(14840) + Math.cos(14841) * 96;
+acc += Math.sin(14841) + Math.cos(14842) * 0;
+acc += Math.sin(14842) + Math.cos(14843) * 1;
+acc += Math.sin(14843) + Math.cos(14844) * 2;
+acc += Math.sin(14844) + Math.cos(14845) * 3;
+acc += Math.sin(14845) + Math.cos(14846) * 4;
+acc += Math.sin(14846) + Math.cos(14847) * 5;
+acc += Math.sin(14847) + Math.cos(14848) * 6;
+acc += Math.sin(14848) + Math.cos(14849) * 7;
+acc += Math.sin(14849) + Math.cos(14850) * 8;
+acc += Math.sin(14850) + Math.cos(14851) * 9;
+acc += Math.sin(14851) + Math.cos(14852) * 10;
+acc += Math.sin(14852) + Math.cos(14853) * 11;
+acc += Math.sin(14853) + Math.cos(14854) * 12;
+acc += Math.sin(14854) + Math.cos(14855) * 13;
+acc += Math.sin(14855) + Math.cos(14856) * 14;
+acc += Math.sin(14856) + Math.cos(14857) * 15;
+acc += Math.sin(14857) + Math.cos(14858) * 16;
+acc += Math.sin(14858) + Math.cos(14859) * 17;
+acc += Math.sin(14859) + Math.cos(14860) * 18;
+acc += Math.sin(14860) + Math.cos(14861) * 19;
+acc += Math.sin(14861) + Math.cos(14862) * 20;
+acc += Math.sin(14862) + Math.cos(14863) * 21;
+acc += Math.sin(14863) + Math.cos(14864) * 22;
+acc += Math.sin(14864) + Math.cos(14865) * 23;
+acc += Math.sin(14865) + Math.cos(14866) * 24;
+acc += Math.sin(14866) + Math.cos(14867) * 25;
+acc += Math.sin(14867) + Math.cos(14868) * 26;
+acc += Math.sin(14868) + Math.cos(14869) * 27;
+acc += Math.sin(14869) + Math.cos(14870) * 28;
+acc += Math.sin(14870) + Math.cos(14871) * 29;
+acc += Math.sin(14871) + Math.cos(14872) * 30;
+acc += Math.sin(14872) + Math.cos(14873) * 31;
+acc += Math.sin(14873) + Math.cos(14874) * 32;
+acc += Math.sin(14874) + Math.cos(14875) * 33;
+acc += Math.sin(14875) + Math.cos(14876) * 34;
+acc += Math.sin(14876) + Math.cos(14877) * 35;
+acc += Math.sin(14877) + Math.cos(14878) * 36;
+acc += Math.sin(14878) + Math.cos(14879) * 37;
+acc += Math.sin(14879) + Math.cos(14880) * 38;
+acc += Math.sin(14880) + Math.cos(14881) * 39;
+acc += Math.sin(14881) + Math.cos(14882) * 40;
+acc += Math.sin(14882) + Math.cos(14883) * 41;
+acc += Math.sin(14883) + Math.cos(14884) * 42;
+acc += Math.sin(14884) + Math.cos(14885) * 43;
+acc += Math.sin(14885) + Math.cos(14886) * 44;
+acc += Math.sin(14886) + Math.cos(14887) * 45;
+acc += Math.sin(14887) + Math.cos(14888) * 46;
+acc += Math.sin(14888) + Math.cos(14889) * 47;
+acc += Math.sin(14889) + Math.cos(14890) * 48;
+acc += Math.sin(14890) + Math.cos(14891) * 49;
+acc += Math.sin(14891) + Math.cos(14892) * 50;
+acc += Math.sin(14892) + Math.cos(14893) * 51;
+acc += Math.sin(14893) + Math.cos(14894) * 52;
+acc += Math.sin(14894) + Math.cos(14895) * 53;
+acc += Math.sin(14895) + Math.cos(14896) * 54;
+acc += Math.sin(14896) + Math.cos(14897) * 55;
+acc += Math.sin(14897) + Math.cos(14898) * 56;
+acc += Math.sin(14898) + Math.cos(14899) * 57;
+acc += Math.sin(14899) + Math.cos(14900) * 58;
+acc += Math.sin(14900) + Math.cos(14901) * 59;
+acc += Math.sin(14901) + Math.cos(14902) * 60;
+acc += Math.sin(14902) + Math.cos(14903) * 61;
+acc += Math.sin(14903) + Math.cos(14904) * 62;
+acc += Math.sin(14904) + Math.cos(14905) * 63;
+acc += Math.sin(14905) + Math.cos(14906) * 64;
+acc += Math.sin(14906) + Math.cos(14907) * 65;
+acc += Math.sin(14907) + Math.cos(14908) * 66;
+acc += Math.sin(14908) + Math.cos(14909) * 67;
+acc += Math.sin(14909) + Math.cos(14910) * 68;
+acc += Math.sin(14910) + Math.cos(14911) * 69;
+acc += Math.sin(14911) + Math.cos(14912) * 70;
+acc += Math.sin(14912) + Math.cos(14913) * 71;
+acc += Math.sin(14913) + Math.cos(14914) * 72;
+acc += Math.sin(14914) + Math.cos(14915) * 73;
+acc += Math.sin(14915) + Math.cos(14916) * 74;
+acc += Math.sin(14916) + Math.cos(14917) * 75;
+acc += Math.sin(14917) + Math.cos(14918) * 76;
+acc += Math.sin(14918) + Math.cos(14919) * 77;
+acc += Math.sin(14919) + Math.cos(14920) * 78;
+acc += Math.sin(14920) + Math.cos(14921) * 79;
+acc += Math.sin(14921) + Math.cos(14922) * 80;
+acc += Math.sin(14922) + Math.cos(14923) * 81;
+acc += Math.sin(14923) + Math.cos(14924) * 82;
+acc += Math.sin(14924) + Math.cos(14925) * 83;
+acc += Math.sin(14925) + Math.cos(14926) * 84;
+acc += Math.sin(14926) + Math.cos(14927) * 85;
+acc += Math.sin(14927) + Math.cos(14928) * 86;
+acc += Math.sin(14928) + Math.cos(14929) * 87;
+acc += Math.sin(14929) + Math.cos(14930) * 88;
+acc += Math.sin(14930) + Math.cos(14931) * 89;
+acc += Math.sin(14931) + Math.cos(14932) * 90;
+acc += Math.sin(14932) + Math.cos(14933) * 91;
+acc += Math.sin(14933) + Math.cos(14934) * 92;
+acc += Math.sin(14934) + Math.cos(14935) * 93;
+acc += Math.sin(14935) + Math.cos(14936) * 94;
+acc += Math.sin(14936) + Math.cos(14937) * 95;
+acc += Math.sin(14937) + Math.cos(14938) * 96;
+acc += Math.sin(14938) + Math.cos(14939) * 0;
+acc += Math.sin(14939) + Math.cos(14940) * 1;
+acc += Math.sin(14940) + Math.cos(14941) * 2;
+acc += Math.sin(14941) + Math.cos(14942) * 3;
+acc += Math.sin(14942) + Math.cos(14943) * 4;
+acc += Math.sin(14943) + Math.cos(14944) * 5;
+acc += Math.sin(14944) + Math.cos(14945) * 6;
+acc += Math.sin(14945) + Math.cos(14946) * 7;
+acc += Math.sin(14946) + Math.cos(14947) * 8;
+acc += Math.sin(14947) + Math.cos(14948) * 9;
+acc += Math.sin(14948) + Math.cos(14949) * 10;
+acc += Math.sin(14949) + Math.cos(14950) * 11;
+acc += Math.sin(14950) + Math.cos(14951) * 12;
+acc += Math.sin(14951) + Math.cos(14952) * 13;
+acc += Math.sin(14952) + Math.cos(14953) * 14;
+acc += Math.sin(14953) + Math.cos(14954) * 15;
+acc += Math.sin(14954) + Math.cos(14955) * 16;
+acc += Math.sin(14955) + Math.cos(14956) * 17;
+acc += Math.sin(14956) + Math.cos(14957) * 18;
+acc += Math.sin(14957) + Math.cos(14958) * 19;
+acc += Math.sin(14958) + Math.cos(14959) * 20;
+acc += Math.sin(14959) + Math.cos(14960) * 21;
+acc += Math.sin(14960) + Math.cos(14961) * 22;
+acc += Math.sin(14961) + Math.cos(14962) * 23;
+acc += Math.sin(14962) + Math.cos(14963) * 24;
+acc += Math.sin(14963) + Math.cos(14964) * 25;
+acc += Math.sin(14964) + Math.cos(14965) * 26;
+acc += Math.sin(14965) + Math.cos(14966) * 27;
+acc += Math.sin(14966) + Math.cos(14967) * 28;
+acc += Math.sin(14967) + Math.cos(14968) * 29;
+acc += Math.sin(14968) + Math.cos(14969) * 30;
+acc += Math.sin(14969) + Math.cos(14970) * 31;
+acc += Math.sin(14970) + Math.cos(14971) * 32;
+acc += Math.sin(14971) + Math.cos(14972) * 33;
+acc += Math.sin(14972) + Math.cos(14973) * 34;
+acc += Math.sin(14973) + Math.cos(14974) * 35;
+acc += Math.sin(14974) + Math.cos(14975) * 36;
+acc += Math.sin(14975) + Math.cos(14976) * 37;
+acc += Math.sin(14976) + Math.cos(14977) * 38;
+acc += Math.sin(14977) + Math.cos(14978) * 39;
+acc += Math.sin(14978) + Math.cos(14979) * 40;
+acc += Math.sin(14979) + Math.cos(14980) * 41;
+acc += Math.sin(14980) + Math.cos(14981) * 42;
+acc += Math.sin(14981) + Math.cos(14982) * 43;
+acc += Math.sin(14982) + Math.cos(14983) * 44;
+acc += Math.sin(14983) + Math.cos(14984) * 45;
+acc += Math.sin(14984) + Math.cos(14985) * 46;
+acc += Math.sin(14985) + Math.cos(14986) * 47;
+acc += Math.sin(14986) + Math.cos(14987) * 48;
+acc += Math.sin(14987) + Math.cos(14988) * 49;
+acc += Math.sin(14988) + Math.cos(14989) * 50;
+acc += Math.sin(14989) + Math.cos(14990) * 51;
+acc += Math.sin(14990) + Math.cos(14991) * 52;
+acc += Math.sin(14991) + Math.cos(14992) * 53;
+acc += Math.sin(14992) + Math.cos(14993) * 54;
+acc += Math.sin(14993) + Math.cos(14994) * 55;
+acc += Math.sin(14994) + Math.cos(14995) * 56;
+acc += Math.sin(14995) + Math.cos(14996) * 57;
+acc += Math.sin(14996) + Math.cos(14997) * 58;
+acc += Math.sin(14997) + Math.cos(14998) * 59;
+acc += Math.sin(14998) + Math.cos(14999) * 60;
+acc += Math.sin(14999) + Math.cos(15000) * 61;
+acc += Math.sin(15000) + Math.cos(15001) * 62;
+acc += Math.sin(15001) + Math.cos(15002) * 63;
+acc += Math.sin(15002) + Math.cos(15003) * 64;
+acc += Math.sin(15003) + Math.cos(15004) * 65;
+acc += Math.sin(15004) + Math.cos(15005) * 66;
+acc += Math.sin(15005) + Math.cos(15006) * 67;
+acc += Math.sin(15006) + Math.cos(15007) * 68;
+acc += Math.sin(15007) + Math.cos(15008) * 69;
+acc += Math.sin(15008) + Math.cos(15009) * 70;
+acc += Math.sin(15009) + Math.cos(15010) * 71;
+acc += Math.sin(15010) + Math.cos(15011) * 72;
+acc += Math.sin(15011) + Math.cos(15012) * 73;
+acc += Math.sin(15012) + Math.cos(15013) * 74;
+acc += Math.sin(15013) + Math.cos(15014) * 75;
+acc += Math.sin(15014) + Math.cos(15015) * 76;
+acc += Math.sin(15015) + Math.cos(15016) * 77;
+acc += Math.sin(15016) + Math.cos(15017) * 78;
+acc += Math.sin(15017) + Math.cos(15018) * 79;
+acc += Math.sin(15018) + Math.cos(15019) * 80;
+acc += Math.sin(15019) + Math.cos(15020) * 81;
+acc += Math.sin(15020) + Math.cos(15021) * 82;
+acc += Math.sin(15021) + Math.cos(15022) * 83;
+acc += Math.sin(15022) + Math.cos(15023) * 84;
+acc += Math.sin(15023) + Math.cos(15024) * 85;
+acc += Math.sin(15024) + Math.cos(15025) * 86;
+acc += Math.sin(15025) + Math.cos(15026) * 87;
+acc += Math.sin(15026) + Math.cos(15027) * 88;
+acc += Math.sin(15027) + Math.cos(15028) * 89;
+acc += Math.sin(15028) + Math.cos(15029) * 90;
+acc += Math.sin(15029) + Math.cos(15030) * 91;
+acc += Math.sin(15030) + Math.cos(15031) * 92;
+acc += Math.sin(15031) + Math.cos(15032) * 93;
+acc += Math.sin(15032) + Math.cos(15033) * 94;
+acc += Math.sin(15033) + Math.cos(15034) * 95;
+acc += Math.sin(15034) + Math.cos(15035) * 96;
+acc += Math.sin(15035) + Math.cos(15036) * 0;
+acc += Math.sin(15036) + Math.cos(15037) * 1;
+acc += Math.sin(15037) + Math.cos(15038) * 2;
+acc += Math.sin(15038) + Math.cos(15039) * 3;
+acc += Math.sin(15039) + Math.cos(15040) * 4;
+acc += Math.sin(15040) + Math.cos(15041) * 5;
+acc += Math.sin(15041) + Math.cos(15042) * 6;
+acc += Math.sin(15042) + Math.cos(15043) * 7;
+acc += Math.sin(15043) + Math.cos(15044) * 8;
+acc += Math.sin(15044) + Math.cos(15045) * 9;
+acc += Math.sin(15045) + Math.cos(15046) * 10;
+acc += Math.sin(15046) + Math.cos(15047) * 11;
+acc += Math.sin(15047) + Math.cos(15048) * 12;
+acc += Math.sin(15048) + Math.cos(15049) * 13;
+acc += Math.sin(15049) + Math.cos(15050) * 14;
+acc += Math.sin(15050) + Math.cos(15051) * 15;
+acc += Math.sin(15051) + Math.cos(15052) * 16;
+acc += Math.sin(15052) + Math.cos(15053) * 17;
+acc += Math.sin(15053) + Math.cos(15054) * 18;
+acc += Math.sin(15054) + Math.cos(15055) * 19;
+acc += Math.sin(15055) + Math.cos(15056) * 20;
+acc += Math.sin(15056) + Math.cos(15057) * 21;
+acc += Math.sin(15057) + Math.cos(15058) * 22;
+acc += Math.sin(15058) + Math.cos(15059) * 23;
+acc += Math.sin(15059) + Math.cos(15060) * 24;
+acc += Math.sin(15060) + Math.cos(15061) * 25;
+acc += Math.sin(15061) + Math.cos(15062) * 26;
+acc += Math.sin(15062) + Math.cos(15063) * 27;
+acc += Math.sin(15063) + Math.cos(15064) * 28;
+acc += Math.sin(15064) + Math.cos(15065) * 29;
+acc += Math.sin(15065) + Math.cos(15066) * 30;
+acc += Math.sin(15066) + Math.cos(15067) * 31;
+acc += Math.sin(15067) + Math.cos(15068) * 32;
+acc += Math.sin(15068) + Math.cos(15069) * 33;
+acc += Math.sin(15069) + Math.cos(15070) * 34;
+acc += Math.sin(15070) + Math.cos(15071) * 35;
+acc += Math.sin(15071) + Math.cos(15072) * 36;
+acc += Math.sin(15072) + Math.cos(15073) * 37;
+acc += Math.sin(15073) + Math.cos(15074) * 38;
+acc += Math.sin(15074) + Math.cos(15075) * 39;
+acc += Math.sin(15075) + Math.cos(15076) * 40;
+acc += Math.sin(15076) + Math.cos(15077) * 41;
+acc += Math.sin(15077) + Math.cos(15078) * 42;
+acc += Math.sin(15078) + Math.cos(15079) * 43;
+acc += Math.sin(15079) + Math.cos(15080) * 44;
+acc += Math.sin(15080) + Math.cos(15081) * 45;
+acc += Math.sin(15081) + Math.cos(15082) * 46;
+acc += Math.sin(15082) + Math.cos(15083) * 47;
+acc += Math.sin(15083) + Math.cos(15084) * 48;
+acc += Math.sin(15084) + Math.cos(15085) * 49;
+acc += Math.sin(15085) + Math.cos(15086) * 50;
+acc += Math.sin(15086) + Math.cos(15087) * 51;
+acc += Math.sin(15087) + Math.cos(15088) * 52;
+acc += Math.sin(15088) + Math.cos(15089) * 53;
+acc += Math.sin(15089) + Math.cos(15090) * 54;
+acc += Math.sin(15090) + Math.cos(15091) * 55;
+acc += Math.sin(15091) + Math.cos(15092) * 56;
+acc += Math.sin(15092) + Math.cos(15093) * 57;
+acc += Math.sin(15093) + Math.cos(15094) * 58;
+acc += Math.sin(15094) + Math.cos(15095) * 59;
+acc += Math.sin(15095) + Math.cos(15096) * 60;
+acc += Math.sin(15096) + Math.cos(15097) * 61;
+acc += Math.sin(15097) + Math.cos(15098) * 62;
+acc += Math.sin(15098) + Math.cos(15099) * 63;
+acc += Math.sin(15099) + Math.cos(15100) * 64;
+acc += Math.sin(15100) + Math.cos(15101) * 65;
+acc += Math.sin(15101) + Math.cos(15102) * 66;
+acc += Math.sin(15102) + Math.cos(15103) * 67;
+acc += Math.sin(15103) + Math.cos(15104) * 68;
+acc += Math.sin(15104) + Math.cos(15105) * 69;
+acc += Math.sin(15105) + Math.cos(15106) * 70;
+acc += Math.sin(15106) + Math.cos(15107) * 71;
+acc += Math.sin(15107) + Math.cos(15108) * 72;
+acc += Math.sin(15108) + Math.cos(15109) * 73;
+acc += Math.sin(15109) + Math.cos(15110) * 74;
+acc += Math.sin(15110) + Math.cos(15111) * 75;
+acc += Math.sin(15111) + Math.cos(15112) * 76;
+acc += Math.sin(15112) + Math.cos(15113) * 77;
+acc += Math.sin(15113) + Math.cos(15114) * 78;
+acc += Math.sin(15114) + Math.cos(15115) * 79;
+acc += Math.sin(15115) + Math.cos(15116) * 80;
+acc += Math.sin(15116) + Math.cos(15117) * 81;
+acc += Math.sin(15117) + Math.cos(15118) * 82;
+acc += Math.sin(15118) + Math.cos(15119) * 83;
+acc += Math.sin(15119) + Math.cos(15120) * 84;
+acc += Math.sin(15120) + Math.cos(15121) * 85;
+acc += Math.sin(15121) + Math.cos(15122) * 86;
+acc += Math.sin(15122) + Math.cos(15123) * 87;
+acc += Math.sin(15123) + Math.cos(15124) * 88;
+acc += Math.sin(15124) + Math.cos(15125) * 89;
+acc += Math.sin(15125) + Math.cos(15126) * 90;
+acc += Math.sin(15126) + Math.cos(15127) * 91;
+acc += Math.sin(15127) + Math.cos(15128) * 92;
+acc += Math.sin(15128) + Math.cos(15129) * 93;
+acc += Math.sin(15129) + Math.cos(15130) * 94;
+acc += Math.sin(15130) + Math.cos(15131) * 95;
+acc += Math.sin(15131) + Math.cos(15132) * 96;
+acc += Math.sin(15132) + Math.cos(15133) * 0;
+acc += Math.sin(15133) + Math.cos(15134) * 1;
+acc += Math.sin(15134) + Math.cos(15135) * 2;
+acc += Math.sin(15135) + Math.cos(15136) * 3;
+acc += Math.sin(15136) + Math.cos(15137) * 4;
+acc += Math.sin(15137) + Math.cos(15138) * 5;
+acc += Math.sin(15138) + Math.cos(15139) * 6;
+acc += Math.sin(15139) + Math.cos(15140) * 7;
+acc += Math.sin(15140) + Math.cos(15141) * 8;
+acc += Math.sin(15141) + Math.cos(15142) * 9;
+acc += Math.sin(15142) + Math.cos(15143) * 10;
+acc += Math.sin(15143) + Math.cos(15144) * 11;
+acc += Math.sin(15144) + Math.cos(15145) * 12;
+acc += Math.sin(15145) + Math.cos(15146) * 13;
+acc += Math.sin(15146) + Math.cos(15147) * 14;
+acc += Math.sin(15147) + Math.cos(15148) * 15;
+acc += Math.sin(15148) + Math.cos(15149) * 16;
+acc += Math.sin(15149) + Math.cos(15150) * 17;
+acc += Math.sin(15150) + Math.cos(15151) * 18;
+acc += Math.sin(15151) + Math.cos(15152) * 19;
+acc += Math.sin(15152) + Math.cos(15153) * 20;
+acc += Math.sin(15153) + Math.cos(15154) * 21;
+acc += Math.sin(15154) + Math.cos(15155) * 22;
+acc += Math.sin(15155) + Math.cos(15156) * 23;
+acc += Math.sin(15156) + Math.cos(15157) * 24;
+acc += Math.sin(15157) + Math.cos(15158) * 25;
+acc += Math.sin(15158) + Math.cos(15159) * 26;
+acc += Math.sin(15159) + Math.cos(15160) * 27;
+acc += Math.sin(15160) + Math.cos(15161) * 28;
+acc += Math.sin(15161) + Math.cos(15162) * 29;
+acc += Math.sin(15162) + Math.cos(15163) * 30;
+acc += Math.sin(15163) + Math.cos(15164) * 31;
+acc += Math.sin(15164) + Math.cos(15165) * 32;
+acc += Math.sin(15165) + Math.cos(15166) * 33;
+acc += Math.sin(15166) + Math.cos(15167) * 34;
+acc += Math.sin(15167) + Math.cos(15168) * 35;
+acc += Math.sin(15168) + Math.cos(15169) * 36;
+acc += Math.sin(15169) + Math.cos(15170) * 37;
+acc += Math.sin(15170) + Math.cos(15171) * 38;
+acc += Math.sin(15171) + Math.cos(15172) * 39;
+acc += Math.sin(15172) + Math.cos(15173) * 40;
+acc += Math.sin(15173) + Math.cos(15174) * 41;
+acc += Math.sin(15174) + Math.cos(15175) * 42;
+acc += Math.sin(15175) + Math.cos(15176) * 43;
+acc += Math.sin(15176) + Math.cos(15177) * 44;
+acc += Math.sin(15177) + Math.cos(15178) * 45;
+acc += Math.sin(15178) + Math.cos(15179) * 46;
+acc += Math.sin(15179) + Math.cos(15180) * 47;
+acc += Math.sin(15180) + Math.cos(15181) * 48;
+acc += Math.sin(15181) + Math.cos(15182) * 49;
+acc += Math.sin(15182) + Math.cos(15183) * 50;
+acc += Math.sin(15183) + Math.cos(15184) * 51;
+acc += Math.sin(15184) + Math.cos(15185) * 52;
+acc += Math.sin(15185) + Math.cos(15186) * 53;
+acc += Math.sin(15186) + Math.cos(15187) * 54;
+acc += Math.sin(15187) + Math.cos(15188) * 55;
+acc += Math.sin(15188) + Math.cos(15189) * 56;
+acc += Math.sin(15189) + Math.cos(15190) * 57;
+acc += Math.sin(15190) + Math.cos(15191) * 58;
+acc += Math.sin(15191) + Math.cos(15192) * 59;
+acc += Math.sin(15192) + Math.cos(15193) * 60;
+acc += Math.sin(15193) + Math.cos(15194) * 61;
+acc += Math.sin(15194) + Math.cos(15195) * 62;
+acc += Math.sin(15195) + Math.cos(15196) * 63;
+acc += Math.sin(15196) + Math.cos(15197) * 64;
+acc += Math.sin(15197) + Math.cos(15198) * 65;
+acc += Math.sin(15198) + Math.cos(15199) * 66;
+acc += Math.sin(15199) + Math.cos(15200) * 67;
+acc += Math.sin(15200) + Math.cos(15201) * 68;
+acc += Math.sin(15201) + Math.cos(15202) * 69;
+acc += Math.sin(15202) + Math.cos(15203) * 70;
+acc += Math.sin(15203) + Math.cos(15204) * 71;
+acc += Math.sin(15204) + Math.cos(15205) * 72;
+acc += Math.sin(15205) + Math.cos(15206) * 73;
+acc += Math.sin(15206) + Math.cos(15207) * 74;
+acc += Math.sin(15207) + Math.cos(15208) * 75;
+acc += Math.sin(15208) + Math.cos(15209) * 76;
+acc += Math.sin(15209) + Math.cos(15210) * 77;
+acc += Math.sin(15210) + Math.cos(15211) * 78;
+acc += Math.sin(15211) + Math.cos(15212) * 79;
+acc += Math.sin(15212) + Math.cos(15213) * 80;
+acc += Math.sin(15213) + Math.cos(15214) * 81;
+acc += Math.sin(15214) + Math.cos(15215) * 82;
+acc += Math.sin(15215) + Math.cos(15216) * 83;
+acc += Math.sin(15216) + Math.cos(15217) * 84;
+acc += Math.sin(15217) + Math.cos(15218) * 85;
+acc += Math.sin(15218) + Math.cos(15219) * 86;
+acc += Math.sin(15219) + Math.cos(15220) * 87;
+acc += Math.sin(15220) + Math.cos(15221) * 88;
+acc += Math.sin(15221) + Math.cos(15222) * 89;
+acc += Math.sin(15222) + Math.cos(15223) * 90;
+acc += Math.sin(15223) + Math.cos(15224) * 91;
+acc += Math.sin(15224) + Math.cos(15225) * 92;
+acc += Math.sin(15225) + Math.cos(15226) * 93;
+acc += Math.sin(15226) + Math.cos(15227) * 94;
+acc += Math.sin(15227) + Math.cos(15228) * 95;
+acc += Math.sin(15228) + Math.cos(15229) * 96;
+acc += Math.sin(15229) + Math.cos(15230) * 0;
+acc += Math.sin(15230) + Math.cos(15231) * 1;
+acc += Math.sin(15231) + Math.cos(15232) * 2;
+acc += Math.sin(15232) + Math.cos(15233) * 3;
+acc += Math.sin(15233) + Math.cos(15234) * 4;
+acc += Math.sin(15234) + Math.cos(15235) * 5;
+acc += Math.sin(15235) + Math.cos(15236) * 6;
+acc += Math.sin(15236) + Math.cos(15237) * 7;
+acc += Math.sin(15237) + Math.cos(15238) * 8;
+acc += Math.sin(15238) + Math.cos(15239) * 9;
+acc += Math.sin(15239) + Math.cos(15240) * 10;
+acc += Math.sin(15240) + Math.cos(15241) * 11;
+acc += Math.sin(15241) + Math.cos(15242) * 12;
+acc += Math.sin(15242) + Math.cos(15243) * 13;
+acc += Math.sin(15243) + Math.cos(15244) * 14;
+acc += Math.sin(15244) + Math.cos(15245) * 15;
+acc += Math.sin(15245) + Math.cos(15246) * 16;
+acc += Math.sin(15246) + Math.cos(15247) * 17;
+acc += Math.sin(15247) + Math.cos(15248) * 18;
+acc += Math.sin(15248) + Math.cos(15249) * 19;
+acc += Math.sin(15249) + Math.cos(15250) * 20;
+acc += Math.sin(15250) + Math.cos(15251) * 21;
+acc += Math.sin(15251) + Math.cos(15252) * 22;
+acc += Math.sin(15252) + Math.cos(15253) * 23;
+acc += Math.sin(15253) + Math.cos(15254) * 24;
+acc += Math.sin(15254) + Math.cos(15255) * 25;
+acc += Math.sin(15255) + Math.cos(15256) * 26;
+acc += Math.sin(15256) + Math.cos(15257) * 27;
+acc += Math.sin(15257) + Math.cos(15258) * 28;
+acc += Math.sin(15258) + Math.cos(15259) * 29;
+acc += Math.sin(15259) + Math.cos(15260) * 30;
+acc += Math.sin(15260) + Math.cos(15261) * 31;
+acc += Math.sin(15261) + Math.cos(15262) * 32;
+acc += Math.sin(15262) + Math.cos(15263) * 33;
+acc += Math.sin(15263) + Math.cos(15264) * 34;
+acc += Math.sin(15264) + Math.cos(15265) * 35;
+acc += Math.sin(15265) + Math.cos(15266) * 36;
+acc += Math.sin(15266) + Math.cos(15267) * 37;
+acc += Math.sin(15267) + Math.cos(15268) * 38;
+acc += Math.sin(15268) + Math.cos(15269) * 39;
+acc += Math.sin(15269) + Math.cos(15270) * 40;
+acc += Math.sin(15270) + Math.cos(15271) * 41;
+acc += Math.sin(15271) + Math.cos(15272) * 42;
+acc += Math.sin(15272) + Math.cos(15273) * 43;
+acc += Math.sin(15273) + Math.cos(15274) * 44;
+acc += Math.sin(15274) + Math.cos(15275) * 45;
+acc += Math.sin(15275) + Math.cos(15276) * 46;
+acc += Math.sin(15276) + Math.cos(15277) * 47;
+acc += Math.sin(15277) + Math.cos(15278) * 48;
+acc += Math.sin(15278) + Math.cos(15279) * 49;
+acc += Math.sin(15279) + Math.cos(15280) * 50;
+acc += Math.sin(15280) + Math.cos(15281) * 51;
+acc += Math.sin(15281) + Math.cos(15282) * 52;
+acc += Math.sin(15282) + Math.cos(15283) * 53;
+acc += Math.sin(15283) + Math.cos(15284) * 54;
+acc += Math.sin(15284) + Math.cos(15285) * 55;
+acc += Math.sin(15285) + Math.cos(15286) * 56;
+acc += Math.sin(15286) + Math.cos(15287) * 57;
+acc += Math.sin(15287) + Math.cos(15288) * 58;
+acc += Math.sin(15288) + Math.cos(15289) * 59;
+acc += Math.sin(15289) + Math.cos(15290) * 60;
+acc += Math.sin(15290) + Math.cos(15291) * 61;
+acc += Math.sin(15291) + Math.cos(15292) * 62;
+acc += Math.sin(15292) + Math.cos(15293) * 63;
+acc += Math.sin(15293) + Math.cos(15294) * 64;
+acc += Math.sin(15294) + Math.cos(15295) * 65;
+acc += Math.sin(15295) + Math.cos(15296) * 66;
+acc += Math.sin(15296) + Math.cos(15297) * 67;
+acc += Math.sin(15297) + Math.cos(15298) * 68;
+acc += Math.sin(15298) + Math.cos(15299) * 69;
+acc += Math.sin(15299) + Math.cos(15300) * 70;
+acc += Math.sin(15300) + Math.cos(15301) * 71;
+acc += Math.sin(15301) + Math.cos(15302) * 72;
+acc += Math.sin(15302) + Math.cos(15303) * 73;
+acc += Math.sin(15303) + Math.cos(15304) * 74;
+acc += Math.sin(15304) + Math.cos(15305) * 75;
+acc += Math.sin(15305) + Math.cos(15306) * 76;
+acc += Math.sin(15306) + Math.cos(15307) * 77;
+acc += Math.sin(15307) + Math.cos(15308) * 78;
+acc += Math.sin(15308) + Math.cos(15309) * 79;
+acc += Math.sin(15309) + Math.cos(15310) * 80;
+acc += Math.sin(15310) + Math.cos(15311) * 81;
+acc += Math.sin(15311) + Math.cos(15312) * 82;
+acc += Math.sin(15312) + Math.cos(15313) * 83;
+acc += Math.sin(15313) + Math.cos(15314) * 84;
+acc += Math.sin(15314) + Math.cos(15315) * 85;
+acc += Math.sin(15315) + Math.cos(15316) * 86;
+acc += Math.sin(15316) + Math.cos(15317) * 87;
+acc += Math.sin(15317) + Math.cos(15318) * 88;
+acc += Math.sin(15318) + Math.cos(15319) * 89;
+acc += Math.sin(15319) + Math.cos(15320) * 90;
+acc += Math.sin(15320) + Math.cos(15321) * 91;
+acc += Math.sin(15321) + Math.cos(15322) * 92;
+acc += Math.sin(15322) + Math.cos(15323) * 93;
+acc += Math.sin(15323) + Math.cos(15324) * 94;
+acc += Math.sin(15324) + Math.cos(15325) * 95;
+acc += Math.sin(15325) + Math.cos(15326) * 96;
+acc += Math.sin(15326) + Math.cos(15327) * 0;
+acc += Math.sin(15327) + Math.cos(15328) * 1;
+acc += Math.sin(15328) + Math.cos(15329) * 2;
+acc += Math.sin(15329) + Math.cos(15330) * 3;
+acc += Math.sin(15330) + Math.cos(15331) * 4;
+acc += Math.sin(15331) + Math.cos(15332) * 5;
+acc += Math.sin(15332) + Math.cos(15333) * 6;
+acc += Math.sin(15333) + Math.cos(15334) * 7;
+acc += Math.sin(15334) + Math.cos(15335) * 8;
+acc += Math.sin(15335) + Math.cos(15336) * 9;
+acc += Math.sin(15336) + Math.cos(15337) * 10;
+acc += Math.sin(15337) + Math.cos(15338) * 11;
+acc += Math.sin(15338) + Math.cos(15339) * 12;
+acc += Math.sin(15339) + Math.cos(15340) * 13;
+acc += Math.sin(15340) + Math.cos(15341) * 14;
+acc += Math.sin(15341) + Math.cos(15342) * 15;
+acc += Math.sin(15342) + Math.cos(15343) * 16;
+acc += Math.sin(15343) + Math.cos(15344) * 17;
+acc += Math.sin(15344) + Math.cos(15345) * 18;
+acc += Math.sin(15345) + Math.cos(15346) * 19;
+acc += Math.sin(15346) + Math.cos(15347) * 20;
+acc += Math.sin(15347) + Math.cos(15348) * 21;
+acc += Math.sin(15348) + Math.cos(15349) * 22;
+acc += Math.sin(15349) + Math.cos(15350) * 23;
+acc += Math.sin(15350) + Math.cos(15351) * 24;
+acc += Math.sin(15351) + Math.cos(15352) * 25;
+acc += Math.sin(15352) + Math.cos(15353) * 26;
+acc += Math.sin(15353) + Math.cos(15354) * 27;
+acc += Math.sin(15354) + Math.cos(15355) * 28;
+acc += Math.sin(15355) + Math.cos(15356) * 29;
+acc += Math.sin(15356) + Math.cos(15357) * 30;
+acc += Math.sin(15357) + Math.cos(15358) * 31;
+acc += Math.sin(15358) + Math.cos(15359) * 32;
+acc += Math.sin(15359) + Math.cos(15360) * 33;
+acc += Math.sin(15360) + Math.cos(15361) * 34;
+acc += Math.sin(15361) + Math.cos(15362) * 35;
+acc += Math.sin(15362) + Math.cos(15363) * 36;
+acc += Math.sin(15363) + Math.cos(15364) * 37;
+acc += Math.sin(15364) + Math.cos(15365) * 38;
+acc += Math.sin(15365) + Math.cos(15366) * 39;
+acc += Math.sin(15366) + Math.cos(15367) * 40;
+acc += Math.sin(15367) + Math.cos(15368) * 41;
+acc += Math.sin(15368) + Math.cos(15369) * 42;
+acc += Math.sin(15369) + Math.cos(15370) * 43;
+acc += Math.sin(15370) + Math.cos(15371) * 44;
+acc += Math.sin(15371) + Math.cos(15372) * 45;
+acc += Math.sin(15372) + Math.cos(15373) * 46;
+acc += Math.sin(15373) + Math.cos(15374) * 47;
+acc += Math.sin(15374) + Math.cos(15375) * 48;
+acc += Math.sin(15375) + Math.cos(15376) * 49;
+acc += Math.sin(15376) + Math.cos(15377) * 50;
+acc += Math.sin(15377) + Math.cos(15378) * 51;
+acc += Math.sin(15378) + Math.cos(15379) * 52;
+acc += Math.sin(15379) + Math.cos(15380) * 53;
+acc += Math.sin(15380) + Math.cos(15381) * 54;
+acc += Math.sin(15381) + Math.cos(15382) * 55;
+acc += Math.sin(15382) + Math.cos(15383) * 56;
+acc += Math.sin(15383) + Math.cos(15384) * 57;
+acc += Math.sin(15384) + Math.cos(15385) * 58;
+acc += Math.sin(15385) + Math.cos(15386) * 59;
+acc += Math.sin(15386) + Math.cos(15387) * 60;
+acc += Math.sin(15387) + Math.cos(15388) * 61;
+acc += Math.sin(15388) + Math.cos(15389) * 62;
+acc += Math.sin(15389) + Math.cos(15390) * 63;
+acc += Math.sin(15390) + Math.cos(15391) * 64;
+acc += Math.sin(15391) + Math.cos(15392) * 65;
+acc += Math.sin(15392) + Math.cos(15393) * 66;
+acc += Math.sin(15393) + Math.cos(15394) * 67;
+acc += Math.sin(15394) + Math.cos(15395) * 68;
+acc += Math.sin(15395) + Math.cos(15396) * 69;
+acc += Math.sin(15396) + Math.cos(15397) * 70;
+acc += Math.sin(15397) + Math.cos(15398) * 71;
+acc += Math.sin(15398) + Math.cos(15399) * 72;
+acc += Math.sin(15399) + Math.cos(15400) * 73;
+acc += Math.sin(15400) + Math.cos(15401) * 74;
+acc += Math.sin(15401) + Math.cos(15402) * 75;
+acc += Math.sin(15402) + Math.cos(15403) * 76;
+acc += Math.sin(15403) + Math.cos(15404) * 77;
+acc += Math.sin(15404) + Math.cos(15405) * 78;
+acc += Math.sin(15405) + Math.cos(15406) * 79;
+acc += Math.sin(15406) + Math.cos(15407) * 80;
+acc += Math.sin(15407) + Math.cos(15408) * 81;
+acc += Math.sin(15408) + Math.cos(15409) * 82;
+acc += Math.sin(15409) + Math.cos(15410) * 83;
+acc += Math.sin(15410) + Math.cos(15411) * 84;
+acc += Math.sin(15411) + Math.cos(15412) * 85;
+acc += Math.sin(15412) + Math.cos(15413) * 86;
+acc += Math.sin(15413) + Math.cos(15414) * 87;
+acc += Math.sin(15414) + Math.cos(15415) * 88;
+acc += Math.sin(15415) + Math.cos(15416) * 89;
+acc += Math.sin(15416) + Math.cos(15417) * 90;
+acc += Math.sin(15417) + Math.cos(15418) * 91;
+acc += Math.sin(15418) + Math.cos(15419) * 92;
+acc += Math.sin(15419) + Math.cos(15420) * 93;
+acc += Math.sin(15420) + Math.cos(15421) * 94;
+acc += Math.sin(15421) + Math.cos(15422) * 95;
+acc += Math.sin(15422) + Math.cos(15423) * 96;
+acc += Math.sin(15423) + Math.cos(15424) * 0;
+acc += Math.sin(15424) + Math.cos(15425) * 1;
+acc += Math.sin(15425) + Math.cos(15426) * 2;
+acc += Math.sin(15426) + Math.cos(15427) * 3;
+acc += Math.sin(15427) + Math.cos(15428) * 4;
+acc += Math.sin(15428) + Math.cos(15429) * 5;
+acc += Math.sin(15429) + Math.cos(15430) * 6;
+acc += Math.sin(15430) + Math.cos(15431) * 7;
+acc += Math.sin(15431) + Math.cos(15432) * 8;
+acc += Math.sin(15432) + Math.cos(15433) * 9;
+acc += Math.sin(15433) + Math.cos(15434) * 10;
+acc += Math.sin(15434) + Math.cos(15435) * 11;
+acc += Math.sin(15435) + Math.cos(15436) * 12;
+acc += Math.sin(15436) + Math.cos(15437) * 13;
+acc += Math.sin(15437) + Math.cos(15438) * 14;
+acc += Math.sin(15438) + Math.cos(15439) * 15;
+acc += Math.sin(15439) + Math.cos(15440) * 16;
+acc += Math.sin(15440) + Math.cos(15441) * 17;
+acc += Math.sin(15441) + Math.cos(15442) * 18;
+acc += Math.sin(15442) + Math.cos(15443) * 19;
+acc += Math.sin(15443) + Math.cos(15444) * 20;
+acc += Math.sin(15444) + Math.cos(15445) * 21;
+acc += Math.sin(15445) + Math.cos(15446) * 22;
+acc += Math.sin(15446) + Math.cos(15447) * 23;
+acc += Math.sin(15447) + Math.cos(15448) * 24;
+acc += Math.sin(15448) + Math.cos(15449) * 25;
+acc += Math.sin(15449) + Math.cos(15450) * 26;
+acc += Math.sin(15450) + Math.cos(15451) * 27;
+acc += Math.sin(15451) + Math.cos(15452) * 28;
+acc += Math.sin(15452) + Math.cos(15453) * 29;
+acc += Math.sin(15453) + Math.cos(15454) * 30;
+acc += Math.sin(15454) + Math.cos(15455) * 31;
+acc += Math.sin(15455) + Math.cos(15456) * 32;
+acc += Math.sin(15456) + Math.cos(15457) * 33;
+acc += Math.sin(15457) + Math.cos(15458) * 34;
+acc += Math.sin(15458) + Math.cos(15459) * 35;
+acc += Math.sin(15459) + Math.cos(15460) * 36;
+acc += Math.sin(15460) + Math.cos(15461) * 37;
+acc += Math.sin(15461) + Math.cos(15462) * 38;
+acc += Math.sin(15462) + Math.cos(15463) * 39;
+acc += Math.sin(15463) + Math.cos(15464) * 40;
+acc += Math.sin(15464) + Math.cos(15465) * 41;
+acc += Math.sin(15465) + Math.cos(15466) * 42;
+acc += Math.sin(15466) + Math.cos(15467) * 43;
+acc += Math.sin(15467) + Math.cos(15468) * 44;
+acc += Math.sin(15468) + Math.cos(15469) * 45;
+acc += Math.sin(15469) + Math.cos(15470) * 46;
+acc += Math.sin(15470) + Math.cos(15471) * 47;
+acc += Math.sin(15471) + Math.cos(15472) * 48;
+acc += Math.sin(15472) + Math.cos(15473) * 49;
+acc += Math.sin(15473) + Math.cos(15474) * 50;
+acc += Math.sin(15474) + Math.cos(15475) * 51;
+acc += Math.sin(15475) + Math.cos(15476) * 52;
+acc += Math.sin(15476) + Math.cos(15477) * 53;
+acc += Math.sin(15477) + Math.cos(15478) * 54;
+acc += Math.sin(15478) + Math.cos(15479) * 55;
+acc += Math.sin(15479) + Math.cos(15480) * 56;
+acc += Math.sin(15480) + Math.cos(15481) * 57;
+acc += Math.sin(15481) + Math.cos(15482) * 58;
+acc += Math.sin(15482) + Math.cos(15483) * 59;
+acc += Math.sin(15483) + Math.cos(15484) * 60;
+acc += Math.sin(15484) + Math.cos(15485) * 61;
+acc += Math.sin(15485) + Math.cos(15486) * 62;
+acc += Math.sin(15486) + Math.cos(15487) * 63;
+acc += Math.sin(15487) + Math.cos(15488) * 64;
+acc += Math.sin(15488) + Math.cos(15489) * 65;
+acc += Math.sin(15489) + Math.cos(15490) * 66;
+acc += Math.sin(15490) + Math.cos(15491) * 67;
+acc += Math.sin(15491) + Math.cos(15492) * 68;
+acc += Math.sin(15492) + Math.cos(15493) * 69;
+acc += Math.sin(15493) + Math.cos(15494) * 70;
+acc += Math.sin(15494) + Math.cos(15495) * 71;
+acc += Math.sin(15495) + Math.cos(15496) * 72;
+acc += Math.sin(15496) + Math.cos(15497) * 73;
+acc += Math.sin(15497) + Math.cos(15498) * 74;
+acc += Math.sin(15498) + Math.cos(15499) * 75;
+acc += Math.sin(15499) + Math.cos(15500) * 76;
+acc += Math.sin(15500) + Math.cos(15501) * 77;
+acc += Math.sin(15501) + Math.cos(15502) * 78;
+acc += Math.sin(15502) + Math.cos(15503) * 79;
+acc += Math.sin(15503) + Math.cos(15504) * 80;
+acc += Math.sin(15504) + Math.cos(15505) * 81;
+acc += Math.sin(15505) + Math.cos(15506) * 82;
+acc += Math.sin(15506) + Math.cos(15507) * 83;
+acc += Math.sin(15507) + Math.cos(15508) * 84;
+acc += Math.sin(15508) + Math.cos(15509) * 85;
+acc += Math.sin(15509) + Math.cos(15510) * 86;
+acc += Math.sin(15510) + Math.cos(15511) * 87;
+acc += Math.sin(15511) + Math.cos(15512) * 88;
+acc += Math.sin(15512) + Math.cos(15513) * 89;
+acc += Math.sin(15513) + Math.cos(15514) * 90;
+acc += Math.sin(15514) + Math.cos(15515) * 91;
+acc += Math.sin(15515) + Math.cos(15516) * 92;
+acc += Math.sin(15516) + Math.cos(15517) * 93;
+acc += Math.sin(15517) + Math.cos(15518) * 94;
+acc += Math.sin(15518) + Math.cos(15519) * 95;
+acc += Math.sin(15519) + Math.cos(15520) * 96;
+acc += Math.sin(15520) + Math.cos(15521) * 0;
+acc += Math.sin(15521) + Math.cos(15522) * 1;
+acc += Math.sin(15522) + Math.cos(15523) * 2;
+acc += Math.sin(15523) + Math.cos(15524) * 3;
+acc += Math.sin(15524) + Math.cos(15525) * 4;
+acc += Math.sin(15525) + Math.cos(15526) * 5;
+acc += Math.sin(15526) + Math.cos(15527) * 6;
+acc += Math.sin(15527) + Math.cos(15528) * 7;
+acc += Math.sin(15528) + Math.cos(15529) * 8;
+acc += Math.sin(15529) + Math.cos(15530) * 9;
+acc += Math.sin(15530) + Math.cos(15531) * 10;
+acc += Math.sin(15531) + Math.cos(15532) * 11;
+acc += Math.sin(15532) + Math.cos(15533) * 12;
+acc += Math.sin(15533) + Math.cos(15534) * 13;
+acc += Math.sin(15534) + Math.cos(15535) * 14;
+acc += Math.sin(15535) + Math.cos(15536) * 15;
+acc += Math.sin(15536) + Math.cos(15537) * 16;
+acc += Math.sin(15537) + Math.cos(15538) * 17;
+acc += Math.sin(15538) + Math.cos(15539) * 18;
+acc += Math.sin(15539) + Math.cos(15540) * 19;
+acc += Math.sin(15540) + Math.cos(15541) * 20;
+acc += Math.sin(15541) + Math.cos(15542) * 21;
+acc += Math.sin(15542) + Math.cos(15543) * 22;
+acc += Math.sin(15543) + Math.cos(15544) * 23;
+acc += Math.sin(15544) + Math.cos(15545) * 24;
+acc += Math.sin(15545) + Math.cos(15546) * 25;
+acc += Math.sin(15546) + Math.cos(15547) * 26;
+acc += Math.sin(15547) + Math.cos(15548) * 27;
+acc += Math.sin(15548) + Math.cos(15549) * 28;
+acc += Math.sin(15549) + Math.cos(15550) * 29;
+acc += Math.sin(15550) + Math.cos(15551) * 30;
+acc += Math.sin(15551) + Math.cos(15552) * 31;
+acc += Math.sin(15552) + Math.cos(15553) * 32;
+acc += Math.sin(15553) + Math.cos(15554) * 33;
+acc += Math.sin(15554) + Math.cos(15555) * 34;
+acc += Math.sin(15555) + Math.cos(15556) * 35;
+acc += Math.sin(15556) + Math.cos(15557) * 36;
+acc += Math.sin(15557) + Math.cos(15558) * 37;
+acc += Math.sin(15558) + Math.cos(15559) * 38;
+acc += Math.sin(15559) + Math.cos(15560) * 39;
+acc += Math.sin(15560) + Math.cos(15561) * 40;
+acc += Math.sin(15561) + Math.cos(15562) * 41;
+acc += Math.sin(15562) + Math.cos(15563) * 42;
+acc += Math.sin(15563) + Math.cos(15564) * 43;
+acc += Math.sin(15564) + Math.cos(15565) * 44;
+acc += Math.sin(15565) + Math.cos(15566) * 45;
+acc += Math.sin(15566) + Math.cos(15567) * 46;
+acc += Math.sin(15567) + Math.cos(15568) * 47;
+acc += Math.sin(15568) + Math.cos(15569) * 48;
+acc += Math.sin(15569) + Math.cos(15570) * 49;
+acc += Math.sin(15570) + Math.cos(15571) * 50;
+acc += Math.sin(15571) + Math.cos(15572) * 51;
+acc += Math.sin(15572) + Math.cos(15573) * 52;
+acc += Math.sin(15573) + Math.cos(15574) * 53;
+acc += Math.sin(15574) + Math.cos(15575) * 54;
+acc += Math.sin(15575) + Math.cos(15576) * 55;
+acc += Math.sin(15576) + Math.cos(15577) * 56;
+acc += Math.sin(15577) + Math.cos(15578) * 57;
+acc += Math.sin(15578) + Math.cos(15579) * 58;
+acc += Math.sin(15579) + Math.cos(15580) * 59;
+acc += Math.sin(15580) + Math.cos(15581) * 60;
+acc += Math.sin(15581) + Math.cos(15582) * 61;
+acc += Math.sin(15582) + Math.cos(15583) * 62;
+acc += Math.sin(15583) + Math.cos(15584) * 63;
+acc += Math.sin(15584) + Math.cos(15585) * 64;
+acc += Math.sin(15585) + Math.cos(15586) * 65;
+acc += Math.sin(15586) + Math.cos(15587) * 66;
+acc += Math.sin(15587) + Math.cos(15588) * 67;
+acc += Math.sin(15588) + Math.cos(15589) * 68;
+acc += Math.sin(15589) + Math.cos(15590) * 69;
+acc += Math.sin(15590) + Math.cos(15591) * 70;
+acc += Math.sin(15591) + Math.cos(15592) * 71;
+acc += Math.sin(15592) + Math.cos(15593) * 72;
+acc += Math.sin(15593) + Math.cos(15594) * 73;
+acc += Math.sin(15594) + Math.cos(15595) * 74;
+acc += Math.sin(15595) + Math.cos(15596) * 75;
+acc += Math.sin(15596) + Math.cos(15597) * 76;
+acc += Math.sin(15597) + Math.cos(15598) * 77;
+acc += Math.sin(15598) + Math.cos(15599) * 78;
+acc += Math.sin(15599) + Math.cos(15600) * 79;
+acc += Math.sin(15600) + Math.cos(15601) * 80;
+acc += Math.sin(15601) + Math.cos(15602) * 81;
+acc += Math.sin(15602) + Math.cos(15603) * 82;
+acc += Math.sin(15603) + Math.cos(15604) * 83;
+acc += Math.sin(15604) + Math.cos(15605) * 84;
+acc += Math.sin(15605) + Math.cos(15606) * 85;
+acc += Math.sin(15606) + Math.cos(15607) * 86;
+acc += Math.sin(15607) + Math.cos(15608) * 87;
+acc += Math.sin(15608) + Math.cos(15609) * 88;
+acc += Math.sin(15609) + Math.cos(15610) * 89;
+acc += Math.sin(15610) + Math.cos(15611) * 90;
+acc += Math.sin(15611) + Math.cos(15612) * 91;
+acc += Math.sin(15612) + Math.cos(15613) * 92;
+acc += Math.sin(15613) + Math.cos(15614) * 93;
+acc += Math.sin(15614) + Math.cos(15615) * 94;
+acc += Math.sin(15615) + Math.cos(15616) * 95;
+acc += Math.sin(15616) + Math.cos(15617) * 96;
+acc += Math.sin(15617) + Math.cos(15618) * 0;
+acc += Math.sin(15618) + Math.cos(15619) * 1;
+acc += Math.sin(15619) + Math.cos(15620) * 2;
+acc += Math.sin(15620) + Math.cos(15621) * 3;
+acc += Math.sin(15621) + Math.cos(15622) * 4;
+acc += Math.sin(15622) + Math.cos(15623) * 5;
+acc += Math.sin(15623) + Math.cos(15624) * 6;
+acc += Math.sin(15624) + Math.cos(15625) * 7;
+acc += Math.sin(15625) + Math.cos(15626) * 8;
+acc += Math.sin(15626) + Math.cos(15627) * 9;
+acc += Math.sin(15627) + Math.cos(15628) * 10;
+acc += Math.sin(15628) + Math.cos(15629) * 11;
+acc += Math.sin(15629) + Math.cos(15630) * 12;
+acc += Math.sin(15630) + Math.cos(15631) * 13;
+acc += Math.sin(15631) + Math.cos(15632) * 14;
+acc += Math.sin(15632) + Math.cos(15633) * 15;
+acc += Math.sin(15633) + Math.cos(15634) * 16;
+acc += Math.sin(15634) + Math.cos(15635) * 17;
+acc += Math.sin(15635) + Math.cos(15636) * 18;
+acc += Math.sin(15636) + Math.cos(15637) * 19;
+acc += Math.sin(15637) + Math.cos(15638) * 20;
+acc += Math.sin(15638) + Math.cos(15639) * 21;
+acc += Math.sin(15639) + Math.cos(15640) * 22;
+acc += Math.sin(15640) + Math.cos(15641) * 23;
+acc += Math.sin(15641) + Math.cos(15642) * 24;
+acc += Math.sin(15642) + Math.cos(15643) * 25;
+acc += Math.sin(15643) + Math.cos(15644) * 26;
+acc += Math.sin(15644) + Math.cos(15645) * 27;
+acc += Math.sin(15645) + Math.cos(15646) * 28;
+acc += Math.sin(15646) + Math.cos(15647) * 29;
+acc += Math.sin(15647) + Math.cos(15648) * 30;
+acc += Math.sin(15648) + Math.cos(15649) * 31;
+acc += Math.sin(15649) + Math.cos(15650) * 32;
+acc += Math.sin(15650) + Math.cos(15651) * 33;
+acc += Math.sin(15651) + Math.cos(15652) * 34;
+acc += Math.sin(15652) + Math.cos(15653) * 35;
+acc += Math.sin(15653) + Math.cos(15654) * 36;
+acc += Math.sin(15654) + Math.cos(15655) * 37;
+acc += Math.sin(15655) + Math.cos(15656) * 38;
+acc += Math.sin(15656) + Math.cos(15657) * 39;
+acc += Math.sin(15657) + Math.cos(15658) * 40;
+acc += Math.sin(15658) + Math.cos(15659) * 41;
+acc += Math.sin(15659) + Math.cos(15660) * 42;
+acc += Math.sin(15660) + Math.cos(15661) * 43;
+acc += Math.sin(15661) + Math.cos(15662) * 44;
+acc += Math.sin(15662) + Math.cos(15663) * 45;
+acc += Math.sin(15663) + Math.cos(15664) * 46;
+acc += Math.sin(15664) + Math.cos(15665) * 47;
+acc += Math.sin(15665) + Math.cos(15666) * 48;
+acc += Math.sin(15666) + Math.cos(15667) * 49;
+acc += Math.sin(15667) + Math.cos(15668) * 50;
+acc += Math.sin(15668) + Math.cos(15669) * 51;
+acc += Math.sin(15669) + Math.cos(15670) * 52;
+acc += Math.sin(15670) + Math.cos(15671) * 53;
+acc += Math.sin(15671) + Math.cos(15672) * 54;
+acc += Math.sin(15672) + Math.cos(15673) * 55;
+acc += Math.sin(15673) + Math.cos(15674) * 56;
+acc += Math.sin(15674) + Math.cos(15675) * 57;
+acc += Math.sin(15675) + Math.cos(15676) * 58;
+acc += Math.sin(15676) + Math.cos(15677) * 59;
+acc += Math.sin(15677) + Math.cos(15678) * 60;
+acc += Math.sin(15678) + Math.cos(15679) * 61;
+acc += Math.sin(15679) + Math.cos(15680) * 62;
+acc += Math.sin(15680) + Math.cos(15681) * 63;
+acc += Math.sin(15681) + Math.cos(15682) * 64;
+acc += Math.sin(15682) + Math.cos(15683) * 65;
+acc += Math.sin(15683) + Math.cos(15684) * 66;
+acc += Math.sin(15684) + Math.cos(15685) * 67;
+acc += Math.sin(15685) + Math.cos(15686) * 68;
+acc += Math.sin(15686) + Math.cos(15687) * 69;
+acc += Math.sin(15687) + Math.cos(15688) * 70;
+acc += Math.sin(15688) + Math.cos(15689) * 71;
+acc += Math.sin(15689) + Math.cos(15690) * 72;
+acc += Math.sin(15690) + Math.cos(15691) * 73;
+acc += Math.sin(15691) + Math.cos(15692) * 74;
+acc += Math.sin(15692) + Math.cos(15693) * 75;
+acc += Math.sin(15693) + Math.cos(15694) * 76;
+acc += Math.sin(15694) + Math.cos(15695) * 77;
+acc += Math.sin(15695) + Math.cos(15696) * 78;
+acc += Math.sin(15696) + Math.cos(15697) * 79;
+acc += Math.sin(15697) + Math.cos(15698) * 80;
+acc += Math.sin(15698) + Math.cos(15699) * 81;
+acc += Math.sin(15699) + Math.cos(15700) * 82;
+acc += Math.sin(15700) + Math.cos(15701) * 83;
+acc += Math.sin(15701) + Math.cos(15702) * 84;
+acc += Math.sin(15702) + Math.cos(15703) * 85;
+acc += Math.sin(15703) + Math.cos(15704) * 86;
+acc += Math.sin(15704) + Math.cos(15705) * 87;
+acc += Math.sin(15705) + Math.cos(15706) * 88;
+acc += Math.sin(15706) + Math.cos(15707) * 89;
+acc += Math.sin(15707) + Math.cos(15708) * 90;
+acc += Math.sin(15708) + Math.cos(15709) * 91;
+acc += Math.sin(15709) + Math.cos(15710) * 92;
+acc += Math.sin(15710) + Math.cos(15711) * 93;
+acc += Math.sin(15711) + Math.cos(15712) * 94;
+acc += Math.sin(15712) + Math.cos(15713) * 95;
+acc += Math.sin(15713) + Math.cos(15714) * 96;
+acc += Math.sin(15714) + Math.cos(15715) * 0;
+acc += Math.sin(15715) + Math.cos(15716) * 1;
+acc += Math.sin(15716) + Math.cos(15717) * 2;
+acc += Math.sin(15717) + Math.cos(15718) * 3;
+acc += Math.sin(15718) + Math.cos(15719) * 4;
+acc += Math.sin(15719) + Math.cos(15720) * 5;
+acc += Math.sin(15720) + Math.cos(15721) * 6;
+acc += Math.sin(15721) + Math.cos(15722) * 7;
+acc += Math.sin(15722) + Math.cos(15723) * 8;
+acc += Math.sin(15723) + Math.cos(15724) * 9;
+acc += Math.sin(15724) + Math.cos(15725) * 10;
+acc += Math.sin(15725) + Math.cos(15726) * 11;
+acc += Math.sin(15726) + Math.cos(15727) * 12;
+acc += Math.sin(15727) + Math.cos(15728) * 13;
+acc += Math.sin(15728) + Math.cos(15729) * 14;
+acc += Math.sin(15729) + Math.cos(15730) * 15;
+acc += Math.sin(15730) + Math.cos(15731) * 16;
+acc += Math.sin(15731) + Math.cos(15732) * 17;
+acc += Math.sin(15732) + Math.cos(15733) * 18;
+acc += Math.sin(15733) + Math.cos(15734) * 19;
+acc += Math.sin(15734) + Math.cos(15735) * 20;
+acc += Math.sin(15735) + Math.cos(15736) * 21;
+acc += Math.sin(15736) + Math.cos(15737) * 22;
+acc += Math.sin(15737) + Math.cos(15738) * 23;
+acc += Math.sin(15738) + Math.cos(15739) * 24;
+acc += Math.sin(15739) + Math.cos(15740) * 25;
+acc += Math.sin(15740) + Math.cos(15741) * 26;
+acc += Math.sin(15741) + Math.cos(15742) * 27;
+acc += Math.sin(15742) + Math.cos(15743) * 28;
+acc += Math.sin(15743) + Math.cos(15744) * 29;
+acc += Math.sin(15744) + Math.cos(15745) * 30;
+acc += Math.sin(15745) + Math.cos(15746) * 31;
+acc += Math.sin(15746) + Math.cos(15747) * 32;
+acc += Math.sin(15747) + Math.cos(15748) * 33;
+acc += Math.sin(15748) + Math.cos(15749) * 34;
+acc += Math.sin(15749) + Math.cos(15750) * 35;
+acc += Math.sin(15750) + Math.cos(15751) * 36;
+acc += Math.sin(15751) + Math.cos(15752) * 37;
+acc += Math.sin(15752) + Math.cos(15753) * 38;
+acc += Math.sin(15753) + Math.cos(15754) * 39;
+acc += Math.sin(15754) + Math.cos(15755) * 40;
+acc += Math.sin(15755) + Math.cos(15756) * 41;
+acc += Math.sin(15756) + Math.cos(15757) * 42;
+acc += Math.sin(15757) + Math.cos(15758) * 43;
+acc += Math.sin(15758) + Math.cos(15759) * 44;
+acc += Math.sin(15759) + Math.cos(15760) * 45;
+acc += Math.sin(15760) + Math.cos(15761) * 46;
+acc += Math.sin(15761) + Math.cos(15762) * 47;
+acc += Math.sin(15762) + Math.cos(15763) * 48;
+acc += Math.sin(15763) + Math.cos(15764) * 49;
+acc += Math.sin(15764) + Math.cos(15765) * 50;
+acc += Math.sin(15765) + Math.cos(15766) * 51;
+acc += Math.sin(15766) + Math.cos(15767) * 52;
+acc += Math.sin(15767) + Math.cos(15768) * 53;
+acc += Math.sin(15768) + Math.cos(15769) * 54;
+acc += Math.sin(15769) + Math.cos(15770) * 55;
+acc += Math.sin(15770) + Math.cos(15771) * 56;
+acc += Math.sin(15771) + Math.cos(15772) * 57;
+acc += Math.sin(15772) + Math.cos(15773) * 58;
+acc += Math.sin(15773) + Math.cos(15774) * 59;
+acc += Math.sin(15774) + Math.cos(15775) * 60;
+acc += Math.sin(15775) + Math.cos(15776) * 61;
+acc += Math.sin(15776) + Math.cos(15777) * 62;
+acc += Math.sin(15777) + Math.cos(15778) * 63;
+acc += Math.sin(15778) + Math.cos(15779) * 64;
+acc += Math.sin(15779) + Math.cos(15780) * 65;
+acc += Math.sin(15780) + Math.cos(15781) * 66;
+acc += Math.sin(15781) + Math.cos(15782) * 67;
+acc += Math.sin(15782) + Math.cos(15783) * 68;
+acc += Math.sin(15783) + Math.cos(15784) * 69;
+acc += Math.sin(15784) + Math.cos(15785) * 70;
+acc += Math.sin(15785) + Math.cos(15786) * 71;
+acc += Math.sin(15786) + Math.cos(15787) * 72;
+acc += Math.sin(15787) + Math.cos(15788) * 73;
+acc += Math.sin(15788) + Math.cos(15789) * 74;
+acc += Math.sin(15789) + Math.cos(15790) * 75;
+acc += Math.sin(15790) + Math.cos(15791) * 76;
+acc += Math.sin(15791) + Math.cos(15792) * 77;
+acc += Math.sin(15792) + Math.cos(15793) * 78;
+acc += Math.sin(15793) + Math.cos(15794) * 79;
+acc += Math.sin(15794) + Math.cos(15795) * 80;
+acc += Math.sin(15795) + Math.cos(15796) * 81;
+acc += Math.sin(15796) + Math.cos(15797) * 82;
+acc += Math.sin(15797) + Math.cos(15798) * 83;
+acc += Math.sin(15798) + Math.cos(15799) * 84;
+acc += Math.sin(15799) + Math.cos(15800) * 85;
+acc += Math.sin(15800) + Math.cos(15801) * 86;
+acc += Math.sin(15801) + Math.cos(15802) * 87;
+acc += Math.sin(15802) + Math.cos(15803) * 88;
+acc += Math.sin(15803) + Math.cos(15804) * 89;
+acc += Math.sin(15804) + Math.cos(15805) * 90;
+acc += Math.sin(15805) + Math.cos(15806) * 91;
+acc += Math.sin(15806) + Math.cos(15807) * 92;
+acc += Math.sin(15807) + Math.cos(15808) * 93;
+acc += Math.sin(15808) + Math.cos(15809) * 94;
+acc += Math.sin(15809) + Math.cos(15810) * 95;
+acc += Math.sin(15810) + Math.cos(15811) * 96;
+acc += Math.sin(15811) + Math.cos(15812) * 0;
+acc += Math.sin(15812) + Math.cos(15813) * 1;
+acc += Math.sin(15813) + Math.cos(15814) * 2;
+acc += Math.sin(15814) + Math.cos(15815) * 3;
+acc += Math.sin(15815) + Math.cos(15816) * 4;
+acc += Math.sin(15816) + Math.cos(15817) * 5;
+acc += Math.sin(15817) + Math.cos(15818) * 6;
+acc += Math.sin(15818) + Math.cos(15819) * 7;
+acc += Math.sin(15819) + Math.cos(15820) * 8;
+acc += Math.sin(15820) + Math.cos(15821) * 9;
+acc += Math.sin(15821) + Math.cos(15822) * 10;
+acc += Math.sin(15822) + Math.cos(15823) * 11;
+acc += Math.sin(15823) + Math.cos(15824) * 12;
+acc += Math.sin(15824) + Math.cos(15825) * 13;
+acc += Math.sin(15825) + Math.cos(15826) * 14;
+acc += Math.sin(15826) + Math.cos(15827) * 15;
+acc += Math.sin(15827) + Math.cos(15828) * 16;
+acc += Math.sin(15828) + Math.cos(15829) * 17;
+acc += Math.sin(15829) + Math.cos(15830) * 18;
+acc += Math.sin(15830) + Math.cos(15831) * 19;
+acc += Math.sin(15831) + Math.cos(15832) * 20;
+acc += Math.sin(15832) + Math.cos(15833) * 21;
+acc += Math.sin(15833) + Math.cos(15834) * 22;
+acc += Math.sin(15834) + Math.cos(15835) * 23;
+acc += Math.sin(15835) + Math.cos(15836) * 24;
+acc += Math.sin(15836) + Math.cos(15837) * 25;
+acc += Math.sin(15837) + Math.cos(15838) * 26;
+acc += Math.sin(15838) + Math.cos(15839) * 27;
+acc += Math.sin(15839) + Math.cos(15840) * 28;
+acc += Math.sin(15840) + Math.cos(15841) * 29;
+acc += Math.sin(15841) + Math.cos(15842) * 30;
+acc += Math.sin(15842) + Math.cos(15843) * 31;
+acc += Math.sin(15843) + Math.cos(15844) * 32;
+acc += Math.sin(15844) + Math.cos(15845) * 33;
+acc += Math.sin(15845) + Math.cos(15846) * 34;
+acc += Math.sin(15846) + Math.cos(15847) * 35;
+acc += Math.sin(15847) + Math.cos(15848) * 36;
+acc += Math.sin(15848) + Math.cos(15849) * 37;
+acc += Math.sin(15849) + Math.cos(15850) * 38;
+acc += Math.sin(15850) + Math.cos(15851) * 39;
+acc += Math.sin(15851) + Math.cos(15852) * 40;
+acc += Math.sin(15852) + Math.cos(15853) * 41;
+acc += Math.sin(15853) + Math.cos(15854) * 42;
+acc += Math.sin(15854) + Math.cos(15855) * 43;
+acc += Math.sin(15855) + Math.cos(15856) * 44;
+acc += Math.sin(15856) + Math.cos(15857) * 45;
+acc += Math.sin(15857) + Math.cos(15858) * 46;
+acc += Math.sin(15858) + Math.cos(15859) * 47;
+acc += Math.sin(15859) + Math.cos(15860) * 48;
+acc += Math.sin(15860) + Math.cos(15861) * 49;
+acc += Math.sin(15861) + Math.cos(15862) * 50;
+acc += Math.sin(15862) + Math.cos(15863) * 51;
+acc += Math.sin(15863) + Math.cos(15864) * 52;
+acc += Math.sin(15864) + Math.cos(15865) * 53;
+acc += Math.sin(15865) + Math.cos(15866) * 54;
+acc += Math.sin(15866) + Math.cos(15867) * 55;
+acc += Math.sin(15867) + Math.cos(15868) * 56;
+acc += Math.sin(15868) + Math.cos(15869) * 57;
+acc += Math.sin(15869) + Math.cos(15870) * 58;
+acc += Math.sin(15870) + Math.cos(15871) * 59;
+acc += Math.sin(15871) + Math.cos(15872) * 60;
+acc += Math.sin(15872) + Math.cos(15873) * 61;
+acc += Math.sin(15873) + Math.cos(15874) * 62;
+acc += Math.sin(15874) + Math.cos(15875) * 63;
+acc += Math.sin(15875) + Math.cos(15876) * 64;
+acc += Math.sin(15876) + Math.cos(15877) * 65;
+acc += Math.sin(15877) + Math.cos(15878) * 66;
+acc += Math.sin(15878) + Math.cos(15879) * 67;
+acc += Math.sin(15879) + Math.cos(15880) * 68;
+acc += Math.sin(15880) + Math.cos(15881) * 69;
+acc += Math.sin(15881) + Math.cos(15882) * 70;
+acc += Math.sin(15882) + Math.cos(15883) * 71;
+acc += Math.sin(15883) + Math.cos(15884) * 72;
+acc += Math.sin(15884) + Math.cos(15885) * 73;
+acc += Math.sin(15885) + Math.cos(15886) * 74;
+acc += Math.sin(15886) + Math.cos(15887) * 75;
+acc += Math.sin(15887) + Math.cos(15888) * 76;
+acc += Math.sin(15888) + Math.cos(15889) * 77;
+acc += Math.sin(15889) + Math.cos(15890) * 78;
+acc += Math.sin(15890) + Math.cos(15891) * 79;
+acc += Math.sin(15891) + Math.cos(15892) * 80;
+acc += Math.sin(15892) + Math.cos(15893) * 81;
+acc += Math.sin(15893) + Math.cos(15894) * 82;
+acc += Math.sin(15894) + Math.cos(15895) * 83;
+acc += Math.sin(15895) + Math.cos(15896) * 84;
+acc += Math.sin(15896) + Math.cos(15897) * 85;
+acc += Math.sin(15897) + Math.cos(15898) * 86;
+acc += Math.sin(15898) + Math.cos(15899) * 87;
+acc += Math.sin(15899) + Math.cos(15900) * 88;
+acc += Math.sin(15900) + Math.cos(15901) * 89;
+acc += Math.sin(15901) + Math.cos(15902) * 90;
+acc += Math.sin(15902) + Math.cos(15903) * 91;
+acc += Math.sin(15903) + Math.cos(15904) * 92;
+acc += Math.sin(15904) + Math.cos(15905) * 93;
+acc += Math.sin(15905) + Math.cos(15906) * 94;
+acc += Math.sin(15906) + Math.cos(15907) * 95;
+acc += Math.sin(15907) + Math.cos(15908) * 96;
+acc += Math.sin(15908) + Math.cos(15909) * 0;
+acc += Math.sin(15909) + Math.cos(15910) * 1;
+acc += Math.sin(15910) + Math.cos(15911) * 2;
+acc += Math.sin(15911) + Math.cos(15912) * 3;
+acc += Math.sin(15912) + Math.cos(15913) * 4;
+acc += Math.sin(15913) + Math.cos(15914) * 5;
+acc += Math.sin(15914) + Math.cos(15915) * 6;
+acc += Math.sin(15915) + Math.cos(15916) * 7;
+acc += Math.sin(15916) + Math.cos(15917) * 8;
+acc += Math.sin(15917) + Math.cos(15918) * 9;
+acc += Math.sin(15918) + Math.cos(15919) * 10;
+acc += Math.sin(15919) + Math.cos(15920) * 11;
+acc += Math.sin(15920) + Math.cos(15921) * 12;
+acc += Math.sin(15921) + Math.cos(15922) * 13;
+acc += Math.sin(15922) + Math.cos(15923) * 14;
+acc += Math.sin(15923) + Math.cos(15924) * 15;
+acc += Math.sin(15924) + Math.cos(15925) * 16;
+acc += Math.sin(15925) + Math.cos(15926) * 17;
+acc += Math.sin(15926) + Math.cos(15927) * 18;
+acc += Math.sin(15927) + Math.cos(15928) * 19;
+acc += Math.sin(15928) + Math.cos(15929) * 20;
+acc += Math.sin(15929) + Math.cos(15930) * 21;
+acc += Math.sin(15930) + Math.cos(15931) * 22;
+acc += Math.sin(15931) + Math.cos(15932) * 23;
+acc += Math.sin(15932) + Math.cos(15933) * 24;
+acc += Math.sin(15933) + Math.cos(15934) * 25;
+acc += Math.sin(15934) + Math.cos(15935) * 26;
+acc += Math.sin(15935) + Math.cos(15936) * 27;
+acc += Math.sin(15936) + Math.cos(15937) * 28;
+acc += Math.sin(15937) + Math.cos(15938) * 29;
+acc += Math.sin(15938) + Math.cos(15939) * 30;
+acc += Math.sin(15939) + Math.cos(15940) * 31;
+acc += Math.sin(15940) + Math.cos(15941) * 32;
+acc += Math.sin(15941) + Math.cos(15942) * 33;
+acc += Math.sin(15942) + Math.cos(15943) * 34;
+acc += Math.sin(15943) + Math.cos(15944) * 35;
+acc += Math.sin(15944) + Math.cos(15945) * 36;
+acc += Math.sin(15945) + Math.cos(15946) * 37;
+acc += Math.sin(15946) + Math.cos(15947) * 38;
+acc += Math.sin(15947) + Math.cos(15948) * 39;
+acc += Math.sin(15948) + Math.cos(15949) * 40;
+acc += Math.sin(15949) + Math.cos(15950) * 41;
+acc += Math.sin(15950) + Math.cos(15951) * 42;
+acc += Math.sin(15951) + Math.cos(15952) * 43;
+acc += Math.sin(15952) + Math.cos(15953) * 44;
+acc += Math.sin(15953) + Math.cos(15954) * 45;
+acc += Math.sin(15954) + Math.cos(15955) * 46;
+acc += Math.sin(15955) + Math.cos(15956) * 47;
+acc += Math.sin(15956) + Math.cos(15957) * 48;
+acc += Math.sin(15957) + Math.cos(15958) * 49;
+acc += Math.sin(15958) + Math.cos(15959) * 50;
+acc += Math.sin(15959) + Math.cos(15960) * 51;
+acc += Math.sin(15960) + Math.cos(15961) * 52;
+acc += Math.sin(15961) + Math.cos(15962) * 53;
+acc += Math.sin(15962) + Math.cos(15963) * 54;
+acc += Math.sin(15963) + Math.cos(15964) * 55;
+acc += Math.sin(15964) + Math.cos(15965) * 56;
+acc += Math.sin(15965) + Math.cos(15966) * 57;
+acc += Math.sin(15966) + Math.cos(15967) * 58;
+acc += Math.sin(15967) + Math.cos(15968) * 59;
+acc += Math.sin(15968) + Math.cos(15969) * 60;
+acc += Math.sin(15969) + Math.cos(15970) * 61;
+acc += Math.sin(15970) + Math.cos(15971) * 62;
+acc += Math.sin(15971) + Math.cos(15972) * 63;
+acc += Math.sin(15972) + Math.cos(15973) * 64;
+acc += Math.sin(15973) + Math.cos(15974) * 65;
+acc += Math.sin(15974) + Math.cos(15975) * 66;
+acc += Math.sin(15975) + Math.cos(15976) * 67;
+acc += Math.sin(15976) + Math.cos(15977) * 68;
+acc += Math.sin(15977) + Math.cos(15978) * 69;
+acc += Math.sin(15978) + Math.cos(15979) * 70;
+acc += Math.sin(15979) + Math.cos(15980) * 71;
+acc += Math.sin(15980) + Math.cos(15981) * 72;
+acc += Math.sin(15981) + Math.cos(15982) * 73;
+acc += Math.sin(15982) + Math.cos(15983) * 74;
+acc += Math.sin(15983) + Math.cos(15984) * 75;
+acc += Math.sin(15984) + Math.cos(15985) * 76;
+acc += Math.sin(15985) + Math.cos(15986) * 77;
+acc += Math.sin(15986) + Math.cos(15987) * 78;
+acc += Math.sin(15987) + Math.cos(15988) * 79;
+acc += Math.sin(15988) + Math.cos(15989) * 80;
+acc += Math.sin(15989) + Math.cos(15990) * 81;
+acc += Math.sin(15990) + Math.cos(15991) * 82;
+acc += Math.sin(15991) + Math.cos(15992) * 83;
+acc += Math.sin(15992) + Math.cos(15993) * 84;
+acc += Math.sin(15993) + Math.cos(15994) * 85;
+acc += Math.sin(15994) + Math.cos(15995) * 86;
+acc += Math.sin(15995) + Math.cos(15996) * 87;
+acc += Math.sin(15996) + Math.cos(15997) * 88;
+acc += Math.sin(15997) + Math.cos(15998) * 89;
+acc += Math.sin(15998) + Math.cos(15999) * 90;
+acc += Math.sin(15999) + Math.cos(16000) * 91;
+acc += Math.sin(16000) + Math.cos(16001) * 92;
+acc += Math.sin(16001) + Math.cos(16002) * 93;
+acc += Math.sin(16002) + Math.cos(16003) * 94;
+acc += Math.sin(16003) + Math.cos(16004) * 95;
+acc += Math.sin(16004) + Math.cos(16005) * 96;
+acc += Math.sin(16005) + Math.cos(16006) * 0;
+acc += Math.sin(16006) + Math.cos(16007) * 1;
+acc += Math.sin(16007) + Math.cos(16008) * 2;
+acc += Math.sin(16008) + Math.cos(16009) * 3;
+acc += Math.sin(16009) + Math.cos(16010) * 4;
+acc += Math.sin(16010) + Math.cos(16011) * 5;
+acc += Math.sin(16011) + Math.cos(16012) * 6;
+acc += Math.sin(16012) + Math.cos(16013) * 7;
+acc += Math.sin(16013) + Math.cos(16014) * 8;
+acc += Math.sin(16014) + Math.cos(16015) * 9;
+acc += Math.sin(16015) + Math.cos(16016) * 10;
+acc += Math.sin(16016) + Math.cos(16017) * 11;
+acc += Math.sin(16017) + Math.cos(16018) * 12;
+acc += Math.sin(16018) + Math.cos(16019) * 13;
+acc += Math.sin(16019) + Math.cos(16020) * 14;
+acc += Math.sin(16020) + Math.cos(16021) * 15;
+acc += Math.sin(16021) + Math.cos(16022) * 16;
+acc += Math.sin(16022) + Math.cos(16023) * 17;
+acc += Math.sin(16023) + Math.cos(16024) * 18;
+acc += Math.sin(16024) + Math.cos(16025) * 19;
+acc += Math.sin(16025) + Math.cos(16026) * 20;
+acc += Math.sin(16026) + Math.cos(16027) * 21;
+acc += Math.sin(16027) + Math.cos(16028) * 22;
+acc += Math.sin(16028) + Math.cos(16029) * 23;
+acc += Math.sin(16029) + Math.cos(16030) * 24;
+acc += Math.sin(16030) + Math.cos(16031) * 25;
+acc += Math.sin(16031) + Math.cos(16032) * 26;
+acc += Math.sin(16032) + Math.cos(16033) * 27;
+acc += Math.sin(16033) + Math.cos(16034) * 28;
+acc += Math.sin(16034) + Math.cos(16035) * 29;
+acc += Math.sin(16035) + Math.cos(16036) * 30;
+acc += Math.sin(16036) + Math.cos(16037) * 31;
+acc += Math.sin(16037) + Math.cos(16038) * 32;
+acc += Math.sin(16038) + Math.cos(16039) * 33;
+acc += Math.sin(16039) + Math.cos(16040) * 34;
+acc += Math.sin(16040) + Math.cos(16041) * 35;
+acc += Math.sin(16041) + Math.cos(16042) * 36;
+acc += Math.sin(16042) + Math.cos(16043) * 37;
+acc += Math.sin(16043) + Math.cos(16044) * 38;
+acc += Math.sin(16044) + Math.cos(16045) * 39;
+acc += Math.sin(16045) + Math.cos(16046) * 40;
+acc += Math.sin(16046) + Math.cos(16047) * 41;
+acc += Math.sin(16047) + Math.cos(16048) * 42;
+acc += Math.sin(16048) + Math.cos(16049) * 43;
+acc += Math.sin(16049) + Math.cos(16050) * 44;
+acc += Math.sin(16050) + Math.cos(16051) * 45;
+acc += Math.sin(16051) + Math.cos(16052) * 46;
+acc += Math.sin(16052) + Math.cos(16053) * 47;
+acc += Math.sin(16053) + Math.cos(16054) * 48;
+acc += Math.sin(16054) + Math.cos(16055) * 49;
+acc += Math.sin(16055) + Math.cos(16056) * 50;
+acc += Math.sin(16056) + Math.cos(16057) * 51;
+acc += Math.sin(16057) + Math.cos(16058) * 52;
+acc += Math.sin(16058) + Math.cos(16059) * 53;
+acc += Math.sin(16059) + Math.cos(16060) * 54;
+acc += Math.sin(16060) + Math.cos(16061) * 55;
+acc += Math.sin(16061) + Math.cos(16062) * 56;
+acc += Math.sin(16062) + Math.cos(16063) * 57;
+acc += Math.sin(16063) + Math.cos(16064) * 58;
+acc += Math.sin(16064) + Math.cos(16065) * 59;
+acc += Math.sin(16065) + Math.cos(16066) * 60;
+acc += Math.sin(16066) + Math.cos(16067) * 61;
+acc += Math.sin(16067) + Math.cos(16068) * 62;
+acc += Math.sin(16068) + Math.cos(16069) * 63;
+acc += Math.sin(16069) + Math.cos(16070) * 64;
+acc += Math.sin(16070) + Math.cos(16071) * 65;
+acc += Math.sin(16071) + Math.cos(16072) * 66;
+acc += Math.sin(16072) + Math.cos(16073) * 67;
+acc += Math.sin(16073) + Math.cos(16074) * 68;
+acc += Math.sin(16074) + Math.cos(16075) * 69;
+acc += Math.sin(16075) + Math.cos(16076) * 70;
+acc += Math.sin(16076) + Math.cos(16077) * 71;
+acc += Math.sin(16077) + Math.cos(16078) * 72;
+acc += Math.sin(16078) + Math.cos(16079) * 73;
+acc += Math.sin(16079) + Math.cos(16080) * 74;
+acc += Math.sin(16080) + Math.cos(16081) * 75;
+acc += Math.sin(16081) + Math.cos(16082) * 76;
+acc += Math.sin(16082) + Math.cos(16083) * 77;
+acc += Math.sin(16083) + Math.cos(16084) * 78;
+acc += Math.sin(16084) + Math.cos(16085) * 79;
+acc += Math.sin(16085) + Math.cos(16086) * 80;
+acc += Math.sin(16086) + Math.cos(16087) * 81;
+acc += Math.sin(16087) + Math.cos(16088) * 82;
+acc += Math.sin(16088) + Math.cos(16089) * 83;
+acc += Math.sin(16089) + Math.cos(16090) * 84;
+acc += Math.sin(16090) + Math.cos(16091) * 85;
+acc += Math.sin(16091) + Math.cos(16092) * 86;
+acc += Math.sin(16092) + Math.cos(16093) * 87;
+acc += Math.sin(16093) + Math.cos(16094) * 88;
+acc += Math.sin(16094) + Math.cos(16095) * 89;
+acc += Math.sin(16095) + Math.cos(16096) * 90;
+acc += Math.sin(16096) + Math.cos(16097) * 91;
+acc += Math.sin(16097) + Math.cos(16098) * 92;
+acc += Math.sin(16098) + Math.cos(16099) * 93;
+acc += Math.sin(16099) + Math.cos(16100) * 94;
+acc += Math.sin(16100) + Math.cos(16101) * 95;
+acc += Math.sin(16101) + Math.cos(16102) * 96;
+acc += Math.sin(16102) + Math.cos(16103) * 0;
+acc += Math.sin(16103) + Math.cos(16104) * 1;
+acc += Math.sin(16104) + Math.cos(16105) * 2;
+acc += Math.sin(16105) + Math.cos(16106) * 3;
+acc += Math.sin(16106) + Math.cos(16107) * 4;
+acc += Math.sin(16107) + Math.cos(16108) * 5;
+acc += Math.sin(16108) + Math.cos(16109) * 6;
+acc += Math.sin(16109) + Math.cos(16110) * 7;
+acc += Math.sin(16110) + Math.cos(16111) * 8;
+acc += Math.sin(16111) + Math.cos(16112) * 9;
+acc += Math.sin(16112) + Math.cos(16113) * 10;
+acc += Math.sin(16113) + Math.cos(16114) * 11;
+acc += Math.sin(16114) + Math.cos(16115) * 12;
+acc += Math.sin(16115) + Math.cos(16116) * 13;
+acc += Math.sin(16116) + Math.cos(16117) * 14;
+acc += Math.sin(16117) + Math.cos(16118) * 15;
+acc += Math.sin(16118) + Math.cos(16119) * 16;
+acc += Math.sin(16119) + Math.cos(16120) * 17;
+acc += Math.sin(16120) + Math.cos(16121) * 18;
+acc += Math.sin(16121) + Math.cos(16122) * 19;
+acc += Math.sin(16122) + Math.cos(16123) * 20;
+acc += Math.sin(16123) + Math.cos(16124) * 21;
+acc += Math.sin(16124) + Math.cos(16125) * 22;
+acc += Math.sin(16125) + Math.cos(16126) * 23;
+acc += Math.sin(16126) + Math.cos(16127) * 24;
+acc += Math.sin(16127) + Math.cos(16128) * 25;
+acc += Math.sin(16128) + Math.cos(16129) * 26;
+acc += Math.sin(16129) + Math.cos(16130) * 27;
+acc += Math.sin(16130) + Math.cos(16131) * 28;
+acc += Math.sin(16131) + Math.cos(16132) * 29;
+acc += Math.sin(16132) + Math.cos(16133) * 30;
+acc += Math.sin(16133) + Math.cos(16134) * 31;
+acc += Math.sin(16134) + Math.cos(16135) * 32;
+acc += Math.sin(16135) + Math.cos(16136) * 33;
+acc += Math.sin(16136) + Math.cos(16137) * 34;
+acc += Math.sin(16137) + Math.cos(16138) * 35;
+acc += Math.sin(16138) + Math.cos(16139) * 36;
+acc += Math.sin(16139) + Math.cos(16140) * 37;
+acc += Math.sin(16140) + Math.cos(16141) * 38;
+acc += Math.sin(16141) + Math.cos(16142) * 39;
+acc += Math.sin(16142) + Math.cos(16143) * 40;
+acc += Math.sin(16143) + Math.cos(16144) * 41;
+acc += Math.sin(16144) + Math.cos(16145) * 42;
+acc += Math.sin(16145) + Math.cos(16146) * 43;
+acc += Math.sin(16146) + Math.cos(16147) * 44;
+acc += Math.sin(16147) + Math.cos(16148) * 45;
+acc += Math.sin(16148) + Math.cos(16149) * 46;
+acc += Math.sin(16149) + Math.cos(16150) * 47;
+acc += Math.sin(16150) + Math.cos(16151) * 48;
+acc += Math.sin(16151) + Math.cos(16152) * 49;
+acc += Math.sin(16152) + Math.cos(16153) * 50;
+acc += Math.sin(16153) + Math.cos(16154) * 51;
+acc += Math.sin(16154) + Math.cos(16155) * 52;
+acc += Math.sin(16155) + Math.cos(16156) * 53;
+acc += Math.sin(16156) + Math.cos(16157) * 54;
+acc += Math.sin(16157) + Math.cos(16158) * 55;
+acc += Math.sin(16158) + Math.cos(16159) * 56;
+acc += Math.sin(16159) + Math.cos(16160) * 57;
+acc += Math.sin(16160) + Math.cos(16161) * 58;
+acc += Math.sin(16161) + Math.cos(16162) * 59;
+acc += Math.sin(16162) + Math.cos(16163) * 60;
+acc += Math.sin(16163) + Math.cos(16164) * 61;
+acc += Math.sin(16164) + Math.cos(16165) * 62;
+acc += Math.sin(16165) + Math.cos(16166) * 63;
+acc += Math.sin(16166) + Math.cos(16167) * 64;
+acc += Math.sin(16167) + Math.cos(16168) * 65;
+acc += Math.sin(16168) + Math.cos(16169) * 66;
+acc += Math.sin(16169) + Math.cos(16170) * 67;
+acc += Math.sin(16170) + Math.cos(16171) * 68;
+acc += Math.sin(16171) + Math.cos(16172) * 69;
+acc += Math.sin(16172) + Math.cos(16173) * 70;
+acc += Math.sin(16173) + Math.cos(16174) * 71;
+acc += Math.sin(16174) + Math.cos(16175) * 72;
+acc += Math.sin(16175) + Math.cos(16176) * 73;
+acc += Math.sin(16176) + Math.cos(16177) * 74;
+acc += Math.sin(16177) + Math.cos(16178) * 75;
+acc += Math.sin(16178) + Math.cos(16179) * 76;
+acc += Math.sin(16179) + Math.cos(16180) * 77;
+acc += Math.sin(16180) + Math.cos(16181) * 78;
+acc += Math.sin(16181) + Math.cos(16182) * 79;
+acc += Math.sin(16182) + Math.cos(16183) * 80;
+acc += Math.sin(16183) + Math.cos(16184) * 81;
+acc += Math.sin(16184) + Math.cos(16185) * 82;
+acc += Math.sin(16185) + Math.cos(16186) * 83;
+acc += Math.sin(16186) + Math.cos(16187) * 84;
+acc += Math.sin(16187) + Math.cos(16188) * 85;
+acc += Math.sin(16188) + Math.cos(16189) * 86;
+acc += Math.sin(16189) + Math.cos(16190) * 87;
+acc += Math.sin(16190) + Math.cos(16191) * 88;
+acc += Math.sin(16191) + Math.cos(16192) * 89;
+acc += Math.sin(16192) + Math.cos(16193) * 90;
+acc += Math.sin(16193) + Math.cos(16194) * 91;
+acc += Math.sin(16194) + Math.cos(16195) * 92;
+acc += Math.sin(16195) + Math.cos(16196) * 93;
+acc += Math.sin(16196) + Math.cos(16197) * 94;
+acc += Math.sin(16197) + Math.cos(16198) * 95;
+acc += Math.sin(16198) + Math.cos(16199) * 96;
+acc += Math.sin(16199) + Math.cos(16200) * 0;
+acc += Math.sin(16200) + Math.cos(16201) * 1;
+acc += Math.sin(16201) + Math.cos(16202) * 2;
+acc += Math.sin(16202) + Math.cos(16203) * 3;
+acc += Math.sin(16203) + Math.cos(16204) * 4;
+acc += Math.sin(16204) + Math.cos(16205) * 5;
+acc += Math.sin(16205) + Math.cos(16206) * 6;
+acc += Math.sin(16206) + Math.cos(16207) * 7;
+acc += Math.sin(16207) + Math.cos(16208) * 8;
+acc += Math.sin(16208) + Math.cos(16209) * 9;
+acc += Math.sin(16209) + Math.cos(16210) * 10;
+acc += Math.sin(16210) + Math.cos(16211) * 11;
+acc += Math.sin(16211) + Math.cos(16212) * 12;
+acc += Math.sin(16212) + Math.cos(16213) * 13;
+acc += Math.sin(16213) + Math.cos(16214) * 14;
+acc += Math.sin(16214) + Math.cos(16215) * 15;
+acc += Math.sin(16215) + Math.cos(16216) * 16;
+acc += Math.sin(16216) + Math.cos(16217) * 17;
+acc += Math.sin(16217) + Math.cos(16218) * 18;
+acc += Math.sin(16218) + Math.cos(16219) * 19;
+acc += Math.sin(16219) + Math.cos(16220) * 20;
+acc += Math.sin(16220) + Math.cos(16221) * 21;
+acc += Math.sin(16221) + Math.cos(16222) * 22;
+acc += Math.sin(16222) + Math.cos(16223) * 23;
+acc += Math.sin(16223) + Math.cos(16224) * 24;
+acc += Math.sin(16224) + Math.cos(16225) * 25;
+acc += Math.sin(16225) + Math.cos(16226) * 26;
+acc += Math.sin(16226) + Math.cos(16227) * 27;
+acc += Math.sin(16227) + Math.cos(16228) * 28;
+acc += Math.sin(16228) + Math.cos(16229) * 29;
+acc += Math.sin(16229) + Math.cos(16230) * 30;
+acc += Math.sin(16230) + Math.cos(16231) * 31;
+acc += Math.sin(16231) + Math.cos(16232) * 32;
+acc += Math.sin(16232) + Math.cos(16233) * 33;
+acc += Math.sin(16233) + Math.cos(16234) * 34;
+acc += Math.sin(16234) + Math.cos(16235) * 35;
+acc += Math.sin(16235) + Math.cos(16236) * 36;
+acc += Math.sin(16236) + Math.cos(16237) * 37;
+acc += Math.sin(16237) + Math.cos(16238) * 38;
+acc += Math.sin(16238) + Math.cos(16239) * 39;
+acc += Math.sin(16239) + Math.cos(16240) * 40;
+acc += Math.sin(16240) + Math.cos(16241) * 41;
+acc += Math.sin(16241) + Math.cos(16242) * 42;
+acc += Math.sin(16242) + Math.cos(16243) * 43;
+acc += Math.sin(16243) + Math.cos(16244) * 44;
+acc += Math.sin(16244) + Math.cos(16245) * 45;
+acc += Math.sin(16245) + Math.cos(16246) * 46;
+acc += Math.sin(16246) + Math.cos(16247) * 47;
+acc += Math.sin(16247) + Math.cos(16248) * 48;
+acc += Math.sin(16248) + Math.cos(16249) * 49;
+acc += Math.sin(16249) + Math.cos(16250) * 50;
+acc += Math.sin(16250) + Math.cos(16251) * 51;
+acc += Math.sin(16251) + Math.cos(16252) * 52;
+acc += Math.sin(16252) + Math.cos(16253) * 53;
+acc += Math.sin(16253) + Math.cos(16254) * 54;
+acc += Math.sin(16254) + Math.cos(16255) * 55;
+acc += Math.sin(16255) + Math.cos(16256) * 56;
+acc += Math.sin(16256) + Math.cos(16257) * 57;
+acc += Math.sin(16257) + Math.cos(16258) * 58;
+acc += Math.sin(16258) + Math.cos(16259) * 59;
+acc += Math.sin(16259) + Math.cos(16260) * 60;
+acc += Math.sin(16260) + Math.cos(16261) * 61;
+acc += Math.sin(16261) + Math.cos(16262) * 62;
+acc += Math.sin(16262) + Math.cos(16263) * 63;
+acc += Math.sin(16263) + Math.cos(16264) * 64;
+acc += Math.sin(16264) + Math.cos(16265) * 65;
+acc += Math.sin(16265) + Math.cos(16266) * 66;
+acc += Math.sin(16266) + Math.cos(16267) * 67;
+acc += Math.sin(16267) + Math.cos(16268) * 68;
+acc += Math.sin(16268) + Math.cos(16269) * 69;
+acc += Math.sin(16269) + Math.cos(16270) * 70;
+acc += Math.sin(16270) + Math.cos(16271) * 71;
+acc += Math.sin(16271) + Math.cos(16272) * 72;
+acc += Math.sin(16272) + Math.cos(16273) * 73;
+acc += Math.sin(16273) + Math.cos(16274) * 74;
+acc += Math.sin(16274) + Math.cos(16275) * 75;
+acc += Math.sin(16275) + Math.cos(16276) * 76;
+acc += Math.sin(16276) + Math.cos(16277) * 77;
+acc += Math.sin(16277) + Math.cos(16278) * 78;
+acc += Math.sin(16278) + Math.cos(16279) * 79;
+acc += Math.sin(16279) + Math.cos(16280) * 80;
+acc += Math.sin(16280) + Math.cos(16281) * 81;
+acc += Math.sin(16281) + Math.cos(16282) * 82;
+acc += Math.sin(16282) + Math.cos(16283) * 83;
+acc += Math.sin(16283) + Math.cos(16284) * 84;
+acc += Math.sin(16284) + Math.cos(16285) * 85;
+acc += Math.sin(16285) + Math.cos(16286) * 86;
+acc += Math.sin(16286) + Math.cos(16287) * 87;
+acc += Math.sin(16287) + Math.cos(16288) * 88;
+acc += Math.sin(16288) + Math.cos(16289) * 89;
+acc += Math.sin(16289) + Math.cos(16290) * 90;
+acc += Math.sin(16290) + Math.cos(16291) * 91;
+acc += Math.sin(16291) + Math.cos(16292) * 92;
+acc += Math.sin(16292) + Math.cos(16293) * 93;
+acc += Math.sin(16293) + Math.cos(16294) * 94;
+acc += Math.sin(16294) + Math.cos(16295) * 95;
+acc += Math.sin(16295) + Math.cos(16296) * 96;
+acc += Math.sin(16296) + Math.cos(16297) * 0;
+acc += Math.sin(16297) + Math.cos(16298) * 1;
+acc += Math.sin(16298) + Math.cos(16299) * 2;
+acc += Math.sin(16299) + Math.cos(16300) * 3;
+acc += Math.sin(16300) + Math.cos(16301) * 4;
+acc += Math.sin(16301) + Math.cos(16302) * 5;
+acc += Math.sin(16302) + Math.cos(16303) * 6;
+acc += Math.sin(16303) + Math.cos(16304) * 7;
+acc += Math.sin(16304) + Math.cos(16305) * 8;
+acc += Math.sin(16305) + Math.cos(16306) * 9;
+acc += Math.sin(16306) + Math.cos(16307) * 10;
+acc += Math.sin(16307) + Math.cos(16308) * 11;
+acc += Math.sin(16308) + Math.cos(16309) * 12;
+acc += Math.sin(16309) + Math.cos(16310) * 13;
+acc += Math.sin(16310) + Math.cos(16311) * 14;
+acc += Math.sin(16311) + Math.cos(16312) * 15;
+acc += Math.sin(16312) + Math.cos(16313) * 16;
+acc += Math.sin(16313) + Math.cos(16314) * 17;
+acc += Math.sin(16314) + Math.cos(16315) * 18;
+acc += Math.sin(16315) + Math.cos(16316) * 19;
+acc += Math.sin(16316) + Math.cos(16317) * 20;
+acc += Math.sin(16317) + Math.cos(16318) * 21;
+acc += Math.sin(16318) + Math.cos(16319) * 22;
+acc += Math.sin(16319) + Math.cos(16320) * 23;
+acc += Math.sin(16320) + Math.cos(16321) * 24;
+acc += Math.sin(16321) + Math.cos(16322) * 25;
+acc += Math.sin(16322) + Math.cos(16323) * 26;
+acc += Math.sin(16323) + Math.cos(16324) * 27;
+acc += Math.sin(16324) + Math.cos(16325) * 28;
+acc += Math.sin(16325) + Math.cos(16326) * 29;
+acc += Math.sin(16326) + Math.cos(16327) * 30;
+acc += Math.sin(16327) + Math.cos(16328) * 31;
+acc += Math.sin(16328) + Math.cos(16329) * 32;
+acc += Math.sin(16329) + Math.cos(16330) * 33;
+acc += Math.sin(16330) + Math.cos(16331) * 34;
+acc += Math.sin(16331) + Math.cos(16332) * 35;
+acc += Math.sin(16332) + Math.cos(16333) * 36;
+acc += Math.sin(16333) + Math.cos(16334) * 37;
+acc += Math.sin(16334) + Math.cos(16335) * 38;
+acc += Math.sin(16335) + Math.cos(16336) * 39;
+acc += Math.sin(16336) + Math.cos(16337) * 40;
+acc += Math.sin(16337) + Math.cos(16338) * 41;
+acc += Math.sin(16338) + Math.cos(16339) * 42;
+acc += Math.sin(16339) + Math.cos(16340) * 43;
+acc += Math.sin(16340) + Math.cos(16341) * 44;
+acc += Math.sin(16341) + Math.cos(16342) * 45;
+acc += Math.sin(16342) + Math.cos(16343) * 46;
+acc += Math.sin(16343) + Math.cos(16344) * 47;
+acc += Math.sin(16344) + Math.cos(16345) * 48;
+acc += Math.sin(16345) + Math.cos(16346) * 49;
+acc += Math.sin(16346) + Math.cos(16347) * 50;
+acc += Math.sin(16347) + Math.cos(16348) * 51;
+acc += Math.sin(16348) + Math.cos(16349) * 52;
+acc += Math.sin(16349) + Math.cos(16350) * 53;
+acc += Math.sin(16350) + Math.cos(16351) * 54;
+acc += Math.sin(16351) + Math.cos(16352) * 55;
+acc += Math.sin(16352) + Math.cos(16353) * 56;
+acc += Math.sin(16353) + Math.cos(16354) * 57;
+acc += Math.sin(16354) + Math.cos(16355) * 58;
+acc += Math.sin(16355) + Math.cos(16356) * 59;
+acc += Math.sin(16356) + Math.cos(16357) * 60;
+acc += Math.sin(16357) + Math.cos(16358) * 61;
+acc += Math.sin(16358) + Math.cos(16359) * 62;
+acc += Math.sin(16359) + Math.cos(16360) * 63;
+acc += Math.sin(16360) + Math.cos(16361) * 64;
+acc += Math.sin(16361) + Math.cos(16362) * 65;
+acc += Math.sin(16362) + Math.cos(16363) * 66;
+acc += Math.sin(16363) + Math.cos(16364) * 67;
+acc += Math.sin(16364) + Math.cos(16365) * 68;
+acc += Math.sin(16365) + Math.cos(16366) * 69;
+acc += Math.sin(16366) + Math.cos(16367) * 70;
+acc += Math.sin(16367) + Math.cos(16368) * 71;
+acc += Math.sin(16368) + Math.cos(16369) * 72;
+acc += Math.sin(16369) + Math.cos(16370) * 73;
+acc += Math.sin(16370) + Math.cos(16371) * 74;
+acc += Math.sin(16371) + Math.cos(16372) * 75;
+acc += Math.sin(16372) + Math.cos(16373) * 76;
+acc += Math.sin(16373) + Math.cos(16374) * 77;
+acc += Math.sin(16374) + Math.cos(16375) * 78;
+acc += Math.sin(16375) + Math.cos(16376) * 79;
+acc += Math.sin(16376) + Math.cos(16377) * 80;
+acc += Math.sin(16377) + Math.cos(16378) * 81;
+acc += Math.sin(16378) + Math.cos(16379) * 82;
+acc += Math.sin(16379) + Math.cos(16380) * 83;
+acc += Math.sin(16380) + Math.cos(16381) * 84;
+acc += Math.sin(16381) + Math.cos(16382) * 85;
+acc += Math.sin(16382) + Math.cos(16383) * 86;
+acc += Math.sin(16383) + Math.cos(16384) * 87;
+acc += Math.sin(16384) + Math.cos(16385) * 88;
+acc += Math.sin(16385) + Math.cos(16386) * 89;
+acc += Math.sin(16386) + Math.cos(16387) * 90;
+acc += Math.sin(16387) + Math.cos(16388) * 91;
+acc += Math.sin(16388) + Math.cos(16389) * 92;
+acc += Math.sin(16389) + Math.cos(16390) * 93;
+acc += Math.sin(16390) + Math.cos(16391) * 94;
+acc += Math.sin(16391) + Math.cos(16392) * 95;
+acc += Math.sin(16392) + Math.cos(16393) * 96;
+acc += Math.sin(16393) + Math.cos(16394) * 0;
+acc += Math.sin(16394) + Math.cos(16395) * 1;
+acc += Math.sin(16395) + Math.cos(16396) * 2;
+acc += Math.sin(16396) + Math.cos(16397) * 3;
+acc += Math.sin(16397) + Math.cos(16398) * 4;
+acc += Math.sin(16398) + Math.cos(16399) * 5;
+acc += Math.sin(16399) + Math.cos(16400) * 6;
+acc += Math.sin(16400) + Math.cos(16401) * 7;
+acc += Math.sin(16401) + Math.cos(16402) * 8;
+acc += Math.sin(16402) + Math.cos(16403) * 9;
+acc += Math.sin(16403) + Math.cos(16404) * 10;
+acc += Math.sin(16404) + Math.cos(16405) * 11;
+acc += Math.sin(16405) + Math.cos(16406) * 12;
+acc += Math.sin(16406) + Math.cos(16407) * 13;
+acc += Math.sin(16407) + Math.cos(16408) * 14;
+acc += Math.sin(16408) + Math.cos(16409) * 15;
+acc += Math.sin(16409) + Math.cos(16410) * 16;
+acc += Math.sin(16410) + Math.cos(16411) * 17;
+acc += Math.sin(16411) + Math.cos(16412) * 18;
+acc += Math.sin(16412) + Math.cos(16413) * 19;
+acc += Math.sin(16413) + Math.cos(16414) * 20;
+acc += Math.sin(16414) + Math.cos(16415) * 21;
+acc += Math.sin(16415) + Math.cos(16416) * 22;
+acc += Math.sin(16416) + Math.cos(16417) * 23;
+acc += Math.sin(16417) + Math.cos(16418) * 24;
+acc += Math.sin(16418) + Math.cos(16419) * 25;
+acc += Math.sin(16419) + Math.cos(16420) * 26;
+acc += Math.sin(16420) + Math.cos(16421) * 27;
+acc += Math.sin(16421) + Math.cos(16422) * 28;
+acc += Math.sin(16422) + Math.cos(16423) * 29;
+acc += Math.sin(16423) + Math.cos(16424) * 30;
+acc += Math.sin(16424) + Math.cos(16425) * 31;
+acc += Math.sin(16425) + Math.cos(16426) * 32;
+acc += Math.sin(16426) + Math.cos(16427) * 33;
+acc += Math.sin(16427) + Math.cos(16428) * 34;
+acc += Math.sin(16428) + Math.cos(16429) * 35;
+acc += Math.sin(16429) + Math.cos(16430) * 36;
+acc += Math.sin(16430) + Math.cos(16431) * 37;
+acc += Math.sin(16431) + Math.cos(16432) * 38;
+acc += Math.sin(16432) + Math.cos(16433) * 39;
+acc += Math.sin(16433) + Math.cos(16434) * 40;
+acc += Math.sin(16434) + Math.cos(16435) * 41;
+acc += Math.sin(16435) + Math.cos(16436) * 42;
+acc += Math.sin(16436) + Math.cos(16437) * 43;
+acc += Math.sin(16437) + Math.cos(16438) * 44;
+acc += Math.sin(16438) + Math.cos(16439) * 45;
+acc += Math.sin(16439) + Math.cos(16440) * 46;
+acc += Math.sin(16440) + Math.cos(16441) * 47;
+acc += Math.sin(16441) + Math.cos(16442) * 48;
+acc += Math.sin(16442) + Math.cos(16443) * 49;
+acc += Math.sin(16443) + Math.cos(16444) * 50;
+acc += Math.sin(16444) + Math.cos(16445) * 51;
+acc += Math.sin(16445) + Math.cos(16446) * 52;
+acc += Math.sin(16446) + Math.cos(16447) * 53;
+acc += Math.sin(16447) + Math.cos(16448) * 54;
+acc += Math.sin(16448) + Math.cos(16449) * 55;
+acc += Math.sin(16449) + Math.cos(16450) * 56;
+acc += Math.sin(16450) + Math.cos(16451) * 57;
+acc += Math.sin(16451) + Math.cos(16452) * 58;
+acc += Math.sin(16452) + Math.cos(16453) * 59;
+acc += Math.sin(16453) + Math.cos(16454) * 60;
+acc += Math.sin(16454) + Math.cos(16455) * 61;
+acc += Math.sin(16455) + Math.cos(16456) * 62;
+acc += Math.sin(16456) + Math.cos(16457) * 63;
+acc += Math.sin(16457) + Math.cos(16458) * 64;
+acc += Math.sin(16458) + Math.cos(16459) * 65;
+acc += Math.sin(16459) + Math.cos(16460) * 66;
+acc += Math.sin(16460) + Math.cos(16461) * 67;
+acc += Math.sin(16461) + Math.cos(16462) * 68;
+acc += Math.sin(16462) + Math.cos(16463) * 69;
+acc += Math.sin(16463) + Math.cos(16464) * 70;
+acc += Math.sin(16464) + Math.cos(16465) * 71;
+acc += Math.sin(16465) + Math.cos(16466) * 72;
+acc += Math.sin(16466) + Math.cos(16467) * 73;
+acc += Math.sin(16467) + Math.cos(16468) * 74;
+acc += Math.sin(16468) + Math.cos(16469) * 75;
+acc += Math.sin(16469) + Math.cos(16470) * 76;
+acc += Math.sin(16470) + Math.cos(16471) * 77;
+acc += Math.sin(16471) + Math.cos(16472) * 78;
+acc += Math.sin(16472) + Math.cos(16473) * 79;
+acc += Math.sin(16473) + Math.cos(16474) * 80;
+acc += Math.sin(16474) + Math.cos(16475) * 81;
+acc += Math.sin(16475) + Math.cos(16476) * 82;
+acc += Math.sin(16476) + Math.cos(16477) * 83;
+acc += Math.sin(16477) + Math.cos(16478) * 84;
+acc += Math.sin(16478) + Math.cos(16479) * 85;
+acc += Math.sin(16479) + Math.cos(16480) * 86;
+acc += Math.sin(16480) + Math.cos(16481) * 87;
+acc += Math.sin(16481) + Math.cos(16482) * 88;
+acc += Math.sin(16482) + Math.cos(16483) * 89;
+acc += Math.sin(16483) + Math.cos(16484) * 90;
+acc += Math.sin(16484) + Math.cos(16485) * 91;
+acc += Math.sin(16485) + Math.cos(16486) * 92;
+acc += Math.sin(16486) + Math.cos(16487) * 93;
+acc += Math.sin(16487) + Math.cos(16488) * 94;
+acc += Math.sin(16488) + Math.cos(16489) * 95;
+acc += Math.sin(16489) + Math.cos(16490) * 96;
+acc += Math.sin(16490) + Math.cos(16491) * 0;
+acc += Math.sin(16491) + Math.cos(16492) * 1;
+acc += Math.sin(16492) + Math.cos(16493) * 2;
+acc += Math.sin(16493) + Math.cos(16494) * 3;
+acc += Math.sin(16494) + Math.cos(16495) * 4;
+acc += Math.sin(16495) + Math.cos(16496) * 5;
+acc += Math.sin(16496) + Math.cos(16497) * 6;
+acc += Math.sin(16497) + Math.cos(16498) * 7;
+acc += Math.sin(16498) + Math.cos(16499) * 8;
+acc += Math.sin(16499) + Math.cos(16500) * 9;
+acc += Math.sin(16500) + Math.cos(16501) * 10;
+acc += Math.sin(16501) + Math.cos(16502) * 11;
+acc += Math.sin(16502) + Math.cos(16503) * 12;
+acc += Math.sin(16503) + Math.cos(16504) * 13;
+acc += Math.sin(16504) + Math.cos(16505) * 14;
+acc += Math.sin(16505) + Math.cos(16506) * 15;
+acc += Math.sin(16506) + Math.cos(16507) * 16;
+acc += Math.sin(16507) + Math.cos(16508) * 17;
+acc += Math.sin(16508) + Math.cos(16509) * 18;
+acc += Math.sin(16509) + Math.cos(16510) * 19;
+acc += Math.sin(16510) + Math.cos(16511) * 20;
+acc += Math.sin(16511) + Math.cos(16512) * 21;
+acc += Math.sin(16512) + Math.cos(16513) * 22;
+acc += Math.sin(16513) + Math.cos(16514) * 23;
+acc += Math.sin(16514) + Math.cos(16515) * 24;
+acc += Math.sin(16515) + Math.cos(16516) * 25;
+acc += Math.sin(16516) + Math.cos(16517) * 26;
+acc += Math.sin(16517) + Math.cos(16518) * 27;
+acc += Math.sin(16518) + Math.cos(16519) * 28;
+acc += Math.sin(16519) + Math.cos(16520) * 29;
+acc += Math.sin(16520) + Math.cos(16521) * 30;
+acc += Math.sin(16521) + Math.cos(16522) * 31;
+acc += Math.sin(16522) + Math.cos(16523) * 32;
+acc += Math.sin(16523) + Math.cos(16524) * 33;
+acc += Math.sin(16524) + Math.cos(16525) * 34;
+acc += Math.sin(16525) + Math.cos(16526) * 35;
+acc += Math.sin(16526) + Math.cos(16527) * 36;
+acc += Math.sin(16527) + Math.cos(16528) * 37;
+acc += Math.sin(16528) + Math.cos(16529) * 38;
+acc += Math.sin(16529) + Math.cos(16530) * 39;
+acc += Math.sin(16530) + Math.cos(16531) * 40;
+acc += Math.sin(16531) + Math.cos(16532) * 41;
+acc += Math.sin(16532) + Math.cos(16533) * 42;
+acc += Math.sin(16533) + Math.cos(16534) * 43;
+acc += Math.sin(16534) + Math.cos(16535) * 44;
+acc += Math.sin(16535) + Math.cos(16536) * 45;
+acc += Math.sin(16536) + Math.cos(16537) * 46;
+acc += Math.sin(16537) + Math.cos(16538) * 47;
+acc += Math.sin(16538) + Math.cos(16539) * 48;
+acc += Math.sin(16539) + Math.cos(16540) * 49;
+acc += Math.sin(16540) + Math.cos(16541) * 50;
+acc += Math.sin(16541) + Math.cos(16542) * 51;
+acc += Math.sin(16542) + Math.cos(16543) * 52;
+acc += Math.sin(16543) + Math.cos(16544) * 53;
+acc += Math.sin(16544) + Math.cos(16545) * 54;
+acc += Math.sin(16545) + Math.cos(16546) * 55;
+acc += Math.sin(16546) + Math.cos(16547) * 56;
+acc += Math.sin(16547) + Math.cos(16548) * 57;
+acc += Math.sin(16548) + Math.cos(16549) * 58;
+acc += Math.sin(16549) + Math.cos(16550) * 59;
+acc += Math.sin(16550) + Math.cos(16551) * 60;
+acc += Math.sin(16551) + Math.cos(16552) * 61;
+acc += Math.sin(16552) + Math.cos(16553) * 62;
+acc += Math.sin(16553) + Math.cos(16554) * 63;
+acc += Math.sin(16554) + Math.cos(16555) * 64;
+acc += Math.sin(16555) + Math.cos(16556) * 65;
+acc += Math.sin(16556) + Math.cos(16557) * 66;
+acc += Math.sin(16557) + Math.cos(16558) * 67;
+acc += Math.sin(16558) + Math.cos(16559) * 68;
+acc += Math.sin(16559) + Math.cos(16560) * 69;
+acc += Math.sin(16560) + Math.cos(16561) * 70;
+acc += Math.sin(16561) + Math.cos(16562) * 71;
+acc += Math.sin(16562) + Math.cos(16563) * 72;
+acc += Math.sin(16563) + Math.cos(16564) * 73;
+acc += Math.sin(16564) + Math.cos(16565) * 74;
+acc += Math.sin(16565) + Math.cos(16566) * 75;
+acc += Math.sin(16566) + Math.cos(16567) * 76;
+acc += Math.sin(16567) + Math.cos(16568) * 77;
+acc += Math.sin(16568) + Math.cos(16569) * 78;
+acc += Math.sin(16569) + Math.cos(16570) * 79;
+acc += Math.sin(16570) + Math.cos(16571) * 80;
+acc += Math.sin(16571) + Math.cos(16572) * 81;
+acc += Math.sin(16572) + Math.cos(16573) * 82;
+acc += Math.sin(16573) + Math.cos(16574) * 83;
+acc += Math.sin(16574) + Math.cos(16575) * 84;
+acc += Math.sin(16575) + Math.cos(16576) * 85;
+acc += Math.sin(16576) + Math.cos(16577) * 86;
+acc += Math.sin(16577) + Math.cos(16578) * 87;
+acc += Math.sin(16578) + Math.cos(16579) * 88;
+acc += Math.sin(16579) + Math.cos(16580) * 89;
+acc += Math.sin(16580) + Math.cos(16581) * 90;
+acc += Math.sin(16581) + Math.cos(16582) * 91;
+acc += Math.sin(16582) + Math.cos(16583) * 92;
+acc += Math.sin(16583) + Math.cos(16584) * 93;
+acc += Math.sin(16584) + Math.cos(16585) * 94;
+acc += Math.sin(16585) + Math.cos(16586) * 95;
+acc += Math.sin(16586) + Math.cos(16587) * 96;
+acc += Math.sin(16587) + Math.cos(16588) * 0;
+acc += Math.sin(16588) + Math.cos(16589) * 1;
+acc += Math.sin(16589) + Math.cos(16590) * 2;
+acc += Math.sin(16590) + Math.cos(16591) * 3;
+acc += Math.sin(16591) + Math.cos(16592) * 4;
+acc += Math.sin(16592) + Math.cos(16593) * 5;
+acc += Math.sin(16593) + Math.cos(16594) * 6;
+acc += Math.sin(16594) + Math.cos(16595) * 7;
+acc += Math.sin(16595) + Math.cos(16596) * 8;
+acc += Math.sin(16596) + Math.cos(16597) * 9;
+acc += Math.sin(16597) + Math.cos(16598) * 10;
+acc += Math.sin(16598) + Math.cos(16599) * 11;
+acc += Math.sin(16599) + Math.cos(16600) * 12;
+acc += Math.sin(16600) + Math.cos(16601) * 13;
+acc += Math.sin(16601) + Math.cos(16602) * 14;
+acc += Math.sin(16602) + Math.cos(16603) * 15;
+acc += Math.sin(16603) + Math.cos(16604) * 16;
+acc += Math.sin(16604) + Math.cos(16605) * 17;
+acc += Math.sin(16605) + Math.cos(16606) * 18;
+acc += Math.sin(16606) + Math.cos(16607) * 19;
+acc += Math.sin(16607) + Math.cos(16608) * 20;
+acc += Math.sin(16608) + Math.cos(16609) * 21;
+acc += Math.sin(16609) + Math.cos(16610) * 22;
+acc += Math.sin(16610) + Math.cos(16611) * 23;
+acc += Math.sin(16611) + Math.cos(16612) * 24;
+acc += Math.sin(16612) + Math.cos(16613) * 25;
+acc += Math.sin(16613) + Math.cos(16614) * 26;
+acc += Math.sin(16614) + Math.cos(16615) * 27;
+acc += Math.sin(16615) + Math.cos(16616) * 28;
+acc += Math.sin(16616) + Math.cos(16617) * 29;
+acc += Math.sin(16617) + Math.cos(16618) * 30;
+acc += Math.sin(16618) + Math.cos(16619) * 31;
+acc += Math.sin(16619) + Math.cos(16620) * 32;
+acc += Math.sin(16620) + Math.cos(16621) * 33;
+acc += Math.sin(16621) + Math.cos(16622) * 34;
+acc += Math.sin(16622) + Math.cos(16623) * 35;
+acc += Math.sin(16623) + Math.cos(16624) * 36;
+acc += Math.sin(16624) + Math.cos(16625) * 37;
+acc += Math.sin(16625) + Math.cos(16626) * 38;
+acc += Math.sin(16626) + Math.cos(16627) * 39;
+acc += Math.sin(16627) + Math.cos(16628) * 40;
+acc += Math.sin(16628) + Math.cos(16629) * 41;
+acc += Math.sin(16629) + Math.cos(16630) * 42;
+acc += Math.sin(16630) + Math.cos(16631) * 43;
+acc += Math.sin(16631) + Math.cos(16632) * 44;
+acc += Math.sin(16632) + Math.cos(16633) * 45;
+acc += Math.sin(16633) + Math.cos(16634) * 46;
+acc += Math.sin(16634) + Math.cos(16635) * 47;
+acc += Math.sin(16635) + Math.cos(16636) * 48;
+acc += Math.sin(16636) + Math.cos(16637) * 49;
+acc += Math.sin(16637) + Math.cos(16638) * 50;
+acc += Math.sin(16638) + Math.cos(16639) * 51;
+acc += Math.sin(16639) + Math.cos(16640) * 52;
+acc += Math.sin(16640) + Math.cos(16641) * 53;
+acc += Math.sin(16641) + Math.cos(16642) * 54;
+acc += Math.sin(16642) + Math.cos(16643) * 55;
+acc += Math.sin(16643) + Math.cos(16644) * 56;
+acc += Math.sin(16644) + Math.cos(16645) * 57;
+acc += Math.sin(16645) + Math.cos(16646) * 58;
+acc += Math.sin(16646) + Math.cos(16647) * 59;
+acc += Math.sin(16647) + Math.cos(16648) * 60;
+acc += Math.sin(16648) + Math.cos(16649) * 61;
+acc += Math.sin(16649) + Math.cos(16650) * 62;
+acc += Math.sin(16650) + Math.cos(16651) * 63;
+acc += Math.sin(16651) + Math.cos(16652) * 64;
+acc += Math.sin(16652) + Math.cos(16653) * 65;
+acc += Math.sin(16653) + Math.cos(16654) * 66;
+acc += Math.sin(16654) + Math.cos(16655) * 67;
+acc += Math.sin(16655) + Math.cos(16656) * 68;
+acc += Math.sin(16656) + Math.cos(16657) * 69;
+acc += Math.sin(16657) + Math.cos(16658) * 70;
+acc += Math.sin(16658) + Math.cos(16659) * 71;
+acc += Math.sin(16659) + Math.cos(16660) * 72;
+acc += Math.sin(16660) + Math.cos(16661) * 73;
+acc += Math.sin(16661) + Math.cos(16662) * 74;
+acc += Math.sin(16662) + Math.cos(16663) * 75;
+acc += Math.sin(16663) + Math.cos(16664) * 76;
+acc += Math.sin(16664) + Math.cos(16665) * 77;
+acc += Math.sin(16665) + Math.cos(16666) * 78;
+acc += Math.sin(16666) + Math.cos(16667) * 79;
+acc += Math.sin(16667) + Math.cos(16668) * 80;
+acc += Math.sin(16668) + Math.cos(16669) * 81;
+acc += Math.sin(16669) + Math.cos(16670) * 82;
+acc += Math.sin(16670) + Math.cos(16671) * 83;
+acc += Math.sin(16671) + Math.cos(16672) * 84;
+acc += Math.sin(16672) + Math.cos(16673) * 85;
+acc += Math.sin(16673) + Math.cos(16674) * 86;
+acc += Math.sin(16674) + Math.cos(16675) * 87;
+acc += Math.sin(16675) + Math.cos(16676) * 88;
+acc += Math.sin(16676) + Math.cos(16677) * 89;
+acc += Math.sin(16677) + Math.cos(16678) * 90;
+acc += Math.sin(16678) + Math.cos(16679) * 91;
+acc += Math.sin(16679) + Math.cos(16680) * 92;
+acc += Math.sin(16680) + Math.cos(16681) * 93;
+acc += Math.sin(16681) + Math.cos(16682) * 94;
+acc += Math.sin(16682) + Math.cos(16683) * 95;
+acc += Math.sin(16683) + Math.cos(16684) * 96;
+acc += Math.sin(16684) + Math.cos(16685) * 0;
+acc += Math.sin(16685) + Math.cos(16686) * 1;
+acc += Math.sin(16686) + Math.cos(16687) * 2;
+acc += Math.sin(16687) + Math.cos(16688) * 3;
+acc += Math.sin(16688) + Math.cos(16689) * 4;
+acc += Math.sin(16689) + Math.cos(16690) * 5;
+acc += Math.sin(16690) + Math.cos(16691) * 6;
+acc += Math.sin(16691) + Math.cos(16692) * 7;
+acc += Math.sin(16692) + Math.cos(16693) * 8;
+acc += Math.sin(16693) + Math.cos(16694) * 9;
+acc += Math.sin(16694) + Math.cos(16695) * 10;
+acc += Math.sin(16695) + Math.cos(16696) * 11;
+acc += Math.sin(16696) + Math.cos(16697) * 12;
+acc += Math.sin(16697) + Math.cos(16698) * 13;
+acc += Math.sin(16698) + Math.cos(16699) * 14;
+acc += Math.sin(16699) + Math.cos(16700) * 15;
+acc += Math.sin(16700) + Math.cos(16701) * 16;
+acc += Math.sin(16701) + Math.cos(16702) * 17;
+acc += Math.sin(16702) + Math.cos(16703) * 18;
+acc += Math.sin(16703) + Math.cos(16704) * 19;
+acc += Math.sin(16704) + Math.cos(16705) * 20;
+acc += Math.sin(16705) + Math.cos(16706) * 21;
+acc += Math.sin(16706) + Math.cos(16707) * 22;
+acc += Math.sin(16707) + Math.cos(16708) * 23;
+acc += Math.sin(16708) + Math.cos(16709) * 24;
+acc += Math.sin(16709) + Math.cos(16710) * 25;
+acc += Math.sin(16710) + Math.cos(16711) * 26;
+acc += Math.sin(16711) + Math.cos(16712) * 27;
+acc += Math.sin(16712) + Math.cos(16713) * 28;
+acc += Math.sin(16713) + Math.cos(16714) * 29;
+acc += Math.sin(16714) + Math.cos(16715) * 30;
+acc += Math.sin(16715) + Math.cos(16716) * 31;
+acc += Math.sin(16716) + Math.cos(16717) * 32;
+acc += Math.sin(16717) + Math.cos(16718) * 33;
+acc += Math.sin(16718) + Math.cos(16719) * 34;
+acc += Math.sin(16719) + Math.cos(16720) * 35;
+acc += Math.sin(16720) + Math.cos(16721) * 36;
+acc += Math.sin(16721) + Math.cos(16722) * 37;
+acc += Math.sin(16722) + Math.cos(16723) * 38;
+acc += Math.sin(16723) + Math.cos(16724) * 39;
+acc += Math.sin(16724) + Math.cos(16725) * 40;
+acc += Math.sin(16725) + Math.cos(16726) * 41;
+acc += Math.sin(16726) + Math.cos(16727) * 42;
+acc += Math.sin(16727) + Math.cos(16728) * 43;
+acc += Math.sin(16728) + Math.cos(16729) * 44;
+acc += Math.sin(16729) + Math.cos(16730) * 45;
+acc += Math.sin(16730) + Math.cos(16731) * 46;
+acc += Math.sin(16731) + Math.cos(16732) * 47;
+acc += Math.sin(16732) + Math.cos(16733) * 48;
+acc += Math.sin(16733) + Math.cos(16734) * 49;
+acc += Math.sin(16734) + Math.cos(16735) * 50;
+acc += Math.sin(16735) + Math.cos(16736) * 51;
+acc += Math.sin(16736) + Math.cos(16737) * 52;
+acc += Math.sin(16737) + Math.cos(16738) * 53;
+acc += Math.sin(16738) + Math.cos(16739) * 54;
+acc += Math.sin(16739) + Math.cos(16740) * 55;
+acc += Math.sin(16740) + Math.cos(16741) * 56;
+acc += Math.sin(16741) + Math.cos(16742) * 57;
+acc += Math.sin(16742) + Math.cos(16743) * 58;
+acc += Math.sin(16743) + Math.cos(16744) * 59;
+acc += Math.sin(16744) + Math.cos(16745) * 60;
+acc += Math.sin(16745) + Math.cos(16746) * 61;
+acc += Math.sin(16746) + Math.cos(16747) * 62;
+acc += Math.sin(16747) + Math.cos(16748) * 63;
+acc += Math.sin(16748) + Math.cos(16749) * 64;
+acc += Math.sin(16749) + Math.cos(16750) * 65;
+acc += Math.sin(16750) + Math.cos(16751) * 66;
+acc += Math.sin(16751) + Math.cos(16752) * 67;
+acc += Math.sin(16752) + Math.cos(16753) * 68;
+acc += Math.sin(16753) + Math.cos(16754) * 69;
+acc += Math.sin(16754) + Math.cos(16755) * 70;
+acc += Math.sin(16755) + Math.cos(16756) * 71;
+acc += Math.sin(16756) + Math.cos(16757) * 72;
+acc += Math.sin(16757) + Math.cos(16758) * 73;
+acc += Math.sin(16758) + Math.cos(16759) * 74;
+acc += Math.sin(16759) + Math.cos(16760) * 75;
+acc += Math.sin(16760) + Math.cos(16761) * 76;
+acc += Math.sin(16761) + Math.cos(16762) * 77;
+acc += Math.sin(16762) + Math.cos(16763) * 78;
+acc += Math.sin(16763) + Math.cos(16764) * 79;
+acc += Math.sin(16764) + Math.cos(16765) * 80;
+acc += Math.sin(16765) + Math.cos(16766) * 81;
+acc += Math.sin(16766) + Math.cos(16767) * 82;
+acc += Math.sin(16767) + Math.cos(16768) * 83;
+acc += Math.sin(16768) + Math.cos(16769) * 84;
+acc += Math.sin(16769) + Math.cos(16770) * 85;
+acc += Math.sin(16770) + Math.cos(16771) * 86;
+acc += Math.sin(16771) + Math.cos(16772) * 87;
+acc += Math.sin(16772) + Math.cos(16773) * 88;
+acc += Math.sin(16773) + Math.cos(16774) * 89;
+acc += Math.sin(16774) + Math.cos(16775) * 90;
+acc += Math.sin(16775) + Math.cos(16776) * 91;
+acc += Math.sin(16776) + Math.cos(16777) * 92;
+acc += Math.sin(16777) + Math.cos(16778) * 93;
+acc += Math.sin(16778) + Math.cos(16779) * 94;
+acc += Math.sin(16779) + Math.cos(16780) * 95;
+acc += Math.sin(16780) + Math.cos(16781) * 96;
+acc += Math.sin(16781) + Math.cos(16782) * 0;
+acc += Math.sin(16782) + Math.cos(16783) * 1;
+acc += Math.sin(16783) + Math.cos(16784) * 2;
+acc += Math.sin(16784) + Math.cos(16785) * 3;
+acc += Math.sin(16785) + Math.cos(16786) * 4;
+acc += Math.sin(16786) + Math.cos(16787) * 5;
+acc += Math.sin(16787) + Math.cos(16788) * 6;
+acc += Math.sin(16788) + Math.cos(16789) * 7;
+acc += Math.sin(16789) + Math.cos(16790) * 8;
+acc += Math.sin(16790) + Math.cos(16791) * 9;
+acc += Math.sin(16791) + Math.cos(16792) * 10;
+acc += Math.sin(16792) + Math.cos(16793) * 11;
+acc += Math.sin(16793) + Math.cos(16794) * 12;
+acc += Math.sin(16794) + Math.cos(16795) * 13;
+acc += Math.sin(16795) + Math.cos(16796) * 14;
+acc += Math.sin(16796) + Math.cos(16797) * 15;
+acc += Math.sin(16797) + Math.cos(16798) * 16;
+acc += Math.sin(16798) + Math.cos(16799) * 17;
+acc += Math.sin(16799) + Math.cos(16800) * 18;
+acc += Math.sin(16800) + Math.cos(16801) * 19;
+acc += Math.sin(16801) + Math.cos(16802) * 20;
+acc += Math.sin(16802) + Math.cos(16803) * 21;
+acc += Math.sin(16803) + Math.cos(16804) * 22;
+acc += Math.sin(16804) + Math.cos(16805) * 23;
+acc += Math.sin(16805) + Math.cos(16806) * 24;
+acc += Math.sin(16806) + Math.cos(16807) * 25;
+acc += Math.sin(16807) + Math.cos(16808) * 26;
+acc += Math.sin(16808) + Math.cos(16809) * 27;
+acc += Math.sin(16809) + Math.cos(16810) * 28;
+acc += Math.sin(16810) + Math.cos(16811) * 29;
+acc += Math.sin(16811) + Math.cos(16812) * 30;
+acc += Math.sin(16812) + Math.cos(16813) * 31;
+acc += Math.sin(16813) + Math.cos(16814) * 32;
+acc += Math.sin(16814) + Math.cos(16815) * 33;
+acc += Math.sin(16815) + Math.cos(16816) * 34;
+acc += Math.sin(16816) + Math.cos(16817) * 35;
+acc += Math.sin(16817) + Math.cos(16818) * 36;
+acc += Math.sin(16818) + Math.cos(16819) * 37;
+acc += Math.sin(16819) + Math.cos(16820) * 38;
+acc += Math.sin(16820) + Math.cos(16821) * 39;
+acc += Math.sin(16821) + Math.cos(16822) * 40;
+acc += Math.sin(16822) + Math.cos(16823) * 41;
+acc += Math.sin(16823) + Math.cos(16824) * 42;
+acc += Math.sin(16824) + Math.cos(16825) * 43;
+acc += Math.sin(16825) + Math.cos(16826) * 44;
+acc += Math.sin(16826) + Math.cos(16827) * 45;
+acc += Math.sin(16827) + Math.cos(16828) * 46;
+acc += Math.sin(16828) + Math.cos(16829) * 47;
+acc += Math.sin(16829) + Math.cos(16830) * 48;
+acc += Math.sin(16830) + Math.cos(16831) * 49;
+acc += Math.sin(16831) + Math.cos(16832) * 50;
+acc += Math.sin(16832) + Math.cos(16833) * 51;
+acc += Math.sin(16833) + Math.cos(16834) * 52;
+acc += Math.sin(16834) + Math.cos(16835) * 53;
+acc += Math.sin(16835) + Math.cos(16836) * 54;
+acc += Math.sin(16836) + Math.cos(16837) * 55;
+acc += Math.sin(16837) + Math.cos(16838) * 56;
+acc += Math.sin(16838) + Math.cos(16839) * 57;
+acc += Math.sin(16839) + Math.cos(16840) * 58;
+acc += Math.sin(16840) + Math.cos(16841) * 59;
+acc += Math.sin(16841) + Math.cos(16842) * 60;
+acc += Math.sin(16842) + Math.cos(16843) * 61;
+acc += Math.sin(16843) + Math.cos(16844) * 62;
+acc += Math.sin(16844) + Math.cos(16845) * 63;
+acc += Math.sin(16845) + Math.cos(16846) * 64;
+acc += Math.sin(16846) + Math.cos(16847) * 65;
+acc += Math.sin(16847) + Math.cos(16848) * 66;
+acc += Math.sin(16848) + Math.cos(16849) * 67;
+acc += Math.sin(16849) + Math.cos(16850) * 68;
+acc += Math.sin(16850) + Math.cos(16851) * 69;
+acc += Math.sin(16851) + Math.cos(16852) * 70;
+acc += Math.sin(16852) + Math.cos(16853) * 71;
+acc += Math.sin(16853) + Math.cos(16854) * 72;
+acc += Math.sin(16854) + Math.cos(16855) * 73;
+acc += Math.sin(16855) + Math.cos(16856) * 74;
+acc += Math.sin(16856) + Math.cos(16857) * 75;
+acc += Math.sin(16857) + Math.cos(16858) * 76;
+acc += Math.sin(16858) + Math.cos(16859) * 77;
+acc += Math.sin(16859) + Math.cos(16860) * 78;
+acc += Math.sin(16860) + Math.cos(16861) * 79;
+acc += Math.sin(16861) + Math.cos(16862) * 80;
+acc += Math.sin(16862) + Math.cos(16863) * 81;
+acc += Math.sin(16863) + Math.cos(16864) * 82;
+acc += Math.sin(16864) + Math.cos(16865) * 83;
+acc += Math.sin(16865) + Math.cos(16866) * 84;
+acc += Math.sin(16866) + Math.cos(16867) * 85;
+acc += Math.sin(16867) + Math.cos(16868) * 86;
+acc += Math.sin(16868) + Math.cos(16869) * 87;
+acc += Math.sin(16869) + Math.cos(16870) * 88;
+acc += Math.sin(16870) + Math.cos(16871) * 89;
+acc += Math.sin(16871) + Math.cos(16872) * 90;
+acc += Math.sin(16872) + Math.cos(16873) * 91;
+acc += Math.sin(16873) + Math.cos(16874) * 92;
+acc += Math.sin(16874) + Math.cos(16875) * 93;
+acc += Math.sin(16875) + Math.cos(16876) * 94;
+acc += Math.sin(16876) + Math.cos(16877) * 95;
+acc += Math.sin(16877) + Math.cos(16878) * 96;
+acc += Math.sin(16878) + Math.cos(16879) * 0;
+acc += Math.sin(16879) + Math.cos(16880) * 1;
+acc += Math.sin(16880) + Math.cos(16881) * 2;
+acc += Math.sin(16881) + Math.cos(16882) * 3;
+acc += Math.sin(16882) + Math.cos(16883) * 4;
+acc += Math.sin(16883) + Math.cos(16884) * 5;
+acc += Math.sin(16884) + Math.cos(16885) * 6;
+acc += Math.sin(16885) + Math.cos(16886) * 7;
+acc += Math.sin(16886) + Math.cos(16887) * 8;
+acc += Math.sin(16887) + Math.cos(16888) * 9;
+acc += Math.sin(16888) + Math.cos(16889) * 10;
+acc += Math.sin(16889) + Math.cos(16890) * 11;
+acc += Math.sin(16890) + Math.cos(16891) * 12;
+acc += Math.sin(16891) + Math.cos(16892) * 13;
+acc += Math.sin(16892) + Math.cos(16893) * 14;
+acc += Math.sin(16893) + Math.cos(16894) * 15;
+acc += Math.sin(16894) + Math.cos(16895) * 16;
+acc += Math.sin(16895) + Math.cos(16896) * 17;
+acc += Math.sin(16896) + Math.cos(16897) * 18;
+acc += Math.sin(16897) + Math.cos(16898) * 19;
+acc += Math.sin(16898) + Math.cos(16899) * 20;
+acc += Math.sin(16899) + Math.cos(16900) * 21;
+acc += Math.sin(16900) + Math.cos(16901) * 22;
+acc += Math.sin(16901) + Math.cos(16902) * 23;
+acc += Math.sin(16902) + Math.cos(16903) * 24;
+acc += Math.sin(16903) + Math.cos(16904) * 25;
+acc += Math.sin(16904) + Math.cos(16905) * 26;
+acc += Math.sin(16905) + Math.cos(16906) * 27;
+acc += Math.sin(16906) + Math.cos(16907) * 28;
+acc += Math.sin(16907) + Math.cos(16908) * 29;
+acc += Math.sin(16908) + Math.cos(16909) * 30;
+acc += Math.sin(16909) + Math.cos(16910) * 31;
+acc += Math.sin(16910) + Math.cos(16911) * 32;
+acc += Math.sin(16911) + Math.cos(16912) * 33;
+acc += Math.sin(16912) + Math.cos(16913) * 34;
+acc += Math.sin(16913) + Math.cos(16914) * 35;
+acc += Math.sin(16914) + Math.cos(16915) * 36;
+acc += Math.sin(16915) + Math.cos(16916) * 37;
+acc += Math.sin(16916) + Math.cos(16917) * 38;
+acc += Math.sin(16917) + Math.cos(16918) * 39;
+acc += Math.sin(16918) + Math.cos(16919) * 40;
+acc += Math.sin(16919) + Math.cos(16920) * 41;
+acc += Math.sin(16920) + Math.cos(16921) * 42;
+acc += Math.sin(16921) + Math.cos(16922) * 43;
+acc += Math.sin(16922) + Math.cos(16923) * 44;
+acc += Math.sin(16923) + Math.cos(16924) * 45;
+acc += Math.sin(16924) + Math.cos(16925) * 46;
+acc += Math.sin(16925) + Math.cos(16926) * 47;
+acc += Math.sin(16926) + Math.cos(16927) * 48;
+acc += Math.sin(16927) + Math.cos(16928) * 49;
+acc += Math.sin(16928) + Math.cos(16929) * 50;
+acc += Math.sin(16929) + Math.cos(16930) * 51;
+acc += Math.sin(16930) + Math.cos(16931) * 52;
+acc += Math.sin(16931) + Math.cos(16932) * 53;
+acc += Math.sin(16932) + Math.cos(16933) * 54;
+acc += Math.sin(16933) + Math.cos(16934) * 55;
+acc += Math.sin(16934) + Math.cos(16935) * 56;
+acc += Math.sin(16935) + Math.cos(16936) * 57;
+acc += Math.sin(16936) + Math.cos(16937) * 58;
+acc += Math.sin(16937) + Math.cos(16938) * 59;
+acc += Math.sin(16938) + Math.cos(16939) * 60;
+acc += Math.sin(16939) + Math.cos(16940) * 61;
+acc += Math.sin(16940) + Math.cos(16941) * 62;
+acc += Math.sin(16941) + Math.cos(16942) * 63;
+acc += Math.sin(16942) + Math.cos(16943) * 64;
+acc += Math.sin(16943) + Math.cos(16944) * 65;
+acc += Math.sin(16944) + Math.cos(16945) * 66;
+acc += Math.sin(16945) + Math.cos(16946) * 67;
+acc += Math.sin(16946) + Math.cos(16947) * 68;
+acc += Math.sin(16947) + Math.cos(16948) * 69;
+acc += Math.sin(16948) + Math.cos(16949) * 70;
+acc += Math.sin(16949) + Math.cos(16950) * 71;
+acc += Math.sin(16950) + Math.cos(16951) * 72;
+acc += Math.sin(16951) + Math.cos(16952) * 73;
+acc += Math.sin(16952) + Math.cos(16953) * 74;
+acc += Math.sin(16953) + Math.cos(16954) * 75;
+acc += Math.sin(16954) + Math.cos(16955) * 76;
+acc += Math.sin(16955) + Math.cos(16956) * 77;
+acc += Math.sin(16956) + Math.cos(16957) * 78;
+acc += Math.sin(16957) + Math.cos(16958) * 79;
+acc += Math.sin(16958) + Math.cos(16959) * 80;
+acc += Math.sin(16959) + Math.cos(16960) * 81;
+acc += Math.sin(16960) + Math.cos(16961) * 82;
+acc += Math.sin(16961) + Math.cos(16962) * 83;
+acc += Math.sin(16962) + Math.cos(16963) * 84;
+acc += Math.sin(16963) + Math.cos(16964) * 85;
+acc += Math.sin(16964) + Math.cos(16965) * 86;
+acc += Math.sin(16965) + Math.cos(16966) * 87;
+acc += Math.sin(16966) + Math.cos(16967) * 88;
+acc += Math.sin(16967) + Math.cos(16968) * 89;
+acc += Math.sin(16968) + Math.cos(16969) * 90;
+acc += Math.sin(16969) + Math.cos(16970) * 91;
+acc += Math.sin(16970) + Math.cos(16971) * 92;
+acc += Math.sin(16971) + Math.cos(16972) * 93;
+acc += Math.sin(16972) + Math.cos(16973) * 94;
+acc += Math.sin(16973) + Math.cos(16974) * 95;
+acc += Math.sin(16974) + Math.cos(16975) * 96;
+acc += Math.sin(16975) + Math.cos(16976) * 0;
+acc += Math.sin(16976) + Math.cos(16977) * 1;
+acc += Math.sin(16977) + Math.cos(16978) * 2;
+acc += Math.sin(16978) + Math.cos(16979) * 3;
+acc += Math.sin(16979) + Math.cos(16980) * 4;
+acc += Math.sin(16980) + Math.cos(16981) * 5;
+acc += Math.sin(16981) + Math.cos(16982) * 6;
+acc += Math.sin(16982) + Math.cos(16983) * 7;
+acc += Math.sin(16983) + Math.cos(16984) * 8;
+acc += Math.sin(16984) + Math.cos(16985) * 9;
+acc += Math.sin(16985) + Math.cos(16986) * 10;
+acc += Math.sin(16986) + Math.cos(16987) * 11;
+acc += Math.sin(16987) + Math.cos(16988) * 12;
+acc += Math.sin(16988) + Math.cos(16989) * 13;
+acc += Math.sin(16989) + Math.cos(16990) * 14;
+acc += Math.sin(16990) + Math.cos(16991) * 15;
+acc += Math.sin(16991) + Math.cos(16992) * 16;
+acc += Math.sin(16992) + Math.cos(16993) * 17;
+acc += Math.sin(16993) + Math.cos(16994) * 18;
+acc += Math.sin(16994) + Math.cos(16995) * 19;
+acc += Math.sin(16995) + Math.cos(16996) * 20;
+acc += Math.sin(16996) + Math.cos(16997) * 21;
+acc += Math.sin(16997) + Math.cos(16998) * 22;
+acc += Math.sin(16998) + Math.cos(16999) * 23;
+acc += Math.sin(16999) + Math.cos(17000) * 24;
+acc += Math.sin(17000) + Math.cos(17001) * 25;
+acc += Math.sin(17001) + Math.cos(17002) * 26;
+acc += Math.sin(17002) + Math.cos(17003) * 27;
+acc += Math.sin(17003) + Math.cos(17004) * 28;
+acc += Math.sin(17004) + Math.cos(17005) * 29;
+acc += Math.sin(17005) + Math.cos(17006) * 30;
+acc += Math.sin(17006) + Math.cos(17007) * 31;
+acc += Math.sin(17007) + Math.cos(17008) * 32;
+acc += Math.sin(17008) + Math.cos(17009) * 33;
+acc += Math.sin(17009) + Math.cos(17010) * 34;
+acc += Math.sin(17010) + Math.cos(17011) * 35;
+acc += Math.sin(17011) + Math.cos(17012) * 36;
+acc += Math.sin(17012) + Math.cos(17013) * 37;
+acc += Math.sin(17013) + Math.cos(17014) * 38;
+acc += Math.sin(17014) + Math.cos(17015) * 39;
+acc += Math.sin(17015) + Math.cos(17016) * 40;
+acc += Math.sin(17016) + Math.cos(17017) * 41;
+acc += Math.sin(17017) + Math.cos(17018) * 42;
+acc += Math.sin(17018) + Math.cos(17019) * 43;
+acc += Math.sin(17019) + Math.cos(17020) * 44;
+acc += Math.sin(17020) + Math.cos(17021) * 45;
+acc += Math.sin(17021) + Math.cos(17022) * 46;
+acc += Math.sin(17022) + Math.cos(17023) * 47;
+acc += Math.sin(17023) + Math.cos(17024) * 48;
+acc += Math.sin(17024) + Math.cos(17025) * 49;
+acc += Math.sin(17025) + Math.cos(17026) * 50;
+acc += Math.sin(17026) + Math.cos(17027) * 51;
+acc += Math.sin(17027) + Math.cos(17028) * 52;
+acc += Math.sin(17028) + Math.cos(17029) * 53;
+acc += Math.sin(17029) + Math.cos(17030) * 54;
+acc += Math.sin(17030) + Math.cos(17031) * 55;
+acc += Math.sin(17031) + Math.cos(17032) * 56;
+acc += Math.sin(17032) + Math.cos(17033) * 57;
+acc += Math.sin(17033) + Math.cos(17034) * 58;
+acc += Math.sin(17034) + Math.cos(17035) * 59;
+acc += Math.sin(17035) + Math.cos(17036) * 60;
+acc += Math.sin(17036) + Math.cos(17037) * 61;
+acc += Math.sin(17037) + Math.cos(17038) * 62;
+acc += Math.sin(17038) + Math.cos(17039) * 63;
+acc += Math.sin(17039) + Math.cos(17040) * 64;
+acc += Math.sin(17040) + Math.cos(17041) * 65;
+acc += Math.sin(17041) + Math.cos(17042) * 66;
+acc += Math.sin(17042) + Math.cos(17043) * 67;
+acc += Math.sin(17043) + Math.cos(17044) * 68;
+acc += Math.sin(17044) + Math.cos(17045) * 69;
+acc += Math.sin(17045) + Math.cos(17046) * 70;
+acc += Math.sin(17046) + Math.cos(17047) * 71;
+acc += Math.sin(17047) + Math.cos(17048) * 72;
+acc += Math.sin(17048) + Math.cos(17049) * 73;
+acc += Math.sin(17049) + Math.cos(17050) * 74;
+acc += Math.sin(17050) + Math.cos(17051) * 75;
+acc += Math.sin(17051) + Math.cos(17052) * 76;
+acc += Math.sin(17052) + Math.cos(17053) * 77;
+acc += Math.sin(17053) + Math.cos(17054) * 78;
+acc += Math.sin(17054) + Math.cos(17055) * 79;
+acc += Math.sin(17055) + Math.cos(17056) * 80;
+acc += Math.sin(17056) + Math.cos(17057) * 81;
+acc += Math.sin(17057) + Math.cos(17058) * 82;
+acc += Math.sin(17058) + Math.cos(17059) * 83;
+acc += Math.sin(17059) + Math.cos(17060) * 84;
+acc += Math.sin(17060) + Math.cos(17061) * 85;
+acc += Math.sin(17061) + Math.cos(17062) * 86;
+acc += Math.sin(17062) + Math.cos(17063) * 87;
+acc += Math.sin(17063) + Math.cos(17064) * 88;
+acc += Math.sin(17064) + Math.cos(17065) * 89;
+acc += Math.sin(17065) + Math.cos(17066) * 90;
+acc += Math.sin(17066) + Math.cos(17067) * 91;
+acc += Math.sin(17067) + Math.cos(17068) * 92;
+acc += Math.sin(17068) + Math.cos(17069) * 93;
+acc += Math.sin(17069) + Math.cos(17070) * 94;
+acc += Math.sin(17070) + Math.cos(17071) * 95;
+acc += Math.sin(17071) + Math.cos(17072) * 96;
+acc += Math.sin(17072) + Math.cos(17073) * 0;
+acc += Math.sin(17073) + Math.cos(17074) * 1;
+acc += Math.sin(17074) + Math.cos(17075) * 2;
+acc += Math.sin(17075) + Math.cos(17076) * 3;
+acc += Math.sin(17076) + Math.cos(17077) * 4;
+acc += Math.sin(17077) + Math.cos(17078) * 5;
+acc += Math.sin(17078) + Math.cos(17079) * 6;
+acc += Math.sin(17079) + Math.cos(17080) * 7;
+acc += Math.sin(17080) + Math.cos(17081) * 8;
+acc += Math.sin(17081) + Math.cos(17082) * 9;
+acc += Math.sin(17082) + Math.cos(17083) * 10;
+acc += Math.sin(17083) + Math.cos(17084) * 11;
+acc += Math.sin(17084) + Math.cos(17085) * 12;
+acc += Math.sin(17085) + Math.cos(17086) * 13;
+acc += Math.sin(17086) + Math.cos(17087) * 14;
+acc += Math.sin(17087) + Math.cos(17088) * 15;
+acc += Math.sin(17088) + Math.cos(17089) * 16;
+acc += Math.sin(17089) + Math.cos(17090) * 17;
+acc += Math.sin(17090) + Math.cos(17091) * 18;
+acc += Math.sin(17091) + Math.cos(17092) * 19;
+acc += Math.sin(17092) + Math.cos(17093) * 20;
+acc += Math.sin(17093) + Math.cos(17094) * 21;
+acc += Math.sin(17094) + Math.cos(17095) * 22;
+acc += Math.sin(17095) + Math.cos(17096) * 23;
+acc += Math.sin(17096) + Math.cos(17097) * 24;
+acc += Math.sin(17097) + Math.cos(17098) * 25;
+acc += Math.sin(17098) + Math.cos(17099) * 26;
+acc += Math.sin(17099) + Math.cos(17100) * 27;
+acc += Math.sin(17100) + Math.cos(17101) * 28;
+acc += Math.sin(17101) + Math.cos(17102) * 29;
+acc += Math.sin(17102) + Math.cos(17103) * 30;
+acc += Math.sin(17103) + Math.cos(17104) * 31;
+acc += Math.sin(17104) + Math.cos(17105) * 32;
+acc += Math.sin(17105) + Math.cos(17106) * 33;
+acc += Math.sin(17106) + Math.cos(17107) * 34;
+acc += Math.sin(17107) + Math.cos(17108) * 35;
+acc += Math.sin(17108) + Math.cos(17109) * 36;
+acc += Math.sin(17109) + Math.cos(17110) * 37;
+acc += Math.sin(17110) + Math.cos(17111) * 38;
+acc += Math.sin(17111) + Math.cos(17112) * 39;
+acc += Math.sin(17112) + Math.cos(17113) * 40;
+acc += Math.sin(17113) + Math.cos(17114) * 41;
+acc += Math.sin(17114) + Math.cos(17115) * 42;
+acc += Math.sin(17115) + Math.cos(17116) * 43;
+acc += Math.sin(17116) + Math.cos(17117) * 44;
+acc += Math.sin(17117) + Math.cos(17118) * 45;
+acc += Math.sin(17118) + Math.cos(17119) * 46;
+acc += Math.sin(17119) + Math.cos(17120) * 47;
+acc += Math.sin(17120) + Math.cos(17121) * 48;
+acc += Math.sin(17121) + Math.cos(17122) * 49;
+acc += Math.sin(17122) + Math.cos(17123) * 50;
+acc += Math.sin(17123) + Math.cos(17124) * 51;
+acc += Math.sin(17124) + Math.cos(17125) * 52;
+acc += Math.sin(17125) + Math.cos(17126) * 53;
+acc += Math.sin(17126) + Math.cos(17127) * 54;
+acc += Math.sin(17127) + Math.cos(17128) * 55;
+acc += Math.sin(17128) + Math.cos(17129) * 56;
+acc += Math.sin(17129) + Math.cos(17130) * 57;
+acc += Math.sin(17130) + Math.cos(17131) * 58;
+acc += Math.sin(17131) + Math.cos(17132) * 59;
+acc += Math.sin(17132) + Math.cos(17133) * 60;
+acc += Math.sin(17133) + Math.cos(17134) * 61;
+acc += Math.sin(17134) + Math.cos(17135) * 62;
+acc += Math.sin(17135) + Math.cos(17136) * 63;
+acc += Math.sin(17136) + Math.cos(17137) * 64;
+acc += Math.sin(17137) + Math.cos(17138) * 65;
+acc += Math.sin(17138) + Math.cos(17139) * 66;
+acc += Math.sin(17139) + Math.cos(17140) * 67;
+acc += Math.sin(17140) + Math.cos(17141) * 68;
+acc += Math.sin(17141) + Math.cos(17142) * 69;
+acc += Math.sin(17142) + Math.cos(17143) * 70;
+acc += Math.sin(17143) + Math.cos(17144) * 71;
+acc += Math.sin(17144) + Math.cos(17145) * 72;
+acc += Math.sin(17145) + Math.cos(17146) * 73;
+acc += Math.sin(17146) + Math.cos(17147) * 74;
+acc += Math.sin(17147) + Math.cos(17148) * 75;
+acc += Math.sin(17148) + Math.cos(17149) * 76;
+acc += Math.sin(17149) + Math.cos(17150) * 77;
+acc += Math.sin(17150) + Math.cos(17151) * 78;
+acc += Math.sin(17151) + Math.cos(17152) * 79;
+acc += Math.sin(17152) + Math.cos(17153) * 80;
+acc += Math.sin(17153) + Math.cos(17154) * 81;
+acc += Math.sin(17154) + Math.cos(17155) * 82;
+acc += Math.sin(17155) + Math.cos(17156) * 83;
+acc += Math.sin(17156) + Math.cos(17157) * 84;
+acc += Math.sin(17157) + Math.cos(17158) * 85;
+acc += Math.sin(17158) + Math.cos(17159) * 86;
+acc += Math.sin(17159) + Math.cos(17160) * 87;
+acc += Math.sin(17160) + Math.cos(17161) * 88;
+acc += Math.sin(17161) + Math.cos(17162) * 89;
+acc += Math.sin(17162) + Math.cos(17163) * 90;
+acc += Math.sin(17163) + Math.cos(17164) * 91;
+acc += Math.sin(17164) + Math.cos(17165) * 92;
+acc += Math.sin(17165) + Math.cos(17166) * 93;
+acc += Math.sin(17166) + Math.cos(17167) * 94;
+acc += Math.sin(17167) + Math.cos(17168) * 95;
+acc += Math.sin(17168) + Math.cos(17169) * 96;
+acc += Math.sin(17169) + Math.cos(17170) * 0;
+acc += Math.sin(17170) + Math.cos(17171) * 1;
+acc += Math.sin(17171) + Math.cos(17172) * 2;
+acc += Math.sin(17172) + Math.cos(17173) * 3;
+acc += Math.sin(17173) + Math.cos(17174) * 4;
+acc += Math.sin(17174) + Math.cos(17175) * 5;
+acc += Math.sin(17175) + Math.cos(17176) * 6;
+acc += Math.sin(17176) + Math.cos(17177) * 7;
+acc += Math.sin(17177) + Math.cos(17178) * 8;
+acc += Math.sin(17178) + Math.cos(17179) * 9;
+acc += Math.sin(17179) + Math.cos(17180) * 10;
+acc += Math.sin(17180) + Math.cos(17181) * 11;
+acc += Math.sin(17181) + Math.cos(17182) * 12;
+acc += Math.sin(17182) + Math.cos(17183) * 13;
+acc += Math.sin(17183) + Math.cos(17184) * 14;
+acc += Math.sin(17184) + Math.cos(17185) * 15;
+acc += Math.sin(17185) + Math.cos(17186) * 16;
+acc += Math.sin(17186) + Math.cos(17187) * 17;
+acc += Math.sin(17187) + Math.cos(17188) * 18;
+acc += Math.sin(17188) + Math.cos(17189) * 19;
+acc += Math.sin(17189) + Math.cos(17190) * 20;
+acc += Math.sin(17190) + Math.cos(17191) * 21;
+acc += Math.sin(17191) + Math.cos(17192) * 22;
+acc += Math.sin(17192) + Math.cos(17193) * 23;
+acc += Math.sin(17193) + Math.cos(17194) * 24;
+acc += Math.sin(17194) + Math.cos(17195) * 25;
+acc += Math.sin(17195) + Math.cos(17196) * 26;
+acc += Math.sin(17196) + Math.cos(17197) * 27;
+acc += Math.sin(17197) + Math.cos(17198) * 28;
+acc += Math.sin(17198) + Math.cos(17199) * 29;
+acc += Math.sin(17199) + Math.cos(17200) * 30;
+acc += Math.sin(17200) + Math.cos(17201) * 31;
+acc += Math.sin(17201) + Math.cos(17202) * 32;
+acc += Math.sin(17202) + Math.cos(17203) * 33;
+acc += Math.sin(17203) + Math.cos(17204) * 34;
+acc += Math.sin(17204) + Math.cos(17205) * 35;
+acc += Math.sin(17205) + Math.cos(17206) * 36;
+acc += Math.sin(17206) + Math.cos(17207) * 37;
+acc += Math.sin(17207) + Math.cos(17208) * 38;
+acc += Math.sin(17208) + Math.cos(17209) * 39;
+acc += Math.sin(17209) + Math.cos(17210) * 40;
+acc += Math.sin(17210) + Math.cos(17211) * 41;
+acc += Math.sin(17211) + Math.cos(17212) * 42;
+acc += Math.sin(17212) + Math.cos(17213) * 43;
+acc += Math.sin(17213) + Math.cos(17214) * 44;
+acc += Math.sin(17214) + Math.cos(17215) * 45;
+acc += Math.sin(17215) + Math.cos(17216) * 46;
+acc += Math.sin(17216) + Math.cos(17217) * 47;
+acc += Math.sin(17217) + Math.cos(17218) * 48;
+acc += Math.sin(17218) + Math.cos(17219) * 49;
+acc += Math.sin(17219) + Math.cos(17220) * 50;
+acc += Math.sin(17220) + Math.cos(17221) * 51;
+acc += Math.sin(17221) + Math.cos(17222) * 52;
+acc += Math.sin(17222) + Math.cos(17223) * 53;
+acc += Math.sin(17223) + Math.cos(17224) * 54;
+acc += Math.sin(17224) + Math.cos(17225) * 55;
+acc += Math.sin(17225) + Math.cos(17226) * 56;
+acc += Math.sin(17226) + Math.cos(17227) * 57;
+acc += Math.sin(17227) + Math.cos(17228) * 58;
+acc += Math.sin(17228) + Math.cos(17229) * 59;
+acc += Math.sin(17229) + Math.cos(17230) * 60;
+acc += Math.sin(17230) + Math.cos(17231) * 61;
+acc += Math.sin(17231) + Math.cos(17232) * 62;
+acc += Math.sin(17232) + Math.cos(17233) * 63;
+acc += Math.sin(17233) + Math.cos(17234) * 64;
+acc += Math.sin(17234) + Math.cos(17235) * 65;
+acc += Math.sin(17235) + Math.cos(17236) * 66;
+acc += Math.sin(17236) + Math.cos(17237) * 67;
+acc += Math.sin(17237) + Math.cos(17238) * 68;
+acc += Math.sin(17238) + Math.cos(17239) * 69;
+acc += Math.sin(17239) + Math.cos(17240) * 70;
+acc += Math.sin(17240) + Math.cos(17241) * 71;
+acc += Math.sin(17241) + Math.cos(17242) * 72;
+acc += Math.sin(17242) + Math.cos(17243) * 73;
+acc += Math.sin(17243) + Math.cos(17244) * 74;
+acc += Math.sin(17244) + Math.cos(17245) * 75;
+acc += Math.sin(17245) + Math.cos(17246) * 76;
+acc += Math.sin(17246) + Math.cos(17247) * 77;
+acc += Math.sin(17247) + Math.cos(17248) * 78;
+acc += Math.sin(17248) + Math.cos(17249) * 79;
+acc += Math.sin(17249) + Math.cos(17250) * 80;
+acc += Math.sin(17250) + Math.cos(17251) * 81;
+acc += Math.sin(17251) + Math.cos(17252) * 82;
+acc += Math.sin(17252) + Math.cos(17253) * 83;
+acc += Math.sin(17253) + Math.cos(17254) * 84;
+acc += Math.sin(17254) + Math.cos(17255) * 85;
+acc += Math.sin(17255) + Math.cos(17256) * 86;
+acc += Math.sin(17256) + Math.cos(17257) * 87;
+acc += Math.sin(17257) + Math.cos(17258) * 88;
+acc += Math.sin(17258) + Math.cos(17259) * 89;
+acc += Math.sin(17259) + Math.cos(17260) * 90;
+acc += Math.sin(17260) + Math.cos(17261) * 91;
+acc += Math.sin(17261) + Math.cos(17262) * 92;
+acc += Math.sin(17262) + Math.cos(17263) * 93;
+acc += Math.sin(17263) + Math.cos(17264) * 94;
+acc += Math.sin(17264) + Math.cos(17265) * 95;
+acc += Math.sin(17265) + Math.cos(17266) * 96;
+acc += Math.sin(17266) + Math.cos(17267) * 0;
+acc += Math.sin(17267) + Math.cos(17268) * 1;
+acc += Math.sin(17268) + Math.cos(17269) * 2;
+acc += Math.sin(17269) + Math.cos(17270) * 3;
+acc += Math.sin(17270) + Math.cos(17271) * 4;
+acc += Math.sin(17271) + Math.cos(17272) * 5;
+acc += Math.sin(17272) + Math.cos(17273) * 6;
+acc += Math.sin(17273) + Math.cos(17274) * 7;
+acc += Math.sin(17274) + Math.cos(17275) * 8;
+acc += Math.sin(17275) + Math.cos(17276) * 9;
+acc += Math.sin(17276) + Math.cos(17277) * 10;
+acc += Math.sin(17277) + Math.cos(17278) * 11;
+acc += Math.sin(17278) + Math.cos(17279) * 12;
+acc += Math.sin(17279) + Math.cos(17280) * 13;
+acc += Math.sin(17280) + Math.cos(17281) * 14;
+acc += Math.sin(17281) + Math.cos(17282) * 15;
+acc += Math.sin(17282) + Math.cos(17283) * 16;
+acc += Math.sin(17283) + Math.cos(17284) * 17;
+acc += Math.sin(17284) + Math.cos(17285) * 18;
+acc += Math.sin(17285) + Math.cos(17286) * 19;
+acc += Math.sin(17286) + Math.cos(17287) * 20;
+acc += Math.sin(17287) + Math.cos(17288) * 21;
+acc += Math.sin(17288) + Math.cos(17289) * 22;
+acc += Math.sin(17289) + Math.cos(17290) * 23;
+acc += Math.sin(17290) + Math.cos(17291) * 24;
+acc += Math.sin(17291) + Math.cos(17292) * 25;
+acc += Math.sin(17292) + Math.cos(17293) * 26;
+acc += Math.sin(17293) + Math.cos(17294) * 27;
+acc += Math.sin(17294) + Math.cos(17295) * 28;
+acc += Math.sin(17295) + Math.cos(17296) * 29;
+acc += Math.sin(17296) + Math.cos(17297) * 30;
+acc += Math.sin(17297) + Math.cos(17298) * 31;
+acc += Math.sin(17298) + Math.cos(17299) * 32;
+acc += Math.sin(17299) + Math.cos(17300) * 33;
+acc += Math.sin(17300) + Math.cos(17301) * 34;
+acc += Math.sin(17301) + Math.cos(17302) * 35;
+acc += Math.sin(17302) + Math.cos(17303) * 36;
+acc += Math.sin(17303) + Math.cos(17304) * 37;
+acc += Math.sin(17304) + Math.cos(17305) * 38;
+acc += Math.sin(17305) + Math.cos(17306) * 39;
+acc += Math.sin(17306) + Math.cos(17307) * 40;
+acc += Math.sin(17307) + Math.cos(17308) * 41;
+acc += Math.sin(17308) + Math.cos(17309) * 42;
+acc += Math.sin(17309) + Math.cos(17310) * 43;
+acc += Math.sin(17310) + Math.cos(17311) * 44;
+acc += Math.sin(17311) + Math.cos(17312) * 45;
+acc += Math.sin(17312) + Math.cos(17313) * 46;
+acc += Math.sin(17313) + Math.cos(17314) * 47;
+acc += Math.sin(17314) + Math.cos(17315) * 48;
+acc += Math.sin(17315) + Math.cos(17316) * 49;
+acc += Math.sin(17316) + Math.cos(17317) * 50;
+acc += Math.sin(17317) + Math.cos(17318) * 51;
+acc += Math.sin(17318) + Math.cos(17319) * 52;
+acc += Math.sin(17319) + Math.cos(17320) * 53;
+acc += Math.sin(17320) + Math.cos(17321) * 54;
+acc += Math.sin(17321) + Math.cos(17322) * 55;
+acc += Math.sin(17322) + Math.cos(17323) * 56;
+acc += Math.sin(17323) + Math.cos(17324) * 57;
+acc += Math.sin(17324) + Math.cos(17325) * 58;
+acc += Math.sin(17325) + Math.cos(17326) * 59;
+acc += Math.sin(17326) + Math.cos(17327) * 60;
+acc += Math.sin(17327) + Math.cos(17328) * 61;
+acc += Math.sin(17328) + Math.cos(17329) * 62;
+acc += Math.sin(17329) + Math.cos(17330) * 63;
+acc += Math.sin(17330) + Math.cos(17331) * 64;
+acc += Math.sin(17331) + Math.cos(17332) * 65;
+acc += Math.sin(17332) + Math.cos(17333) * 66;
+acc += Math.sin(17333) + Math.cos(17334) * 67;
+acc += Math.sin(17334) + Math.cos(17335) * 68;
+acc += Math.sin(17335) + Math.cos(17336) * 69;
+acc += Math.sin(17336) + Math.cos(17337) * 70;
+acc += Math.sin(17337) + Math.cos(17338) * 71;
+acc += Math.sin(17338) + Math.cos(17339) * 72;
+acc += Math.sin(17339) + Math.cos(17340) * 73;
+acc += Math.sin(17340) + Math.cos(17341) * 74;
+acc += Math.sin(17341) + Math.cos(17342) * 75;
+acc += Math.sin(17342) + Math.cos(17343) * 76;
+acc += Math.sin(17343) + Math.cos(17344) * 77;
+acc += Math.sin(17344) + Math.cos(17345) * 78;
+acc += Math.sin(17345) + Math.cos(17346) * 79;
+acc += Math.sin(17346) + Math.cos(17347) * 80;
+acc += Math.sin(17347) + Math.cos(17348) * 81;
+acc += Math.sin(17348) + Math.cos(17349) * 82;
+acc += Math.sin(17349) + Math.cos(17350) * 83;
+acc += Math.sin(17350) + Math.cos(17351) * 84;
+acc += Math.sin(17351) + Math.cos(17352) * 85;
+acc += Math.sin(17352) + Math.cos(17353) * 86;
+acc += Math.sin(17353) + Math.cos(17354) * 87;
+acc += Math.sin(17354) + Math.cos(17355) * 88;
+acc += Math.sin(17355) + Math.cos(17356) * 89;
+acc += Math.sin(17356) + Math.cos(17357) * 90;
+acc += Math.sin(17357) + Math.cos(17358) * 91;
+acc += Math.sin(17358) + Math.cos(17359) * 92;
+acc += Math.sin(17359) + Math.cos(17360) * 93;
+acc += Math.sin(17360) + Math.cos(17361) * 94;
+acc += Math.sin(17361) + Math.cos(17362) * 95;
+acc += Math.sin(17362) + Math.cos(17363) * 96;
+acc += Math.sin(17363) + Math.cos(17364) * 0;
+acc += Math.sin(17364) + Math.cos(17365) * 1;
+acc += Math.sin(17365) + Math.cos(17366) * 2;
+acc += Math.sin(17366) + Math.cos(17367) * 3;
+acc += Math.sin(17367) + Math.cos(17368) * 4;
+acc += Math.sin(17368) + Math.cos(17369) * 5;
+acc += Math.sin(17369) + Math.cos(17370) * 6;
+acc += Math.sin(17370) + Math.cos(17371) * 7;
+acc += Math.sin(17371) + Math.cos(17372) * 8;
+acc += Math.sin(17372) + Math.cos(17373) * 9;
+acc += Math.sin(17373) + Math.cos(17374) * 10;
+acc += Math.sin(17374) + Math.cos(17375) * 11;
+acc += Math.sin(17375) + Math.cos(17376) * 12;
+acc += Math.sin(17376) + Math.cos(17377) * 13;
+acc += Math.sin(17377) + Math.cos(17378) * 14;
+acc += Math.sin(17378) + Math.cos(17379) * 15;
+acc += Math.sin(17379) + Math.cos(17380) * 16;
+acc += Math.sin(17380) + Math.cos(17381) * 17;
+acc += Math.sin(17381) + Math.cos(17382) * 18;
+acc += Math.sin(17382) + Math.cos(17383) * 19;
+acc += Math.sin(17383) + Math.cos(17384) * 20;
+acc += Math.sin(17384) + Math.cos(17385) * 21;
+acc += Math.sin(17385) + Math.cos(17386) * 22;
+acc += Math.sin(17386) + Math.cos(17387) * 23;
+acc += Math.sin(17387) + Math.cos(17388) * 24;
+acc += Math.sin(17388) + Math.cos(17389) * 25;
+acc += Math.sin(17389) + Math.cos(17390) * 26;
+acc += Math.sin(17390) + Math.cos(17391) * 27;
+acc += Math.sin(17391) + Math.cos(17392) * 28;
+acc += Math.sin(17392) + Math.cos(17393) * 29;
+acc += Math.sin(17393) + Math.cos(17394) * 30;
+acc += Math.sin(17394) + Math.cos(17395) * 31;
+acc += Math.sin(17395) + Math.cos(17396) * 32;
+acc += Math.sin(17396) + Math.cos(17397) * 33;
+acc += Math.sin(17397) + Math.cos(17398) * 34;
+acc += Math.sin(17398) + Math.cos(17399) * 35;
+acc += Math.sin(17399) + Math.cos(17400) * 36;
+acc += Math.sin(17400) + Math.cos(17401) * 37;
+acc += Math.sin(17401) + Math.cos(17402) * 38;
+acc += Math.sin(17402) + Math.cos(17403) * 39;
+acc += Math.sin(17403) + Math.cos(17404) * 40;
+acc += Math.sin(17404) + Math.cos(17405) * 41;
+acc += Math.sin(17405) + Math.cos(17406) * 42;
+acc += Math.sin(17406) + Math.cos(17407) * 43;
+acc += Math.sin(17407) + Math.cos(17408) * 44;
+acc += Math.sin(17408) + Math.cos(17409) * 45;
+acc += Math.sin(17409) + Math.cos(17410) * 46;
+acc += Math.sin(17410) + Math.cos(17411) * 47;
+acc += Math.sin(17411) + Math.cos(17412) * 48;
+acc += Math.sin(17412) + Math.cos(17413) * 49;
+acc += Math.sin(17413) + Math.cos(17414) * 50;
+acc += Math.sin(17414) + Math.cos(17415) * 51;
+acc += Math.sin(17415) + Math.cos(17416) * 52;
+acc += Math.sin(17416) + Math.cos(17417) * 53;
+acc += Math.sin(17417) + Math.cos(17418) * 54;
+acc += Math.sin(17418) + Math.cos(17419) * 55;
+acc += Math.sin(17419) + Math.cos(17420) * 56;
+acc += Math.sin(17420) + Math.cos(17421) * 57;
+acc += Math.sin(17421) + Math.cos(17422) * 58;
+acc += Math.sin(17422) + Math.cos(17423) * 59;
+acc += Math.sin(17423) + Math.cos(17424) * 60;
+acc += Math.sin(17424) + Math.cos(17425) * 61;
+acc += Math.sin(17425) + Math.cos(17426) * 62;
+acc += Math.sin(17426) + Math.cos(17427) * 63;
+acc += Math.sin(17427) + Math.cos(17428) * 64;
+acc += Math.sin(17428) + Math.cos(17429) * 65;
+acc += Math.sin(17429) + Math.cos(17430) * 66;
+acc += Math.sin(17430) + Math.cos(17431) * 67;
+acc += Math.sin(17431) + Math.cos(17432) * 68;
+acc += Math.sin(17432) + Math.cos(17433) * 69;
+acc += Math.sin(17433) + Math.cos(17434) * 70;
+acc += Math.sin(17434) + Math.cos(17435) * 71;
+acc += Math.sin(17435) + Math.cos(17436) * 72;
+acc += Math.sin(17436) + Math.cos(17437) * 73;
+acc += Math.sin(17437) + Math.cos(17438) * 74;
+acc += Math.sin(17438) + Math.cos(17439) * 75;
+acc += Math.sin(17439) + Math.cos(17440) * 76;
+acc += Math.sin(17440) + Math.cos(17441) * 77;
+acc += Math.sin(17441) + Math.cos(17442) * 78;
+acc += Math.sin(17442) + Math.cos(17443) * 79;
+acc += Math.sin(17443) + Math.cos(17444) * 80;
+acc += Math.sin(17444) + Math.cos(17445) * 81;
+acc += Math.sin(17445) + Math.cos(17446) * 82;
+acc += Math.sin(17446) + Math.cos(17447) * 83;
+acc += Math.sin(17447) + Math.cos(17448) * 84;
+acc += Math.sin(17448) + Math.cos(17449) * 85;
+acc += Math.sin(17449) + Math.cos(17450) * 86;
+acc += Math.sin(17450) + Math.cos(17451) * 87;
+acc += Math.sin(17451) + Math.cos(17452) * 88;
+acc += Math.sin(17452) + Math.cos(17453) * 89;
+acc += Math.sin(17453) + Math.cos(17454) * 90;
+acc += Math.sin(17454) + Math.cos(17455) * 91;
+acc += Math.sin(17455) + Math.cos(17456) * 92;
+acc += Math.sin(17456) + Math.cos(17457) * 93;
+acc += Math.sin(17457) + Math.cos(17458) * 94;
+acc += Math.sin(17458) + Math.cos(17459) * 95;
+acc += Math.sin(17459) + Math.cos(17460) * 96;
+acc += Math.sin(17460) + Math.cos(17461) * 0;
+acc += Math.sin(17461) + Math.cos(17462) * 1;
+acc += Math.sin(17462) + Math.cos(17463) * 2;
+acc += Math.sin(17463) + Math.cos(17464) * 3;
+acc += Math.sin(17464) + Math.cos(17465) * 4;
+acc += Math.sin(17465) + Math.cos(17466) * 5;
+acc += Math.sin(17466) + Math.cos(17467) * 6;
+acc += Math.sin(17467) + Math.cos(17468) * 7;
+acc += Math.sin(17468) + Math.cos(17469) * 8;
+acc += Math.sin(17469) + Math.cos(17470) * 9;
+acc += Math.sin(17470) + Math.cos(17471) * 10;
+acc += Math.sin(17471) + Math.cos(17472) * 11;
+acc += Math.sin(17472) + Math.cos(17473) * 12;
+acc += Math.sin(17473) + Math.cos(17474) * 13;
+acc += Math.sin(17474) + Math.cos(17475) * 14;
+acc += Math.sin(17475) + Math.cos(17476) * 15;
+acc += Math.sin(17476) + Math.cos(17477) * 16;
+acc += Math.sin(17477) + Math.cos(17478) * 17;
+acc += Math.sin(17478) + Math.cos(17479) * 18;
+acc += Math.sin(17479) + Math.cos(17480) * 19;
+acc += Math.sin(17480) + Math.cos(17481) * 20;
+acc += Math.sin(17481) + Math.cos(17482) * 21;
+acc += Math.sin(17482) + Math.cos(17483) * 22;
+acc += Math.sin(17483) + Math.cos(17484) * 23;
+acc += Math.sin(17484) + Math.cos(17485) * 24;
+acc += Math.sin(17485) + Math.cos(17486) * 25;
+acc += Math.sin(17486) + Math.cos(17487) * 26;
+acc += Math.sin(17487) + Math.cos(17488) * 27;
+acc += Math.sin(17488) + Math.cos(17489) * 28;
+acc += Math.sin(17489) + Math.cos(17490) * 29;
+acc += Math.sin(17490) + Math.cos(17491) * 30;
+acc += Math.sin(17491) + Math.cos(17492) * 31;
+acc += Math.sin(17492) + Math.cos(17493) * 32;
+acc += Math.sin(17493) + Math.cos(17494) * 33;
+acc += Math.sin(17494) + Math.cos(17495) * 34;
+acc += Math.sin(17495) + Math.cos(17496) * 35;
+acc += Math.sin(17496) + Math.cos(17497) * 36;
+acc += Math.sin(17497) + Math.cos(17498) * 37;
+acc += Math.sin(17498) + Math.cos(17499) * 38;
+acc += Math.sin(17499) + Math.cos(17500) * 39;
+acc += Math.sin(17500) + Math.cos(17501) * 40;
+acc += Math.sin(17501) + Math.cos(17502) * 41;
+acc += Math.sin(17502) + Math.cos(17503) * 42;
+acc += Math.sin(17503) + Math.cos(17504) * 43;
+acc += Math.sin(17504) + Math.cos(17505) * 44;
+acc += Math.sin(17505) + Math.cos(17506) * 45;
+acc += Math.sin(17506) + Math.cos(17507) * 46;
+acc += Math.sin(17507) + Math.cos(17508) * 47;
+acc += Math.sin(17508) + Math.cos(17509) * 48;
+acc += Math.sin(17509) + Math.cos(17510) * 49;
+acc += Math.sin(17510) + Math.cos(17511) * 50;
+acc += Math.sin(17511) + Math.cos(17512) * 51;
+acc += Math.sin(17512) + Math.cos(17513) * 52;
+acc += Math.sin(17513) + Math.cos(17514) * 53;
+acc += Math.sin(17514) + Math.cos(17515) * 54;
+acc += Math.sin(17515) + Math.cos(17516) * 55;
+acc += Math.sin(17516) + Math.cos(17517) * 56;
+acc += Math.sin(17517) + Math.cos(17518) * 57;
+acc += Math.sin(17518) + Math.cos(17519) * 58;
+acc += Math.sin(17519) + Math.cos(17520) * 59;
+acc += Math.sin(17520) + Math.cos(17521) * 60;
+acc += Math.sin(17521) + Math.cos(17522) * 61;
+acc += Math.sin(17522) + Math.cos(17523) * 62;
+acc += Math.sin(17523) + Math.cos(17524) * 63;
+acc += Math.sin(17524) + Math.cos(17525) * 64;
+acc += Math.sin(17525) + Math.cos(17526) * 65;
+acc += Math.sin(17526) + Math.cos(17527) * 66;
+acc += Math.sin(17527) + Math.cos(17528) * 67;
+acc += Math.sin(17528) + Math.cos(17529) * 68;
+acc += Math.sin(17529) + Math.cos(17530) * 69;
+acc += Math.sin(17530) + Math.cos(17531) * 70;
+acc += Math.sin(17531) + Math.cos(17532) * 71;
+acc += Math.sin(17532) + Math.cos(17533) * 72;
+acc += Math.sin(17533) + Math.cos(17534) * 73;
+acc += Math.sin(17534) + Math.cos(17535) * 74;
+acc += Math.sin(17535) + Math.cos(17536) * 75;
+acc += Math.sin(17536) + Math.cos(17537) * 76;
+acc += Math.sin(17537) + Math.cos(17538) * 77;
+acc += Math.sin(17538) + Math.cos(17539) * 78;
+acc += Math.sin(17539) + Math.cos(17540) * 79;
+acc += Math.sin(17540) + Math.cos(17541) * 80;
+acc += Math.sin(17541) + Math.cos(17542) * 81;
+acc += Math.sin(17542) + Math.cos(17543) * 82;
+acc += Math.sin(17543) + Math.cos(17544) * 83;
+acc += Math.sin(17544) + Math.cos(17545) * 84;
+acc += Math.sin(17545) + Math.cos(17546) * 85;
+acc += Math.sin(17546) + Math.cos(17547) * 86;
+acc += Math.sin(17547) + Math.cos(17548) * 87;
+acc += Math.sin(17548) + Math.cos(17549) * 88;
+acc += Math.sin(17549) + Math.cos(17550) * 89;
+acc += Math.sin(17550) + Math.cos(17551) * 90;
+acc += Math.sin(17551) + Math.cos(17552) * 91;
+acc += Math.sin(17552) + Math.cos(17553) * 92;
+acc += Math.sin(17553) + Math.cos(17554) * 93;
+acc += Math.sin(17554) + Math.cos(17555) * 94;
+acc += Math.sin(17555) + Math.cos(17556) * 95;
+acc += Math.sin(17556) + Math.cos(17557) * 96;
+acc += Math.sin(17557) + Math.cos(17558) * 0;
+acc += Math.sin(17558) + Math.cos(17559) * 1;
+acc += Math.sin(17559) + Math.cos(17560) * 2;
+acc += Math.sin(17560) + Math.cos(17561) * 3;
+acc += Math.sin(17561) + Math.cos(17562) * 4;
+acc += Math.sin(17562) + Math.cos(17563) * 5;
+acc += Math.sin(17563) + Math.cos(17564) * 6;
+acc += Math.sin(17564) + Math.cos(17565) * 7;
+acc += Math.sin(17565) + Math.cos(17566) * 8;
+acc += Math.sin(17566) + Math.cos(17567) * 9;
+acc += Math.sin(17567) + Math.cos(17568) * 10;
+acc += Math.sin(17568) + Math.cos(17569) * 11;
+acc += Math.sin(17569) + Math.cos(17570) * 12;
+acc += Math.sin(17570) + Math.cos(17571) * 13;
+acc += Math.sin(17571) + Math.cos(17572) * 14;
+acc += Math.sin(17572) + Math.cos(17573) * 15;
+acc += Math.sin(17573) + Math.cos(17574) * 16;
+acc += Math.sin(17574) + Math.cos(17575) * 17;
+acc += Math.sin(17575) + Math.cos(17576) * 18;
+acc += Math.sin(17576) + Math.cos(17577) * 19;
+acc += Math.sin(17577) + Math.cos(17578) * 20;
+acc += Math.sin(17578) + Math.cos(17579) * 21;
+acc += Math.sin(17579) + Math.cos(17580) * 22;
+acc += Math.sin(17580) + Math.cos(17581) * 23;
+acc += Math.sin(17581) + Math.cos(17582) * 24;
+acc += Math.sin(17582) + Math.cos(17583) * 25;
+acc += Math.sin(17583) + Math.cos(17584) * 26;
+acc += Math.sin(17584) + Math.cos(17585) * 27;
+acc += Math.sin(17585) + Math.cos(17586) * 28;
+acc += Math.sin(17586) + Math.cos(17587) * 29;
+acc += Math.sin(17587) + Math.cos(17588) * 30;
+acc += Math.sin(17588) + Math.cos(17589) * 31;
+acc += Math.sin(17589) + Math.cos(17590) * 32;
+acc += Math.sin(17590) + Math.cos(17591) * 33;
+acc += Math.sin(17591) + Math.cos(17592) * 34;
+acc += Math.sin(17592) + Math.cos(17593) * 35;
+acc += Math.sin(17593) + Math.cos(17594) * 36;
+acc += Math.sin(17594) + Math.cos(17595) * 37;
+acc += Math.sin(17595) + Math.cos(17596) * 38;
+acc += Math.sin(17596) + Math.cos(17597) * 39;
+acc += Math.sin(17597) + Math.cos(17598) * 40;
+acc += Math.sin(17598) + Math.cos(17599) * 41;
+acc += Math.sin(17599) + Math.cos(17600) * 42;
+acc += Math.sin(17600) + Math.cos(17601) * 43;
+acc += Math.sin(17601) + Math.cos(17602) * 44;
+acc += Math.sin(17602) + Math.cos(17603) * 45;
+acc += Math.sin(17603) + Math.cos(17604) * 46;
+acc += Math.sin(17604) + Math.cos(17605) * 47;
+acc += Math.sin(17605) + Math.cos(17606) * 48;
+acc += Math.sin(17606) + Math.cos(17607) * 49;
+acc += Math.sin(17607) + Math.cos(17608) * 50;
+acc += Math.sin(17608) + Math.cos(17609) * 51;
+acc += Math.sin(17609) + Math.cos(17610) * 52;
+acc += Math.sin(17610) + Math.cos(17611) * 53;
+acc += Math.sin(17611) + Math.cos(17612) * 54;
+acc += Math.sin(17612) + Math.cos(17613) * 55;
+acc += Math.sin(17613) + Math.cos(17614) * 56;
+acc += Math.sin(17614) + Math.cos(17615) * 57;
+acc += Math.sin(17615) + Math.cos(17616) * 58;
+acc += Math.sin(17616) + Math.cos(17617) * 59;
+acc += Math.sin(17617) + Math.cos(17618) * 60;
+acc += Math.sin(17618) + Math.cos(17619) * 61;
+acc += Math.sin(17619) + Math.cos(17620) * 62;
+acc += Math.sin(17620) + Math.cos(17621) * 63;
+acc += Math.sin(17621) + Math.cos(17622) * 64;
+acc += Math.sin(17622) + Math.cos(17623) * 65;
+acc += Math.sin(17623) + Math.cos(17624) * 66;
+acc += Math.sin(17624) + Math.cos(17625) * 67;
+acc += Math.sin(17625) + Math.cos(17626) * 68;
+acc += Math.sin(17626) + Math.cos(17627) * 69;
+acc += Math.sin(17627) + Math.cos(17628) * 70;
+acc += Math.sin(17628) + Math.cos(17629) * 71;
+acc += Math.sin(17629) + Math.cos(17630) * 72;
+acc += Math.sin(17630) + Math.cos(17631) * 73;
+acc += Math.sin(17631) + Math.cos(17632) * 74;
+acc += Math.sin(17632) + Math.cos(17633) * 75;
+acc += Math.sin(17633) + Math.cos(17634) * 76;
+acc += Math.sin(17634) + Math.cos(17635) * 77;
+acc += Math.sin(17635) + Math.cos(17636) * 78;
+acc += Math.sin(17636) + Math.cos(17637) * 79;
+acc += Math.sin(17637) + Math.cos(17638) * 80;
+acc += Math.sin(17638) + Math.cos(17639) * 81;
+acc += Math.sin(17639) + Math.cos(17640) * 82;
+acc += Math.sin(17640) + Math.cos(17641) * 83;
+acc += Math.sin(17641) + Math.cos(17642) * 84;
+acc += Math.sin(17642) + Math.cos(17643) * 85;
+acc += Math.sin(17643) + Math.cos(17644) * 86;
+acc += Math.sin(17644) + Math.cos(17645) * 87;
+acc += Math.sin(17645) + Math.cos(17646) * 88;
+acc += Math.sin(17646) + Math.cos(17647) * 89;
+acc += Math.sin(17647) + Math.cos(17648) * 90;
+acc += Math.sin(17648) + Math.cos(17649) * 91;
+acc += Math.sin(17649) + Math.cos(17650) * 92;
+acc += Math.sin(17650) + Math.cos(17651) * 93;
+acc += Math.sin(17651) + Math.cos(17652) * 94;
+acc += Math.sin(17652) + Math.cos(17653) * 95;
+acc += Math.sin(17653) + Math.cos(17654) * 96;
+acc += Math.sin(17654) + Math.cos(17655) * 0;
+acc += Math.sin(17655) + Math.cos(17656) * 1;
+acc += Math.sin(17656) + Math.cos(17657) * 2;
+acc += Math.sin(17657) + Math.cos(17658) * 3;
+acc += Math.sin(17658) + Math.cos(17659) * 4;
+acc += Math.sin(17659) + Math.cos(17660) * 5;
+acc += Math.sin(17660) + Math.cos(17661) * 6;
+acc += Math.sin(17661) + Math.cos(17662) * 7;
+acc += Math.sin(17662) + Math.cos(17663) * 8;
+acc += Math.sin(17663) + Math.cos(17664) * 9;
+acc += Math.sin(17664) + Math.cos(17665) * 10;
+acc += Math.sin(17665) + Math.cos(17666) * 11;
+acc += Math.sin(17666) + Math.cos(17667) * 12;
+acc += Math.sin(17667) + Math.cos(17668) * 13;
+acc += Math.sin(17668) + Math.cos(17669) * 14;
+acc += Math.sin(17669) + Math.cos(17670) * 15;
+acc += Math.sin(17670) + Math.cos(17671) * 16;
+acc += Math.sin(17671) + Math.cos(17672) * 17;
+acc += Math.sin(17672) + Math.cos(17673) * 18;
+acc += Math.sin(17673) + Math.cos(17674) * 19;
+acc += Math.sin(17674) + Math.cos(17675) * 20;
+acc += Math.sin(17675) + Math.cos(17676) * 21;
+acc += Math.sin(17676) + Math.cos(17677) * 22;
+acc += Math.sin(17677) + Math.cos(17678) * 23;
+acc += Math.sin(17678) + Math.cos(17679) * 24;
+acc += Math.sin(17679) + Math.cos(17680) * 25;
+acc += Math.sin(17680) + Math.cos(17681) * 26;
+acc += Math.sin(17681) + Math.cos(17682) * 27;
+acc += Math.sin(17682) + Math.cos(17683) * 28;
+acc += Math.sin(17683) + Math.cos(17684) * 29;
+acc += Math.sin(17684) + Math.cos(17685) * 30;
+acc += Math.sin(17685) + Math.cos(17686) * 31;
+acc += Math.sin(17686) + Math.cos(17687) * 32;
+acc += Math.sin(17687) + Math.cos(17688) * 33;
+acc += Math.sin(17688) + Math.cos(17689) * 34;
+acc += Math.sin(17689) + Math.cos(17690) * 35;
+acc += Math.sin(17690) + Math.cos(17691) * 36;
+acc += Math.sin(17691) + Math.cos(17692) * 37;
+acc += Math.sin(17692) + Math.cos(17693) * 38;
+acc += Math.sin(17693) + Math.cos(17694) * 39;
+acc += Math.sin(17694) + Math.cos(17695) * 40;
+acc += Math.sin(17695) + Math.cos(17696) * 41;
+acc += Math.sin(17696) + Math.cos(17697) * 42;
+acc += Math.sin(17697) + Math.cos(17698) * 43;
+acc += Math.sin(17698) + Math.cos(17699) * 44;
+acc += Math.sin(17699) + Math.cos(17700) * 45;
+acc += Math.sin(17700) + Math.cos(17701) * 46;
+acc += Math.sin(17701) + Math.cos(17702) * 47;
+acc += Math.sin(17702) + Math.cos(17703) * 48;
+acc += Math.sin(17703) + Math.cos(17704) * 49;
+acc += Math.sin(17704) + Math.cos(17705) * 50;
+acc += Math.sin(17705) + Math.cos(17706) * 51;
+acc += Math.sin(17706) + Math.cos(17707) * 52;
+acc += Math.sin(17707) + Math.cos(17708) * 53;
+acc += Math.sin(17708) + Math.cos(17709) * 54;
+acc += Math.sin(17709) + Math.cos(17710) * 55;
+acc += Math.sin(17710) + Math.cos(17711) * 56;
+acc += Math.sin(17711) + Math.cos(17712) * 57;
+acc += Math.sin(17712) + Math.cos(17713) * 58;
+acc += Math.sin(17713) + Math.cos(17714) * 59;
+acc += Math.sin(17714) + Math.cos(17715) * 60;
+acc += Math.sin(17715) + Math.cos(17716) * 61;
+acc += Math.sin(17716) + Math.cos(17717) * 62;
+acc += Math.sin(17717) + Math.cos(17718) * 63;
+acc += Math.sin(17718) + Math.cos(17719) * 64;
+acc += Math.sin(17719) + Math.cos(17720) * 65;
+acc += Math.sin(17720) + Math.cos(17721) * 66;
+acc += Math.sin(17721) + Math.cos(17722) * 67;
+acc += Math.sin(17722) + Math.cos(17723) * 68;
+acc += Math.sin(17723) + Math.cos(17724) * 69;
+acc += Math.sin(17724) + Math.cos(17725) * 70;
+acc += Math.sin(17725) + Math.cos(17726) * 71;
+acc += Math.sin(17726) + Math.cos(17727) * 72;
+acc += Math.sin(17727) + Math.cos(17728) * 73;
+acc += Math.sin(17728) + Math.cos(17729) * 74;
+acc += Math.sin(17729) + Math.cos(17730) * 75;
+acc += Math.sin(17730) + Math.cos(17731) * 76;
+acc += Math.sin(17731) + Math.cos(17732) * 77;
+acc += Math.sin(17732) + Math.cos(17733) * 78;
+acc += Math.sin(17733) + Math.cos(17734) * 79;
+acc += Math.sin(17734) + Math.cos(17735) * 80;
+acc += Math.sin(17735) + Math.cos(17736) * 81;
+acc += Math.sin(17736) + Math.cos(17737) * 82;
+acc += Math.sin(17737) + Math.cos(17738) * 83;
+acc += Math.sin(17738) + Math.cos(17739) * 84;
+acc += Math.sin(17739) + Math.cos(17740) * 85;
+acc += Math.sin(17740) + Math.cos(17741) * 86;
+acc += Math.sin(17741) + Math.cos(17742) * 87;
+acc += Math.sin(17742) + Math.cos(17743) * 88;
+acc += Math.sin(17743) + Math.cos(17744) * 89;
+acc += Math.sin(17744) + Math.cos(17745) * 90;
+acc += Math.sin(17745) + Math.cos(17746) * 91;
+acc += Math.sin(17746) + Math.cos(17747) * 92;
+acc += Math.sin(17747) + Math.cos(17748) * 93;
+acc += Math.sin(17748) + Math.cos(17749) * 94;
+acc += Math.sin(17749) + Math.cos(17750) * 95;
+acc += Math.sin(17750) + Math.cos(17751) * 96;
+acc += Math.sin(17751) + Math.cos(17752) * 0;
+acc += Math.sin(17752) + Math.cos(17753) * 1;
+acc += Math.sin(17753) + Math.cos(17754) * 2;
+acc += Math.sin(17754) + Math.cos(17755) * 3;
+acc += Math.sin(17755) + Math.cos(17756) * 4;
+acc += Math.sin(17756) + Math.cos(17757) * 5;
+acc += Math.sin(17757) + Math.cos(17758) * 6;
+acc += Math.sin(17758) + Math.cos(17759) * 7;
+acc += Math.sin(17759) + Math.cos(17760) * 8;
+acc += Math.sin(17760) + Math.cos(17761) * 9;
+acc += Math.sin(17761) + Math.cos(17762) * 10;
+acc += Math.sin(17762) + Math.cos(17763) * 11;
+acc += Math.sin(17763) + Math.cos(17764) * 12;
+acc += Math.sin(17764) + Math.cos(17765) * 13;
+acc += Math.sin(17765) + Math.cos(17766) * 14;
+acc += Math.sin(17766) + Math.cos(17767) * 15;
+acc += Math.sin(17767) + Math.cos(17768) * 16;
+acc += Math.sin(17768) + Math.cos(17769) * 17;
+acc += Math.sin(17769) + Math.cos(17770) * 18;
+acc += Math.sin(17770) + Math.cos(17771) * 19;
+acc += Math.sin(17771) + Math.cos(17772) * 20;
+acc += Math.sin(17772) + Math.cos(17773) * 21;
+acc += Math.sin(17773) + Math.cos(17774) * 22;
+acc += Math.sin(17774) + Math.cos(17775) * 23;
+acc += Math.sin(17775) + Math.cos(17776) * 24;
+acc += Math.sin(17776) + Math.cos(17777) * 25;
+acc += Math.sin(17777) + Math.cos(17778) * 26;
+acc += Math.sin(17778) + Math.cos(17779) * 27;
+acc += Math.sin(17779) + Math.cos(17780) * 28;
+acc += Math.sin(17780) + Math.cos(17781) * 29;
+acc += Math.sin(17781) + Math.cos(17782) * 30;
+acc += Math.sin(17782) + Math.cos(17783) * 31;
+acc += Math.sin(17783) + Math.cos(17784) * 32;
+acc += Math.sin(17784) + Math.cos(17785) * 33;
+acc += Math.sin(17785) + Math.cos(17786) * 34;
+acc += Math.sin(17786) + Math.cos(17787) * 35;
+acc += Math.sin(17787) + Math.cos(17788) * 36;
+acc += Math.sin(17788) + Math.cos(17789) * 37;
+acc += Math.sin(17789) + Math.cos(17790) * 38;
+acc += Math.sin(17790) + Math.cos(17791) * 39;
+acc += Math.sin(17791) + Math.cos(17792) * 40;
+acc += Math.sin(17792) + Math.cos(17793) * 41;
+acc += Math.sin(17793) + Math.cos(17794) * 42;
+acc += Math.sin(17794) + Math.cos(17795) * 43;
+acc += Math.sin(17795) + Math.cos(17796) * 44;
+acc += Math.sin(17796) + Math.cos(17797) * 45;
+acc += Math.sin(17797) + Math.cos(17798) * 46;
+acc += Math.sin(17798) + Math.cos(17799) * 47;
+acc += Math.sin(17799) + Math.cos(17800) * 48;
+acc += Math.sin(17800) + Math.cos(17801) * 49;
+acc += Math.sin(17801) + Math.cos(17802) * 50;
+acc += Math.sin(17802) + Math.cos(17803) * 51;
+acc += Math.sin(17803) + Math.cos(17804) * 52;
+acc += Math.sin(17804) + Math.cos(17805) * 53;
+acc += Math.sin(17805) + Math.cos(17806) * 54;
+acc += Math.sin(17806) + Math.cos(17807) * 55;
+acc += Math.sin(17807) + Math.cos(17808) * 56;
+acc += Math.sin(17808) + Math.cos(17809) * 57;
+acc += Math.sin(17809) + Math.cos(17810) * 58;
+acc += Math.sin(17810) + Math.cos(17811) * 59;
+acc += Math.sin(17811) + Math.cos(17812) * 60;
+acc += Math.sin(17812) + Math.cos(17813) * 61;
+acc += Math.sin(17813) + Math.cos(17814) * 62;
+acc += Math.sin(17814) + Math.cos(17815) * 63;
+acc += Math.sin(17815) + Math.cos(17816) * 64;
+acc += Math.sin(17816) + Math.cos(17817) * 65;
+acc += Math.sin(17817) + Math.cos(17818) * 66;
+acc += Math.sin(17818) + Math.cos(17819) * 67;
+acc += Math.sin(17819) + Math.cos(17820) * 68;
+acc += Math.sin(17820) + Math.cos(17821) * 69;
+acc += Math.sin(17821) + Math.cos(17822) * 70;
+acc += Math.sin(17822) + Math.cos(17823) * 71;
+acc += Math.sin(17823) + Math.cos(17824) * 72;
+acc += Math.sin(17824) + Math.cos(17825) * 73;
+acc += Math.sin(17825) + Math.cos(17826) * 74;
+acc += Math.sin(17826) + Math.cos(17827) * 75;
+acc += Math.sin(17827) + Math.cos(17828) * 76;
+acc += Math.sin(17828) + Math.cos(17829) * 77;
+acc += Math.sin(17829) + Math.cos(17830) * 78;
+acc += Math.sin(17830) + Math.cos(17831) * 79;
+acc += Math.sin(17831) + Math.cos(17832) * 80;
+acc += Math.sin(17832) + Math.cos(17833) * 81;
+acc += Math.sin(17833) + Math.cos(17834) * 82;
+acc += Math.sin(17834) + Math.cos(17835) * 83;
+acc += Math.sin(17835) + Math.cos(17836) * 84;
+acc += Math.sin(17836) + Math.cos(17837) * 85;
+acc += Math.sin(17837) + Math.cos(17838) * 86;
+acc += Math.sin(17838) + Math.cos(17839) * 87;
+acc += Math.sin(17839) + Math.cos(17840) * 88;
+acc += Math.sin(17840) + Math.cos(17841) * 89;
+acc += Math.sin(17841) + Math.cos(17842) * 90;
+acc += Math.sin(17842) + Math.cos(17843) * 91;
+acc += Math.sin(17843) + Math.cos(17844) * 92;
+acc += Math.sin(17844) + Math.cos(17845) * 93;
+acc += Math.sin(17845) + Math.cos(17846) * 94;
+acc += Math.sin(17846) + Math.cos(17847) * 95;
+acc += Math.sin(17847) + Math.cos(17848) * 96;
+acc += Math.sin(17848) + Math.cos(17849) * 0;
+acc += Math.sin(17849) + Math.cos(17850) * 1;
+acc += Math.sin(17850) + Math.cos(17851) * 2;
+acc += Math.sin(17851) + Math.cos(17852) * 3;
+acc += Math.sin(17852) + Math.cos(17853) * 4;
+acc += Math.sin(17853) + Math.cos(17854) * 5;
+acc += Math.sin(17854) + Math.cos(17855) * 6;
+acc += Math.sin(17855) + Math.cos(17856) * 7;
+acc += Math.sin(17856) + Math.cos(17857) * 8;
+acc += Math.sin(17857) + Math.cos(17858) * 9;
+acc += Math.sin(17858) + Math.cos(17859) * 10;
+acc += Math.sin(17859) + Math.cos(17860) * 11;
+acc += Math.sin(17860) + Math.cos(17861) * 12;
+acc += Math.sin(17861) + Math.cos(17862) * 13;
+acc += Math.sin(17862) + Math.cos(17863) * 14;
+acc += Math.sin(17863) + Math.cos(17864) * 15;
+acc += Math.sin(17864) + Math.cos(17865) * 16;
+acc += Math.sin(17865) + Math.cos(17866) * 17;
+acc += Math.sin(17866) + Math.cos(17867) * 18;
+acc += Math.sin(17867) + Math.cos(17868) * 19;
+acc += Math.sin(17868) + Math.cos(17869) * 20;
+acc += Math.sin(17869) + Math.cos(17870) * 21;
+acc += Math.sin(17870) + Math.cos(17871) * 22;
+acc += Math.sin(17871) + Math.cos(17872) * 23;
+acc += Math.sin(17872) + Math.cos(17873) * 24;
+acc += Math.sin(17873) + Math.cos(17874) * 25;
+acc += Math.sin(17874) + Math.cos(17875) * 26;
+acc += Math.sin(17875) + Math.cos(17876) * 27;
+acc += Math.sin(17876) + Math.cos(17877) * 28;
+acc += Math.sin(17877) + Math.cos(17878) * 29;
+acc += Math.sin(17878) + Math.cos(17879) * 30;
+acc += Math.sin(17879) + Math.cos(17880) * 31;
+acc += Math.sin(17880) + Math.cos(17881) * 32;
+acc += Math.sin(17881) + Math.cos(17882) * 33;
+acc += Math.sin(17882) + Math.cos(17883) * 34;
+acc += Math.sin(17883) + Math.cos(17884) * 35;
+acc += Math.sin(17884) + Math.cos(17885) * 36;
+acc += Math.sin(17885) + Math.cos(17886) * 37;
+acc += Math.sin(17886) + Math.cos(17887) * 38;
+acc += Math.sin(17887) + Math.cos(17888) * 39;
+acc += Math.sin(17888) + Math.cos(17889) * 40;
+acc += Math.sin(17889) + Math.cos(17890) * 41;
+acc += Math.sin(17890) + Math.cos(17891) * 42;
+acc += Math.sin(17891) + Math.cos(17892) * 43;
+acc += Math.sin(17892) + Math.cos(17893) * 44;
+acc += Math.sin(17893) + Math.cos(17894) * 45;
+acc += Math.sin(17894) + Math.cos(17895) * 46;
+acc += Math.sin(17895) + Math.cos(17896) * 47;
+acc += Math.sin(17896) + Math.cos(17897) * 48;
+acc += Math.sin(17897) + Math.cos(17898) * 49;
+acc += Math.sin(17898) + Math.cos(17899) * 50;
+acc += Math.sin(17899) + Math.cos(17900) * 51;
+acc += Math.sin(17900) + Math.cos(17901) * 52;
+acc += Math.sin(17901) + Math.cos(17902) * 53;
+acc += Math.sin(17902) + Math.cos(17903) * 54;
+acc += Math.sin(17903) + Math.cos(17904) * 55;
+acc += Math.sin(17904) + Math.cos(17905) * 56;
+acc += Math.sin(17905) + Math.cos(17906) * 57;
+acc += Math.sin(17906) + Math.cos(17907) * 58;
+acc += Math.sin(17907) + Math.cos(17908) * 59;
+acc += Math.sin(17908) + Math.cos(17909) * 60;
+acc += Math.sin(17909) + Math.cos(17910) * 61;
+acc += Math.sin(17910) + Math.cos(17911) * 62;
+acc += Math.sin(17911) + Math.cos(17912) * 63;
+acc += Math.sin(17912) + Math.cos(17913) * 64;
+acc += Math.sin(17913) + Math.cos(17914) * 65;
+acc += Math.sin(17914) + Math.cos(17915) * 66;
+acc += Math.sin(17915) + Math.cos(17916) * 67;
+acc += Math.sin(17916) + Math.cos(17917) * 68;
+acc += Math.sin(17917) + Math.cos(17918) * 69;
+acc += Math.sin(17918) + Math.cos(17919) * 70;
+acc += Math.sin(17919) + Math.cos(17920) * 71;
+acc += Math.sin(17920) + Math.cos(17921) * 72;
+acc += Math.sin(17921) + Math.cos(17922) * 73;
+acc += Math.sin(17922) + Math.cos(17923) * 74;
+acc += Math.sin(17923) + Math.cos(17924) * 75;
+acc += Math.sin(17924) + Math.cos(17925) * 76;
+acc += Math.sin(17925) + Math.cos(17926) * 77;
+acc += Math.sin(17926) + Math.cos(17927) * 78;
+acc += Math.sin(17927) + Math.cos(17928) * 79;
+acc += Math.sin(17928) + Math.cos(17929) * 80;
+acc += Math.sin(17929) + Math.cos(17930) * 81;
+acc += Math.sin(17930) + Math.cos(17931) * 82;
+acc += Math.sin(17931) + Math.cos(17932) * 83;
+acc += Math.sin(17932) + Math.cos(17933) * 84;
+acc += Math.sin(17933) + Math.cos(17934) * 85;
+acc += Math.sin(17934) + Math.cos(17935) * 86;
+acc += Math.sin(17935) + Math.cos(17936) * 87;
+acc += Math.sin(17936) + Math.cos(17937) * 88;
+acc += Math.sin(17937) + Math.cos(17938) * 89;
+acc += Math.sin(17938) + Math.cos(17939) * 90;
+acc += Math.sin(17939) + Math.cos(17940) * 91;
+acc += Math.sin(17940) + Math.cos(17941) * 92;
+acc += Math.sin(17941) + Math.cos(17942) * 93;
+acc += Math.sin(17942) + Math.cos(17943) * 94;
+acc += Math.sin(17943) + Math.cos(17944) * 95;
+acc += Math.sin(17944) + Math.cos(17945) * 96;
+acc += Math.sin(17945) + Math.cos(17946) * 0;
+acc += Math.sin(17946) + Math.cos(17947) * 1;
+acc += Math.sin(17947) + Math.cos(17948) * 2;
+acc += Math.sin(17948) + Math.cos(17949) * 3;
+acc += Math.sin(17949) + Math.cos(17950) * 4;
+acc += Math.sin(17950) + Math.cos(17951) * 5;
+acc += Math.sin(17951) + Math.cos(17952) * 6;
+acc += Math.sin(17952) + Math.cos(17953) * 7;
+acc += Math.sin(17953) + Math.cos(17954) * 8;
+acc += Math.sin(17954) + Math.cos(17955) * 9;
+acc += Math.sin(17955) + Math.cos(17956) * 10;
+acc += Math.sin(17956) + Math.cos(17957) * 11;
+acc += Math.sin(17957) + Math.cos(17958) * 12;
+acc += Math.sin(17958) + Math.cos(17959) * 13;
+acc += Math.sin(17959) + Math.cos(17960) * 14;
+acc += Math.sin(17960) + Math.cos(17961) * 15;
+acc += Math.sin(17961) + Math.cos(17962) * 16;
+acc += Math.sin(17962) + Math.cos(17963) * 17;
+acc += Math.sin(17963) + Math.cos(17964) * 18;
+acc += Math.sin(17964) + Math.cos(17965) * 19;
+acc += Math.sin(17965) + Math.cos(17966) * 20;
+acc += Math.sin(17966) + Math.cos(17967) * 21;
+acc += Math.sin(17967) + Math.cos(17968) * 22;
+acc += Math.sin(17968) + Math.cos(17969) * 23;
+acc += Math.sin(17969) + Math.cos(17970) * 24;
+acc += Math.sin(17970) + Math.cos(17971) * 25;
+acc += Math.sin(17971) + Math.cos(17972) * 26;
+acc += Math.sin(17972) + Math.cos(17973) * 27;
+acc += Math.sin(17973) + Math.cos(17974) * 28;
+acc += Math.sin(17974) + Math.cos(17975) * 29;
+acc += Math.sin(17975) + Math.cos(17976) * 30;
+acc += Math.sin(17976) + Math.cos(17977) * 31;
+acc += Math.sin(17977) + Math.cos(17978) * 32;
+acc += Math.sin(17978) + Math.cos(17979) * 33;
+acc += Math.sin(17979) + Math.cos(17980) * 34;
+acc += Math.sin(17980) + Math.cos(17981) * 35;
+acc += Math.sin(17981) + Math.cos(17982) * 36;
+acc += Math.sin(17982) + Math.cos(17983) * 37;
+acc += Math.sin(17983) + Math.cos(17984) * 38;
+acc += Math.sin(17984) + Math.cos(17985) * 39;
+acc += Math.sin(17985) + Math.cos(17986) * 40;
+acc += Math.sin(17986) + Math.cos(17987) * 41;
+acc += Math.sin(17987) + Math.cos(17988) * 42;
+acc += Math.sin(17988) + Math.cos(17989) * 43;
+acc += Math.sin(17989) + Math.cos(17990) * 44;
+acc += Math.sin(17990) + Math.cos(17991) * 45;
+acc += Math.sin(17991) + Math.cos(17992) * 46;
+acc += Math.sin(17992) + Math.cos(17993) * 47;
+acc += Math.sin(17993) + Math.cos(17994) * 48;
+acc += Math.sin(17994) + Math.cos(17995) * 49;
+acc += Math.sin(17995) + Math.cos(17996) * 50;
+acc += Math.sin(17996) + Math.cos(17997) * 51;
+acc += Math.sin(17997) + Math.cos(17998) * 52;
+acc += Math.sin(17998) + Math.cos(17999) * 53;
+acc += Math.sin(17999) + Math.cos(18000) * 54;
+acc += Math.sin(18000) + Math.cos(18001) * 55;
+acc += Math.sin(18001) + Math.cos(18002) * 56;
+acc += Math.sin(18002) + Math.cos(18003) * 57;
+acc += Math.sin(18003) + Math.cos(18004) * 58;
+acc += Math.sin(18004) + Math.cos(18005) * 59;
+acc += Math.sin(18005) + Math.cos(18006) * 60;
+acc += Math.sin(18006) + Math.cos(18007) * 61;
+acc += Math.sin(18007) + Math.cos(18008) * 62;
+acc += Math.sin(18008) + Math.cos(18009) * 63;
+acc += Math.sin(18009) + Math.cos(18010) * 64;
+acc += Math.sin(18010) + Math.cos(18011) * 65;
+acc += Math.sin(18011) + Math.cos(18012) * 66;
+acc += Math.sin(18012) + Math.cos(18013) * 67;
+acc += Math.sin(18013) + Math.cos(18014) * 68;
+acc += Math.sin(18014) + Math.cos(18015) * 69;
+acc += Math.sin(18015) + Math.cos(18016) * 70;
+acc += Math.sin(18016) + Math.cos(18017) * 71;
+acc += Math.sin(18017) + Math.cos(18018) * 72;
+acc += Math.sin(18018) + Math.cos(18019) * 73;
+acc += Math.sin(18019) + Math.cos(18020) * 74;
+acc += Math.sin(18020) + Math.cos(18021) * 75;
+acc += Math.sin(18021) + Math.cos(18022) * 76;
+acc += Math.sin(18022) + Math.cos(18023) * 77;
+acc += Math.sin(18023) + Math.cos(18024) * 78;
+acc += Math.sin(18024) + Math.cos(18025) * 79;
+acc += Math.sin(18025) + Math.cos(18026) * 80;
+acc += Math.sin(18026) + Math.cos(18027) * 81;
+acc += Math.sin(18027) + Math.cos(18028) * 82;
+acc += Math.sin(18028) + Math.cos(18029) * 83;
+acc += Math.sin(18029) + Math.cos(18030) * 84;
+acc += Math.sin(18030) + Math.cos(18031) * 85;
+acc += Math.sin(18031) + Math.cos(18032) * 86;
+acc += Math.sin(18032) + Math.cos(18033) * 87;
+acc += Math.sin(18033) + Math.cos(18034) * 88;
+acc += Math.sin(18034) + Math.cos(18035) * 89;
+acc += Math.sin(18035) + Math.cos(18036) * 90;
+acc += Math.sin(18036) + Math.cos(18037) * 91;
+acc += Math.sin(18037) + Math.cos(18038) * 92;
+acc += Math.sin(18038) + Math.cos(18039) * 93;
+acc += Math.sin(18039) + Math.cos(18040) * 94;
+acc += Math.sin(18040) + Math.cos(18041) * 95;
+acc += Math.sin(18041) + Math.cos(18042) * 96;
+acc += Math.sin(18042) + Math.cos(18043) * 0;
+acc += Math.sin(18043) + Math.cos(18044) * 1;
+acc += Math.sin(18044) + Math.cos(18045) * 2;
+acc += Math.sin(18045) + Math.cos(18046) * 3;
+acc += Math.sin(18046) + Math.cos(18047) * 4;
+acc += Math.sin(18047) + Math.cos(18048) * 5;
+acc += Math.sin(18048) + Math.cos(18049) * 6;
+acc += Math.sin(18049) + Math.cos(18050) * 7;
+acc += Math.sin(18050) + Math.cos(18051) * 8;
+acc += Math.sin(18051) + Math.cos(18052) * 9;
+acc += Math.sin(18052) + Math.cos(18053) * 10;
+acc += Math.sin(18053) + Math.cos(18054) * 11;
+acc += Math.sin(18054) + Math.cos(18055) * 12;
+acc += Math.sin(18055) + Math.cos(18056) * 13;
+acc += Math.sin(18056) + Math.cos(18057) * 14;
+acc += Math.sin(18057) + Math.cos(18058) * 15;
+acc += Math.sin(18058) + Math.cos(18059) * 16;
+acc += Math.sin(18059) + Math.cos(18060) * 17;
+acc += Math.sin(18060) + Math.cos(18061) * 18;
+acc += Math.sin(18061) + Math.cos(18062) * 19;
+acc += Math.sin(18062) + Math.cos(18063) * 20;
+acc += Math.sin(18063) + Math.cos(18064) * 21;
+acc += Math.sin(18064) + Math.cos(18065) * 22;
+acc += Math.sin(18065) + Math.cos(18066) * 23;
+acc += Math.sin(18066) + Math.cos(18067) * 24;
+acc += Math.sin(18067) + Math.cos(18068) * 25;
+acc += Math.sin(18068) + Math.cos(18069) * 26;
+acc += Math.sin(18069) + Math.cos(18070) * 27;
+acc += Math.sin(18070) + Math.cos(18071) * 28;
+acc += Math.sin(18071) + Math.cos(18072) * 29;
+acc += Math.sin(18072) + Math.cos(18073) * 30;
+acc += Math.sin(18073) + Math.cos(18074) * 31;
+acc += Math.sin(18074) + Math.cos(18075) * 32;
+acc += Math.sin(18075) + Math.cos(18076) * 33;
+acc += Math.sin(18076) + Math.cos(18077) * 34;
+acc += Math.sin(18077) + Math.cos(18078) * 35;
+acc += Math.sin(18078) + Math.cos(18079) * 36;
+acc += Math.sin(18079) + Math.cos(18080) * 37;
+acc += Math.sin(18080) + Math.cos(18081) * 38;
+acc += Math.sin(18081) + Math.cos(18082) * 39;
+acc += Math.sin(18082) + Math.cos(18083) * 40;
+acc += Math.sin(18083) + Math.cos(18084) * 41;
+acc += Math.sin(18084) + Math.cos(18085) * 42;
+acc += Math.sin(18085) + Math.cos(18086) * 43;
+acc += Math.sin(18086) + Math.cos(18087) * 44;
+acc += Math.sin(18087) + Math.cos(18088) * 45;
+acc += Math.sin(18088) + Math.cos(18089) * 46;
+acc += Math.sin(18089) + Math.cos(18090) * 47;
+acc += Math.sin(18090) + Math.cos(18091) * 48;
+acc += Math.sin(18091) + Math.cos(18092) * 49;
+acc += Math.sin(18092) + Math.cos(18093) * 50;
+acc += Math.sin(18093) + Math.cos(18094) * 51;
+acc += Math.sin(18094) + Math.cos(18095) * 52;
+acc += Math.sin(18095) + Math.cos(18096) * 53;
+acc += Math.sin(18096) + Math.cos(18097) * 54;
+acc += Math.sin(18097) + Math.cos(18098) * 55;
+acc += Math.sin(18098) + Math.cos(18099) * 56;
+acc += Math.sin(18099) + Math.cos(18100) * 57;
+acc += Math.sin(18100) + Math.cos(18101) * 58;
+acc += Math.sin(18101) + Math.cos(18102) * 59;
+acc += Math.sin(18102) + Math.cos(18103) * 60;
+acc += Math.sin(18103) + Math.cos(18104) * 61;
+acc += Math.sin(18104) + Math.cos(18105) * 62;
+acc += Math.sin(18105) + Math.cos(18106) * 63;
+acc += Math.sin(18106) + Math.cos(18107) * 64;
+acc += Math.sin(18107) + Math.cos(18108) * 65;
+acc += Math.sin(18108) + Math.cos(18109) * 66;
+acc += Math.sin(18109) + Math.cos(18110) * 67;
+acc += Math.sin(18110) + Math.cos(18111) * 68;
+acc += Math.sin(18111) + Math.cos(18112) * 69;
+acc += Math.sin(18112) + Math.cos(18113) * 70;
+acc += Math.sin(18113) + Math.cos(18114) * 71;
+acc += Math.sin(18114) + Math.cos(18115) * 72;
+acc += Math.sin(18115) + Math.cos(18116) * 73;
+acc += Math.sin(18116) + Math.cos(18117) * 74;
+acc += Math.sin(18117) + Math.cos(18118) * 75;
+acc += Math.sin(18118) + Math.cos(18119) * 76;
+acc += Math.sin(18119) + Math.cos(18120) * 77;
+acc += Math.sin(18120) + Math.cos(18121) * 78;
+acc += Math.sin(18121) + Math.cos(18122) * 79;
+acc += Math.sin(18122) + Math.cos(18123) * 80;
+acc += Math.sin(18123) + Math.cos(18124) * 81;
+acc += Math.sin(18124) + Math.cos(18125) * 82;
+acc += Math.sin(18125) + Math.cos(18126) * 83;
+acc += Math.sin(18126) + Math.cos(18127) * 84;
+acc += Math.sin(18127) + Math.cos(18128) * 85;
+acc += Math.sin(18128) + Math.cos(18129) * 86;
+acc += Math.sin(18129) + Math.cos(18130) * 87;
+acc += Math.sin(18130) + Math.cos(18131) * 88;
+acc += Math.sin(18131) + Math.cos(18132) * 89;
+acc += Math.sin(18132) + Math.cos(18133) * 90;
+acc += Math.sin(18133) + Math.cos(18134) * 91;
+acc += Math.sin(18134) + Math.cos(18135) * 92;
+acc += Math.sin(18135) + Math.cos(18136) * 93;
+acc += Math.sin(18136) + Math.cos(18137) * 94;
+acc += Math.sin(18137) + Math.cos(18138) * 95;
+acc += Math.sin(18138) + Math.cos(18139) * 96;
+acc += Math.sin(18139) + Math.cos(18140) * 0;
+acc += Math.sin(18140) + Math.cos(18141) * 1;
+acc += Math.sin(18141) + Math.cos(18142) * 2;
+acc += Math.sin(18142) + Math.cos(18143) * 3;
+acc += Math.sin(18143) + Math.cos(18144) * 4;
+acc += Math.sin(18144) + Math.cos(18145) * 5;
+acc += Math.sin(18145) + Math.cos(18146) * 6;
+acc += Math.sin(18146) + Math.cos(18147) * 7;
+acc += Math.sin(18147) + Math.cos(18148) * 8;
+acc += Math.sin(18148) + Math.cos(18149) * 9;
+acc += Math.sin(18149) + Math.cos(18150) * 10;
+acc += Math.sin(18150) + Math.cos(18151) * 11;
+acc += Math.sin(18151) + Math.cos(18152) * 12;
+acc += Math.sin(18152) + Math.cos(18153) * 13;
+acc += Math.sin(18153) + Math.cos(18154) * 14;
+acc += Math.sin(18154) + Math.cos(18155) * 15;
+acc += Math.sin(18155) + Math.cos(18156) * 16;
+acc += Math.sin(18156) + Math.cos(18157) * 17;
+acc += Math.sin(18157) + Math.cos(18158) * 18;
+acc += Math.sin(18158) + Math.cos(18159) * 19;
+acc += Math.sin(18159) + Math.cos(18160) * 20;
+acc += Math.sin(18160) + Math.cos(18161) * 21;
+acc += Math.sin(18161) + Math.cos(18162) * 22;
+acc += Math.sin(18162) + Math.cos(18163) * 23;
+acc += Math.sin(18163) + Math.cos(18164) * 24;
+acc += Math.sin(18164) + Math.cos(18165) * 25;
+acc += Math.sin(18165) + Math.cos(18166) * 26;
+acc += Math.sin(18166) + Math.cos(18167) * 27;
+acc += Math.sin(18167) + Math.cos(18168) * 28;
+acc += Math.sin(18168) + Math.cos(18169) * 29;
+acc += Math.sin(18169) + Math.cos(18170) * 30;
+acc += Math.sin(18170) + Math.cos(18171) * 31;
+acc += Math.sin(18171) + Math.cos(18172) * 32;
+acc += Math.sin(18172) + Math.cos(18173) * 33;
+acc += Math.sin(18173) + Math.cos(18174) * 34;
+acc += Math.sin(18174) + Math.cos(18175) * 35;
+acc += Math.sin(18175) + Math.cos(18176) * 36;
+acc += Math.sin(18176) + Math.cos(18177) * 37;
+acc += Math.sin(18177) + Math.cos(18178) * 38;
+acc += Math.sin(18178) + Math.cos(18179) * 39;
+acc += Math.sin(18179) + Math.cos(18180) * 40;
+acc += Math.sin(18180) + Math.cos(18181) * 41;
+acc += Math.sin(18181) + Math.cos(18182) * 42;
+acc += Math.sin(18182) + Math.cos(18183) * 43;
+acc += Math.sin(18183) + Math.cos(18184) * 44;
+acc += Math.sin(18184) + Math.cos(18185) * 45;
+acc += Math.sin(18185) + Math.cos(18186) * 46;
+acc += Math.sin(18186) + Math.cos(18187) * 47;
+acc += Math.sin(18187) + Math.cos(18188) * 48;
+acc += Math.sin(18188) + Math.cos(18189) * 49;
+acc += Math.sin(18189) + Math.cos(18190) * 50;
+acc += Math.sin(18190) + Math.cos(18191) * 51;
+acc += Math.sin(18191) + Math.cos(18192) * 52;
+acc += Math.sin(18192) + Math.cos(18193) * 53;
+acc += Math.sin(18193) + Math.cos(18194) * 54;
+acc += Math.sin(18194) + Math.cos(18195) * 55;
+acc += Math.sin(18195) + Math.cos(18196) * 56;
+acc += Math.sin(18196) + Math.cos(18197) * 57;
+acc += Math.sin(18197) + Math.cos(18198) * 58;
+acc += Math.sin(18198) + Math.cos(18199) * 59;
+acc += Math.sin(18199) + Math.cos(18200) * 60;
+acc += Math.sin(18200) + Math.cos(18201) * 61;
+acc += Math.sin(18201) + Math.cos(18202) * 62;
+acc += Math.sin(18202) + Math.cos(18203) * 63;
+acc += Math.sin(18203) + Math.cos(18204) * 64;
+acc += Math.sin(18204) + Math.cos(18205) * 65;
+acc += Math.sin(18205) + Math.cos(18206) * 66;
+acc += Math.sin(18206) + Math.cos(18207) * 67;
+acc += Math.sin(18207) + Math.cos(18208) * 68;
+acc += Math.sin(18208) + Math.cos(18209) * 69;
+acc += Math.sin(18209) + Math.cos(18210) * 70;
+acc += Math.sin(18210) + Math.cos(18211) * 71;
+acc += Math.sin(18211) + Math.cos(18212) * 72;
+acc += Math.sin(18212) + Math.cos(18213) * 73;
+acc += Math.sin(18213) + Math.cos(18214) * 74;
+acc += Math.sin(18214) + Math.cos(18215) * 75;
+acc += Math.sin(18215) + Math.cos(18216) * 76;
+acc += Math.sin(18216) + Math.cos(18217) * 77;
+acc += Math.sin(18217) + Math.cos(18218) * 78;
+acc += Math.sin(18218) + Math.cos(18219) * 79;
+acc += Math.sin(18219) + Math.cos(18220) * 80;
+acc += Math.sin(18220) + Math.cos(18221) * 81;
+acc += Math.sin(18221) + Math.cos(18222) * 82;
+acc += Math.sin(18222) + Math.cos(18223) * 83;
+acc += Math.sin(18223) + Math.cos(18224) * 84;
+acc += Math.sin(18224) + Math.cos(18225) * 85;
+acc += Math.sin(18225) + Math.cos(18226) * 86;
+acc += Math.sin(18226) + Math.cos(18227) * 87;
+acc += Math.sin(18227) + Math.cos(18228) * 88;
+acc += Math.sin(18228) + Math.cos(18229) * 89;
+acc += Math.sin(18229) + Math.cos(18230) * 90;
+acc += Math.sin(18230) + Math.cos(18231) * 91;
+acc += Math.sin(18231) + Math.cos(18232) * 92;
+acc += Math.sin(18232) + Math.cos(18233) * 93;
+acc += Math.sin(18233) + Math.cos(18234) * 94;
+acc += Math.sin(18234) + Math.cos(18235) * 95;
+acc += Math.sin(18235) + Math.cos(18236) * 96;
+acc += Math.sin(18236) + Math.cos(18237) * 0;
+acc += Math.sin(18237) + Math.cos(18238) * 1;
+acc += Math.sin(18238) + Math.cos(18239) * 2;
+acc += Math.sin(18239) + Math.cos(18240) * 3;
+acc += Math.sin(18240) + Math.cos(18241) * 4;
+acc += Math.sin(18241) + Math.cos(18242) * 5;
+acc += Math.sin(18242) + Math.cos(18243) * 6;
+acc += Math.sin(18243) + Math.cos(18244) * 7;
+acc += Math.sin(18244) + Math.cos(18245) * 8;
+acc += Math.sin(18245) + Math.cos(18246) * 9;
+acc += Math.sin(18246) + Math.cos(18247) * 10;
+acc += Math.sin(18247) + Math.cos(18248) * 11;
+acc += Math.sin(18248) + Math.cos(18249) * 12;
+acc += Math.sin(18249) + Math.cos(18250) * 13;
+acc += Math.sin(18250) + Math.cos(18251) * 14;
+acc += Math.sin(18251) + Math.cos(18252) * 15;
+acc += Math.sin(18252) + Math.cos(18253) * 16;
+acc += Math.sin(18253) + Math.cos(18254) * 17;
+acc += Math.sin(18254) + Math.cos(18255) * 18;
+acc += Math.sin(18255) + Math.cos(18256) * 19;
+acc += Math.sin(18256) + Math.cos(18257) * 20;
+acc += Math.sin(18257) + Math.cos(18258) * 21;
+acc += Math.sin(18258) + Math.cos(18259) * 22;
+acc += Math.sin(18259) + Math.cos(18260) * 23;
+acc += Math.sin(18260) + Math.cos(18261) * 24;
+acc += Math.sin(18261) + Math.cos(18262) * 25;
+acc += Math.sin(18262) + Math.cos(18263) * 26;
+acc += Math.sin(18263) + Math.cos(18264) * 27;
+acc += Math.sin(18264) + Math.cos(18265) * 28;
+acc += Math.sin(18265) + Math.cos(18266) * 29;
+acc += Math.sin(18266) + Math.cos(18267) * 30;
+acc += Math.sin(18267) + Math.cos(18268) * 31;
+acc += Math.sin(18268) + Math.cos(18269) * 32;
+acc += Math.sin(18269) + Math.cos(18270) * 33;
+acc += Math.sin(18270) + Math.cos(18271) * 34;
+acc += Math.sin(18271) + Math.cos(18272) * 35;
+acc += Math.sin(18272) + Math.cos(18273) * 36;
+acc += Math.sin(18273) + Math.cos(18274) * 37;
+acc += Math.sin(18274) + Math.cos(18275) * 38;
+acc += Math.sin(18275) + Math.cos(18276) * 39;
+acc += Math.sin(18276) + Math.cos(18277) * 40;
+acc += Math.sin(18277) + Math.cos(18278) * 41;
+acc += Math.sin(18278) + Math.cos(18279) * 42;
+acc += Math.sin(18279) + Math.cos(18280) * 43;
+acc += Math.sin(18280) + Math.cos(18281) * 44;
+acc += Math.sin(18281) + Math.cos(18282) * 45;
+acc += Math.sin(18282) + Math.cos(18283) * 46;
+acc += Math.sin(18283) + Math.cos(18284) * 47;
+acc += Math.sin(18284) + Math.cos(18285) * 48;
+acc += Math.sin(18285) + Math.cos(18286) * 49;
+acc += Math.sin(18286) + Math.cos(18287) * 50;
+acc += Math.sin(18287) + Math.cos(18288) * 51;
+acc += Math.sin(18288) + Math.cos(18289) * 52;
+acc += Math.sin(18289) + Math.cos(18290) * 53;
+acc += Math.sin(18290) + Math.cos(18291) * 54;
+acc += Math.sin(18291) + Math.cos(18292) * 55;
+acc += Math.sin(18292) + Math.cos(18293) * 56;
+acc += Math.sin(18293) + Math.cos(18294) * 57;
+acc += Math.sin(18294) + Math.cos(18295) * 58;
+acc += Math.sin(18295) + Math.cos(18296) * 59;
+acc += Math.sin(18296) + Math.cos(18297) * 60;
+acc += Math.sin(18297) + Math.cos(18298) * 61;
+acc += Math.sin(18298) + Math.cos(18299) * 62;
+acc += Math.sin(18299) + Math.cos(18300) * 63;
+acc += Math.sin(18300) + Math.cos(18301) * 64;
+acc += Math.sin(18301) + Math.cos(18302) * 65;
+acc += Math.sin(18302) + Math.cos(18303) * 66;
+acc += Math.sin(18303) + Math.cos(18304) * 67;
+acc += Math.sin(18304) + Math.cos(18305) * 68;
+acc += Math.sin(18305) + Math.cos(18306) * 69;
+acc += Math.sin(18306) + Math.cos(18307) * 70;
+acc += Math.sin(18307) + Math.cos(18308) * 71;
+acc += Math.sin(18308) + Math.cos(18309) * 72;
+acc += Math.sin(18309) + Math.cos(18310) * 73;
+acc += Math.sin(18310) + Math.cos(18311) * 74;
+acc += Math.sin(18311) + Math.cos(18312) * 75;
+acc += Math.sin(18312) + Math.cos(18313) * 76;
+acc += Math.sin(18313) + Math.cos(18314) * 77;
+acc += Math.sin(18314) + Math.cos(18315) * 78;
+acc += Math.sin(18315) + Math.cos(18316) * 79;
+acc += Math.sin(18316) + Math.cos(18317) * 80;
+acc += Math.sin(18317) + Math.cos(18318) * 81;
+acc += Math.sin(18318) + Math.cos(18319) * 82;
+acc += Math.sin(18319) + Math.cos(18320) * 83;
+acc += Math.sin(18320) + Math.cos(18321) * 84;
+acc += Math.sin(18321) + Math.cos(18322) * 85;
+acc += Math.sin(18322) + Math.cos(18323) * 86;
+acc += Math.sin(18323) + Math.cos(18324) * 87;
+acc += Math.sin(18324) + Math.cos(18325) * 88;
+acc += Math.sin(18325) + Math.cos(18326) * 89;
+acc += Math.sin(18326) + Math.cos(18327) * 90;
+acc += Math.sin(18327) + Math.cos(18328) * 91;
+acc += Math.sin(18328) + Math.cos(18329) * 92;
+acc += Math.sin(18329) + Math.cos(18330) * 93;
+acc += Math.sin(18330) + Math.cos(18331) * 94;
+acc += Math.sin(18331) + Math.cos(18332) * 95;
+acc += Math.sin(18332) + Math.cos(18333) * 96;
+acc += Math.sin(18333) + Math.cos(18334) * 0;
+acc += Math.sin(18334) + Math.cos(18335) * 1;
+acc += Math.sin(18335) + Math.cos(18336) * 2;
+acc += Math.sin(18336) + Math.cos(18337) * 3;
+acc += Math.sin(18337) + Math.cos(18338) * 4;
+acc += Math.sin(18338) + Math.cos(18339) * 5;
+acc += Math.sin(18339) + Math.cos(18340) * 6;
+acc += Math.sin(18340) + Math.cos(18341) * 7;
+acc += Math.sin(18341) + Math.cos(18342) * 8;
+acc += Math.sin(18342) + Math.cos(18343) * 9;
+acc += Math.sin(18343) + Math.cos(18344) * 10;
+acc += Math.sin(18344) + Math.cos(18345) * 11;
+acc += Math.sin(18345) + Math.cos(18346) * 12;
+acc += Math.sin(18346) + Math.cos(18347) * 13;
+acc += Math.sin(18347) + Math.cos(18348) * 14;
+acc += Math.sin(18348) + Math.cos(18349) * 15;
+acc += Math.sin(18349) + Math.cos(18350) * 16;
+acc += Math.sin(18350) + Math.cos(18351) * 17;
+acc += Math.sin(18351) + Math.cos(18352) * 18;
+acc += Math.sin(18352) + Math.cos(18353) * 19;
+acc += Math.sin(18353) + Math.cos(18354) * 20;
+acc += Math.sin(18354) + Math.cos(18355) * 21;
+acc += Math.sin(18355) + Math.cos(18356) * 22;
+acc += Math.sin(18356) + Math.cos(18357) * 23;
+acc += Math.sin(18357) + Math.cos(18358) * 24;
+acc += Math.sin(18358) + Math.cos(18359) * 25;
+acc += Math.sin(18359) + Math.cos(18360) * 26;
+acc += Math.sin(18360) + Math.cos(18361) * 27;
+acc += Math.sin(18361) + Math.cos(18362) * 28;
+acc += Math.sin(18362) + Math.cos(18363) * 29;
+acc += Math.sin(18363) + Math.cos(18364) * 30;
+acc += Math.sin(18364) + Math.cos(18365) * 31;
+acc += Math.sin(18365) + Math.cos(18366) * 32;
+acc += Math.sin(18366) + Math.cos(18367) * 33;
+acc += Math.sin(18367) + Math.cos(18368) * 34;
+acc += Math.sin(18368) + Math.cos(18369) * 35;
+acc += Math.sin(18369) + Math.cos(18370) * 36;
+acc += Math.sin(18370) + Math.cos(18371) * 37;
+acc += Math.sin(18371) + Math.cos(18372) * 38;
+acc += Math.sin(18372) + Math.cos(18373) * 39;
+acc += Math.sin(18373) + Math.cos(18374) * 40;
+acc += Math.sin(18374) + Math.cos(18375) * 41;
+acc += Math.sin(18375) + Math.cos(18376) * 42;
+acc += Math.sin(18376) + Math.cos(18377) * 43;
+acc += Math.sin(18377) + Math.cos(18378) * 44;
+acc += Math.sin(18378) + Math.cos(18379) * 45;
+acc += Math.sin(18379) + Math.cos(18380) * 46;
+acc += Math.sin(18380) + Math.cos(18381) * 47;
+acc += Math.sin(18381) + Math.cos(18382) * 48;
+acc += Math.sin(18382) + Math.cos(18383) * 49;
+acc += Math.sin(18383) + Math.cos(18384) * 50;
+acc += Math.sin(18384) + Math.cos(18385) * 51;
+acc += Math.sin(18385) + Math.cos(18386) * 52;
+acc += Math.sin(18386) + Math.cos(18387) * 53;
+acc += Math.sin(18387) + Math.cos(18388) * 54;
+acc += Math.sin(18388) + Math.cos(18389) * 55;
+acc += Math.sin(18389) + Math.cos(18390) * 56;
+acc += Math.sin(18390) + Math.cos(18391) * 57;
+acc += Math.sin(18391) + Math.cos(18392) * 58;
+acc += Math.sin(18392) + Math.cos(18393) * 59;
+acc += Math.sin(18393) + Math.cos(18394) * 60;
+acc += Math.sin(18394) + Math.cos(18395) * 61;
+acc += Math.sin(18395) + Math.cos(18396) * 62;
+acc += Math.sin(18396) + Math.cos(18397) * 63;
+acc += Math.sin(18397) + Math.cos(18398) * 64;
+acc += Math.sin(18398) + Math.cos(18399) * 65;
+acc += Math.sin(18399) + Math.cos(18400) * 66;
+acc += Math.sin(18400) + Math.cos(18401) * 67;
+acc += Math.sin(18401) + Math.cos(18402) * 68;
+acc += Math.sin(18402) + Math.cos(18403) * 69;
+acc += Math.sin(18403) + Math.cos(18404) * 70;
+acc += Math.sin(18404) + Math.cos(18405) * 71;
+acc += Math.sin(18405) + Math.cos(18406) * 72;
+acc += Math.sin(18406) + Math.cos(18407) * 73;
+acc += Math.sin(18407) + Math.cos(18408) * 74;
+acc += Math.sin(18408) + Math.cos(18409) * 75;
+acc += Math.sin(18409) + Math.cos(18410) * 76;
+acc += Math.sin(18410) + Math.cos(18411) * 77;
+acc += Math.sin(18411) + Math.cos(18412) * 78;
+acc += Math.sin(18412) + Math.cos(18413) * 79;
+acc += Math.sin(18413) + Math.cos(18414) * 80;
+acc += Math.sin(18414) + Math.cos(18415) * 81;
+acc += Math.sin(18415) + Math.cos(18416) * 82;
+acc += Math.sin(18416) + Math.cos(18417) * 83;
+acc += Math.sin(18417) + Math.cos(18418) * 84;
+acc += Math.sin(18418) + Math.cos(18419) * 85;
+acc += Math.sin(18419) + Math.cos(18420) * 86;
+acc += Math.sin(18420) + Math.cos(18421) * 87;
+acc += Math.sin(18421) + Math.cos(18422) * 88;
+acc += Math.sin(18422) + Math.cos(18423) * 89;
+acc += Math.sin(18423) + Math.cos(18424) * 90;
+acc += Math.sin(18424) + Math.cos(18425) * 91;
+acc += Math.sin(18425) + Math.cos(18426) * 92;
+acc += Math.sin(18426) + Math.cos(18427) * 93;
+acc += Math.sin(18427) + Math.cos(18428) * 94;
+acc += Math.sin(18428) + Math.cos(18429) * 95;
+acc += Math.sin(18429) + Math.cos(18430) * 96;
+acc += Math.sin(18430) + Math.cos(18431) * 0;
+acc += Math.sin(18431) + Math.cos(18432) * 1;
+acc += Math.sin(18432) + Math.cos(18433) * 2;
+acc += Math.sin(18433) + Math.cos(18434) * 3;
+acc += Math.sin(18434) + Math.cos(18435) * 4;
+acc += Math.sin(18435) + Math.cos(18436) * 5;
+acc += Math.sin(18436) + Math.cos(18437) * 6;
+acc += Math.sin(18437) + Math.cos(18438) * 7;
+acc += Math.sin(18438) + Math.cos(18439) * 8;
+acc += Math.sin(18439) + Math.cos(18440) * 9;
+acc += Math.sin(18440) + Math.cos(18441) * 10;
+acc += Math.sin(18441) + Math.cos(18442) * 11;
+acc += Math.sin(18442) + Math.cos(18443) * 12;
+acc += Math.sin(18443) + Math.cos(18444) * 13;
+acc += Math.sin(18444) + Math.cos(18445) * 14;
+acc += Math.sin(18445) + Math.cos(18446) * 15;
+acc += Math.sin(18446) + Math.cos(18447) * 16;
+acc += Math.sin(18447) + Math.cos(18448) * 17;
+acc += Math.sin(18448) + Math.cos(18449) * 18;
+acc += Math.sin(18449) + Math.cos(18450) * 19;
+acc += Math.sin(18450) + Math.cos(18451) * 20;
+acc += Math.sin(18451) + Math.cos(18452) * 21;
+acc += Math.sin(18452) + Math.cos(18453) * 22;
+acc += Math.sin(18453) + Math.cos(18454) * 23;
+acc += Math.sin(18454) + Math.cos(18455) * 24;
+acc += Math.sin(18455) + Math.cos(18456) * 25;
+acc += Math.sin(18456) + Math.cos(18457) * 26;
+acc += Math.sin(18457) + Math.cos(18458) * 27;
+acc += Math.sin(18458) + Math.cos(18459) * 28;
+acc += Math.sin(18459) + Math.cos(18460) * 29;
+acc += Math.sin(18460) + Math.cos(18461) * 30;
+acc += Math.sin(18461) + Math.cos(18462) * 31;
+acc += Math.sin(18462) + Math.cos(18463) * 32;
+acc += Math.sin(18463) + Math.cos(18464) * 33;
+acc += Math.sin(18464) + Math.cos(18465) * 34;
+acc += Math.sin(18465) + Math.cos(18466) * 35;
+acc += Math.sin(18466) + Math.cos(18467) * 36;
+acc += Math.sin(18467) + Math.cos(18468) * 37;
+acc += Math.sin(18468) + Math.cos(18469) * 38;
+acc += Math.sin(18469) + Math.cos(18470) * 39;
+acc += Math.sin(18470) + Math.cos(18471) * 40;
+acc += Math.sin(18471) + Math.cos(18472) * 41;
+acc += Math.sin(18472) + Math.cos(18473) * 42;
+acc += Math.sin(18473) + Math.cos(18474) * 43;
+acc += Math.sin(18474) + Math.cos(18475) * 44;
+acc += Math.sin(18475) + Math.cos(18476) * 45;
+acc += Math.sin(18476) + Math.cos(18477) * 46;
+acc += Math.sin(18477) + Math.cos(18478) * 47;
+acc += Math.sin(18478) + Math.cos(18479) * 48;
+acc += Math.sin(18479) + Math.cos(18480) * 49;
+acc += Math.sin(18480) + Math.cos(18481) * 50;
+acc += Math.sin(18481) + Math.cos(18482) * 51;
+acc += Math.sin(18482) + Math.cos(18483) * 52;
+acc += Math.sin(18483) + Math.cos(18484) * 53;
+acc += Math.sin(18484) + Math.cos(18485) * 54;
+acc += Math.sin(18485) + Math.cos(18486) * 55;
+acc += Math.sin(18486) + Math.cos(18487) * 56;
+acc += Math.sin(18487) + Math.cos(18488) * 57;
+acc += Math.sin(18488) + Math.cos(18489) * 58;
+acc += Math.sin(18489) + Math.cos(18490) * 59;
+acc += Math.sin(18490) + Math.cos(18491) * 60;
+acc += Math.sin(18491) + Math.cos(18492) * 61;
+acc += Math.sin(18492) + Math.cos(18493) * 62;
+acc += Math.sin(18493) + Math.cos(18494) * 63;
+acc += Math.sin(18494) + Math.cos(18495) * 64;
+acc += Math.sin(18495) + Math.cos(18496) * 65;
+acc += Math.sin(18496) + Math.cos(18497) * 66;
+acc += Math.sin(18497) + Math.cos(18498) * 67;
+acc += Math.sin(18498) + Math.cos(18499) * 68;
+acc += Math.sin(18499) + Math.cos(18500) * 69;
+acc += Math.sin(18500) + Math.cos(18501) * 70;
+acc += Math.sin(18501) + Math.cos(18502) * 71;
+acc += Math.sin(18502) + Math.cos(18503) * 72;
+acc += Math.sin(18503) + Math.cos(18504) * 73;
+acc += Math.sin(18504) + Math.cos(18505) * 74;
+acc += Math.sin(18505) + Math.cos(18506) * 75;
+acc += Math.sin(18506) + Math.cos(18507) * 76;
+acc += Math.sin(18507) + Math.cos(18508) * 77;
+acc += Math.sin(18508) + Math.cos(18509) * 78;
+acc += Math.sin(18509) + Math.cos(18510) * 79;
+acc += Math.sin(18510) + Math.cos(18511) * 80;
+acc += Math.sin(18511) + Math.cos(18512) * 81;
+acc += Math.sin(18512) + Math.cos(18513) * 82;
+acc += Math.sin(18513) + Math.cos(18514) * 83;
+acc += Math.sin(18514) + Math.cos(18515) * 84;
+acc += Math.sin(18515) + Math.cos(18516) * 85;
+acc += Math.sin(18516) + Math.cos(18517) * 86;
+acc += Math.sin(18517) + Math.cos(18518) * 87;
+acc += Math.sin(18518) + Math.cos(18519) * 88;
+acc += Math.sin(18519) + Math.cos(18520) * 89;
+acc += Math.sin(18520) + Math.cos(18521) * 90;
+acc += Math.sin(18521) + Math.cos(18522) * 91;
+acc += Math.sin(18522) + Math.cos(18523) * 92;
+acc += Math.sin(18523) + Math.cos(18524) * 93;
+acc += Math.sin(18524) + Math.cos(18525) * 94;
+acc += Math.sin(18525) + Math.cos(18526) * 95;
+acc += Math.sin(18526) + Math.cos(18527) * 96;
+acc += Math.sin(18527) + Math.cos(18528) * 0;
+acc += Math.sin(18528) + Math.cos(18529) * 1;
+acc += Math.sin(18529) + Math.cos(18530) * 2;
+acc += Math.sin(18530) + Math.cos(18531) * 3;
+acc += Math.sin(18531) + Math.cos(18532) * 4;
+acc += Math.sin(18532) + Math.cos(18533) * 5;
+acc += Math.sin(18533) + Math.cos(18534) * 6;
+acc += Math.sin(18534) + Math.cos(18535) * 7;
+acc += Math.sin(18535) + Math.cos(18536) * 8;
+acc += Math.sin(18536) + Math.cos(18537) * 9;
+acc += Math.sin(18537) + Math.cos(18538) * 10;
+acc += Math.sin(18538) + Math.cos(18539) * 11;
+acc += Math.sin(18539) + Math.cos(18540) * 12;
+acc += Math.sin(18540) + Math.cos(18541) * 13;
+acc += Math.sin(18541) + Math.cos(18542) * 14;
+acc += Math.sin(18542) + Math.cos(18543) * 15;
+acc += Math.sin(18543) + Math.cos(18544) * 16;
+acc += Math.sin(18544) + Math.cos(18545) * 17;
+acc += Math.sin(18545) + Math.cos(18546) * 18;
+acc += Math.sin(18546) + Math.cos(18547) * 19;
+acc += Math.sin(18547) + Math.cos(18548) * 20;
+acc += Math.sin(18548) + Math.cos(18549) * 21;
+acc += Math.sin(18549) + Math.cos(18550) * 22;
+acc += Math.sin(18550) + Math.cos(18551) * 23;
+acc += Math.sin(18551) + Math.cos(18552) * 24;
+acc += Math.sin(18552) + Math.cos(18553) * 25;
+acc += Math.sin(18553) + Math.cos(18554) * 26;
+acc += Math.sin(18554) + Math.cos(18555) * 27;
+acc += Math.sin(18555) + Math.cos(18556) * 28;
+acc += Math.sin(18556) + Math.cos(18557) * 29;
+acc += Math.sin(18557) + Math.cos(18558) * 30;
+acc += Math.sin(18558) + Math.cos(18559) * 31;
+acc += Math.sin(18559) + Math.cos(18560) * 32;
+acc += Math.sin(18560) + Math.cos(18561) * 33;
+acc += Math.sin(18561) + Math.cos(18562) * 34;
+acc += Math.sin(18562) + Math.cos(18563) * 35;
+acc += Math.sin(18563) + Math.cos(18564) * 36;
+acc += Math.sin(18564) + Math.cos(18565) * 37;
+acc += Math.sin(18565) + Math.cos(18566) * 38;
+acc += Math.sin(18566) + Math.cos(18567) * 39;
+acc += Math.sin(18567) + Math.cos(18568) * 40;
+acc += Math.sin(18568) + Math.cos(18569) * 41;
+acc += Math.sin(18569) + Math.cos(18570) * 42;
+acc += Math.sin(18570) + Math.cos(18571) * 43;
+acc += Math.sin(18571) + Math.cos(18572) * 44;
+acc += Math.sin(18572) + Math.cos(18573) * 45;
+acc += Math.sin(18573) + Math.cos(18574) * 46;
+acc += Math.sin(18574) + Math.cos(18575) * 47;
+acc += Math.sin(18575) + Math.cos(18576) * 48;
+acc += Math.sin(18576) + Math.cos(18577) * 49;
+acc += Math.sin(18577) + Math.cos(18578) * 50;
+acc += Math.sin(18578) + Math.cos(18579) * 51;
+acc += Math.sin(18579) + Math.cos(18580) * 52;
+acc += Math.sin(18580) + Math.cos(18581) * 53;
+acc += Math.sin(18581) + Math.cos(18582) * 54;
+acc += Math.sin(18582) + Math.cos(18583) * 55;
+acc += Math.sin(18583) + Math.cos(18584) * 56;
+acc += Math.sin(18584) + Math.cos(18585) * 57;
+acc += Math.sin(18585) + Math.cos(18586) * 58;
+acc += Math.sin(18586) + Math.cos(18587) * 59;
+acc += Math.sin(18587) + Math.cos(18588) * 60;
+acc += Math.sin(18588) + Math.cos(18589) * 61;
+acc += Math.sin(18589) + Math.cos(18590) * 62;
+acc += Math.sin(18590) + Math.cos(18591) * 63;
+acc += Math.sin(18591) + Math.cos(18592) * 64;
+acc += Math.sin(18592) + Math.cos(18593) * 65;
+acc += Math.sin(18593) + Math.cos(18594) * 66;
+acc += Math.sin(18594) + Math.cos(18595) * 67;
+acc += Math.sin(18595) + Math.cos(18596) * 68;
+acc += Math.sin(18596) + Math.cos(18597) * 69;
+acc += Math.sin(18597) + Math.cos(18598) * 70;
+acc += Math.sin(18598) + Math.cos(18599) * 71;
+acc += Math.sin(18599) + Math.cos(18600) * 72;
+acc += Math.sin(18600) + Math.cos(18601) * 73;
+acc += Math.sin(18601) + Math.cos(18602) * 74;
+acc += Math.sin(18602) + Math.cos(18603) * 75;
+acc += Math.sin(18603) + Math.cos(18604) * 76;
+acc += Math.sin(18604) + Math.cos(18605) * 77;
+acc += Math.sin(18605) + Math.cos(18606) * 78;
+acc += Math.sin(18606) + Math.cos(18607) * 79;
+acc += Math.sin(18607) + Math.cos(18608) * 80;
+acc += Math.sin(18608) + Math.cos(18609) * 81;
+acc += Math.sin(18609) + Math.cos(18610) * 82;
+acc += Math.sin(18610) + Math.cos(18611) * 83;
+acc += Math.sin(18611) + Math.cos(18612) * 84;
+acc += Math.sin(18612) + Math.cos(18613) * 85;
+acc += Math.sin(18613) + Math.cos(18614) * 86;
+acc += Math.sin(18614) + Math.cos(18615) * 87;
+acc += Math.sin(18615) + Math.cos(18616) * 88;
+acc += Math.sin(18616) + Math.cos(18617) * 89;
+acc += Math.sin(18617) + Math.cos(18618) * 90;
+acc += Math.sin(18618) + Math.cos(18619) * 91;
+acc += Math.sin(18619) + Math.cos(18620) * 92;
+acc += Math.sin(18620) + Math.cos(18621) * 93;
+acc += Math.sin(18621) + Math.cos(18622) * 94;
+acc += Math.sin(18622) + Math.cos(18623) * 95;
+acc += Math.sin(18623) + Math.cos(18624) * 96;
+acc += Math.sin(18624) + Math.cos(18625) * 0;
+acc += Math.sin(18625) + Math.cos(18626) * 1;
+acc += Math.sin(18626) + Math.cos(18627) * 2;
+acc += Math.sin(18627) + Math.cos(18628) * 3;
+acc += Math.sin(18628) + Math.cos(18629) * 4;
+acc += Math.sin(18629) + Math.cos(18630) * 5;
+acc += Math.sin(18630) + Math.cos(18631) * 6;
+acc += Math.sin(18631) + Math.cos(18632) * 7;
+acc += Math.sin(18632) + Math.cos(18633) * 8;
+acc += Math.sin(18633) + Math.cos(18634) * 9;
+acc += Math.sin(18634) + Math.cos(18635) * 10;
+acc += Math.sin(18635) + Math.cos(18636) * 11;
+acc += Math.sin(18636) + Math.cos(18637) * 12;
+acc += Math.sin(18637) + Math.cos(18638) * 13;
+acc += Math.sin(18638) + Math.cos(18639) * 14;
+acc += Math.sin(18639) + Math.cos(18640) * 15;
+acc += Math.sin(18640) + Math.cos(18641) * 16;
+acc += Math.sin(18641) + Math.cos(18642) * 17;
+acc += Math.sin(18642) + Math.cos(18643) * 18;
+acc += Math.sin(18643) + Math.cos(18644) * 19;
+acc += Math.sin(18644) + Math.cos(18645) * 20;
+acc += Math.sin(18645) + Math.cos(18646) * 21;
+acc += Math.sin(18646) + Math.cos(18647) * 22;
+acc += Math.sin(18647) + Math.cos(18648) * 23;
+acc += Math.sin(18648) + Math.cos(18649) * 24;
+acc += Math.sin(18649) + Math.cos(18650) * 25;
+acc += Math.sin(18650) + Math.cos(18651) * 26;
+acc += Math.sin(18651) + Math.cos(18652) * 27;
+acc += Math.sin(18652) + Math.cos(18653) * 28;
+acc += Math.sin(18653) + Math.cos(18654) * 29;
+acc += Math.sin(18654) + Math.cos(18655) * 30;
+acc += Math.sin(18655) + Math.cos(18656) * 31;
+acc += Math.sin(18656) + Math.cos(18657) * 32;
+acc += Math.sin(18657) + Math.cos(18658) * 33;
+acc += Math.sin(18658) + Math.cos(18659) * 34;
+acc += Math.sin(18659) + Math.cos(18660) * 35;
+acc += Math.sin(18660) + Math.cos(18661) * 36;
+acc += Math.sin(18661) + Math.cos(18662) * 37;
+acc += Math.sin(18662) + Math.cos(18663) * 38;
+acc += Math.sin(18663) + Math.cos(18664) * 39;
+acc += Math.sin(18664) + Math.cos(18665) * 40;
+acc += Math.sin(18665) + Math.cos(18666) * 41;
+acc += Math.sin(18666) + Math.cos(18667) * 42;
+acc += Math.sin(18667) + Math.cos(18668) * 43;
+acc += Math.sin(18668) + Math.cos(18669) * 44;
+acc += Math.sin(18669) + Math.cos(18670) * 45;
+acc += Math.sin(18670) + Math.cos(18671) * 46;
+acc += Math.sin(18671) + Math.cos(18672) * 47;
+acc += Math.sin(18672) + Math.cos(18673) * 48;
+acc += Math.sin(18673) + Math.cos(18674) * 49;
+acc += Math.sin(18674) + Math.cos(18675) * 50;
+acc += Math.sin(18675) + Math.cos(18676) * 51;
+acc += Math.sin(18676) + Math.cos(18677) * 52;
+acc += Math.sin(18677) + Math.cos(18678) * 53;
+acc += Math.sin(18678) + Math.cos(18679) * 54;
+acc += Math.sin(18679) + Math.cos(18680) * 55;
+acc += Math.sin(18680) + Math.cos(18681) * 56;
+acc += Math.sin(18681) + Math.cos(18682) * 57;
+acc += Math.sin(18682) + Math.cos(18683) * 58;
+acc += Math.sin(18683) + Math.cos(18684) * 59;
+acc += Math.sin(18684) + Math.cos(18685) * 60;
+acc += Math.sin(18685) + Math.cos(18686) * 61;
+acc += Math.sin(18686) + Math.cos(18687) * 62;
+acc += Math.sin(18687) + Math.cos(18688) * 63;
+acc += Math.sin(18688) + Math.cos(18689) * 64;
+acc += Math.sin(18689) + Math.cos(18690) * 65;
+acc += Math.sin(18690) + Math.cos(18691) * 66;
+acc += Math.sin(18691) + Math.cos(18692) * 67;
+acc += Math.sin(18692) + Math.cos(18693) * 68;
+acc += Math.sin(18693) + Math.cos(18694) * 69;
+acc += Math.sin(18694) + Math.cos(18695) * 70;
+acc += Math.sin(18695) + Math.cos(18696) * 71;
+acc += Math.sin(18696) + Math.cos(18697) * 72;
+acc += Math.sin(18697) + Math.cos(18698) * 73;
+acc += Math.sin(18698) + Math.cos(18699) * 74;
+acc += Math.sin(18699) + Math.cos(18700) * 75;
+acc += Math.sin(18700) + Math.cos(18701) * 76;
+acc += Math.sin(18701) + Math.cos(18702) * 77;
+acc += Math.sin(18702) + Math.cos(18703) * 78;
+acc += Math.sin(18703) + Math.cos(18704) * 79;
+acc += Math.sin(18704) + Math.cos(18705) * 80;
+acc += Math.sin(18705) + Math.cos(18706) * 81;
+acc += Math.sin(18706) + Math.cos(18707) * 82;
+acc += Math.sin(18707) + Math.cos(18708) * 83;
+acc += Math.sin(18708) + Math.cos(18709) * 84;
+acc += Math.sin(18709) + Math.cos(18710) * 85;
+acc += Math.sin(18710) + Math.cos(18711) * 86;
+acc += Math.sin(18711) + Math.cos(18712) * 87;
+acc += Math.sin(18712) + Math.cos(18713) * 88;
+acc += Math.sin(18713) + Math.cos(18714) * 89;
+acc += Math.sin(18714) + Math.cos(18715) * 90;
+acc += Math.sin(18715) + Math.cos(18716) * 91;
+acc += Math.sin(18716) + Math.cos(18717) * 92;
+acc += Math.sin(18717) + Math.cos(18718) * 93;
+acc += Math.sin(18718) + Math.cos(18719) * 94;
+acc += Math.sin(18719) + Math.cos(18720) * 95;
+acc += Math.sin(18720) + Math.cos(18721) * 96;
+acc += Math.sin(18721) + Math.cos(18722) * 0;
+acc += Math.sin(18722) + Math.cos(18723) * 1;
+acc += Math.sin(18723) + Math.cos(18724) * 2;
+acc += Math.sin(18724) + Math.cos(18725) * 3;
+acc += Math.sin(18725) + Math.cos(18726) * 4;
+acc += Math.sin(18726) + Math.cos(18727) * 5;
+acc += Math.sin(18727) + Math.cos(18728) * 6;
+acc += Math.sin(18728) + Math.cos(18729) * 7;
+acc += Math.sin(18729) + Math.cos(18730) * 8;
+acc += Math.sin(18730) + Math.cos(18731) * 9;
+acc += Math.sin(18731) + Math.cos(18732) * 10;
+acc += Math.sin(18732) + Math.cos(18733) * 11;
+acc += Math.sin(18733) + Math.cos(18734) * 12;
+acc += Math.sin(18734) + Math.cos(18735) * 13;
+acc += Math.sin(18735) + Math.cos(18736) * 14;
+acc += Math.sin(18736) + Math.cos(18737) * 15;
+acc += Math.sin(18737) + Math.cos(18738) * 16;
+acc += Math.sin(18738) + Math.cos(18739) * 17;
+acc += Math.sin(18739) + Math.cos(18740) * 18;
+acc += Math.sin(18740) + Math.cos(18741) * 19;
+acc += Math.sin(18741) + Math.cos(18742) * 20;
+acc += Math.sin(18742) + Math.cos(18743) * 21;
+acc += Math.sin(18743) + Math.cos(18744) * 22;
+acc += Math.sin(18744) + Math.cos(18745) * 23;
+acc += Math.sin(18745) + Math.cos(18746) * 24;
+acc += Math.sin(18746) + Math.cos(18747) * 25;
+acc += Math.sin(18747) + Math.cos(18748) * 26;
+acc += Math.sin(18748) + Math.cos(18749) * 27;
+acc += Math.sin(18749) + Math.cos(18750) * 28;
+acc += Math.sin(18750) + Math.cos(18751) * 29;
+acc += Math.sin(18751) + Math.cos(18752) * 30;
+acc += Math.sin(18752) + Math.cos(18753) * 31;
+acc += Math.sin(18753) + Math.cos(18754) * 32;
+acc += Math.sin(18754) + Math.cos(18755) * 33;
+acc += Math.sin(18755) + Math.cos(18756) * 34;
+acc += Math.sin(18756) + Math.cos(18757) * 35;
+acc += Math.sin(18757) + Math.cos(18758) * 36;
+acc += Math.sin(18758) + Math.cos(18759) * 37;
+acc += Math.sin(18759) + Math.cos(18760) * 38;
+acc += Math.sin(18760) + Math.cos(18761) * 39;
+acc += Math.sin(18761) + Math.cos(18762) * 40;
+acc += Math.sin(18762) + Math.cos(18763) * 41;
+acc += Math.sin(18763) + Math.cos(18764) * 42;
+acc += Math.sin(18764) + Math.cos(18765) * 43;
+acc += Math.sin(18765) + Math.cos(18766) * 44;
+acc += Math.sin(18766) + Math.cos(18767) * 45;
+acc += Math.sin(18767) + Math.cos(18768) * 46;
+acc += Math.sin(18768) + Math.cos(18769) * 47;
+acc += Math.sin(18769) + Math.cos(18770) * 48;
+acc += Math.sin(18770) + Math.cos(18771) * 49;
+acc += Math.sin(18771) + Math.cos(18772) * 50;
+acc += Math.sin(18772) + Math.cos(18773) * 51;
+acc += Math.sin(18773) + Math.cos(18774) * 52;
+acc += Math.sin(18774) + Math.cos(18775) * 53;
+acc += Math.sin(18775) + Math.cos(18776) * 54;
+acc += Math.sin(18776) + Math.cos(18777) * 55;
+acc += Math.sin(18777) + Math.cos(18778) * 56;
+acc += Math.sin(18778) + Math.cos(18779) * 57;
+acc += Math.sin(18779) + Math.cos(18780) * 58;
+acc += Math.sin(18780) + Math.cos(18781) * 59;
+acc += Math.sin(18781) + Math.cos(18782) * 60;
+acc += Math.sin(18782) + Math.cos(18783) * 61;
+acc += Math.sin(18783) + Math.cos(18784) * 62;
+acc += Math.sin(18784) + Math.cos(18785) * 63;
+acc += Math.sin(18785) + Math.cos(18786) * 64;
+acc += Math.sin(18786) + Math.cos(18787) * 65;
+acc += Math.sin(18787) + Math.cos(18788) * 66;
+acc += Math.sin(18788) + Math.cos(18789) * 67;
+acc += Math.sin(18789) + Math.cos(18790) * 68;
+acc += Math.sin(18790) + Math.cos(18791) * 69;
+acc += Math.sin(18791) + Math.cos(18792) * 70;
+acc += Math.sin(18792) + Math.cos(18793) * 71;
+acc += Math.sin(18793) + Math.cos(18794) * 72;
+acc += Math.sin(18794) + Math.cos(18795) * 73;
+acc += Math.sin(18795) + Math.cos(18796) * 74;
+acc += Math.sin(18796) + Math.cos(18797) * 75;
+acc += Math.sin(18797) + Math.cos(18798) * 76;
+acc += Math.sin(18798) + Math.cos(18799) * 77;
+acc += Math.sin(18799) + Math.cos(18800) * 78;
+acc += Math.sin(18800) + Math.cos(18801) * 79;
+acc += Math.sin(18801) + Math.cos(18802) * 80;
+acc += Math.sin(18802) + Math.cos(18803) * 81;
+acc += Math.sin(18803) + Math.cos(18804) * 82;
+acc += Math.sin(18804) + Math.cos(18805) * 83;
+acc += Math.sin(18805) + Math.cos(18806) * 84;
+acc += Math.sin(18806) + Math.cos(18807) * 85;
+acc += Math.sin(18807) + Math.cos(18808) * 86;
+acc += Math.sin(18808) + Math.cos(18809) * 87;
+acc += Math.sin(18809) + Math.cos(18810) * 88;
+acc += Math.sin(18810) + Math.cos(18811) * 89;
+acc += Math.sin(18811) + Math.cos(18812) * 90;
+acc += Math.sin(18812) + Math.cos(18813) * 91;
+acc += Math.sin(18813) + Math.cos(18814) * 92;
+acc += Math.sin(18814) + Math.cos(18815) * 93;
+acc += Math.sin(18815) + Math.cos(18816) * 94;
+acc += Math.sin(18816) + Math.cos(18817) * 95;
+acc += Math.sin(18817) + Math.cos(18818) * 96;
+acc += Math.sin(18818) + Math.cos(18819) * 0;
+acc += Math.sin(18819) + Math.cos(18820) * 1;
+acc += Math.sin(18820) + Math.cos(18821) * 2;
+acc += Math.sin(18821) + Math.cos(18822) * 3;
+acc += Math.sin(18822) + Math.cos(18823) * 4;
+acc += Math.sin(18823) + Math.cos(18824) * 5;
+acc += Math.sin(18824) + Math.cos(18825) * 6;
+acc += Math.sin(18825) + Math.cos(18826) * 7;
+acc += Math.sin(18826) + Math.cos(18827) * 8;
+acc += Math.sin(18827) + Math.cos(18828) * 9;
+acc += Math.sin(18828) + Math.cos(18829) * 10;
+acc += Math.sin(18829) + Math.cos(18830) * 11;
+acc += Math.sin(18830) + Math.cos(18831) * 12;
+acc += Math.sin(18831) + Math.cos(18832) * 13;
+acc += Math.sin(18832) + Math.cos(18833) * 14;
+acc += Math.sin(18833) + Math.cos(18834) * 15;
+acc += Math.sin(18834) + Math.cos(18835) * 16;
+acc += Math.sin(18835) + Math.cos(18836) * 17;
+acc += Math.sin(18836) + Math.cos(18837) * 18;
+acc += Math.sin(18837) + Math.cos(18838) * 19;
+acc += Math.sin(18838) + Math.cos(18839) * 20;
+acc += Math.sin(18839) + Math.cos(18840) * 21;
+acc += Math.sin(18840) + Math.cos(18841) * 22;
+acc += Math.sin(18841) + Math.cos(18842) * 23;
+acc += Math.sin(18842) + Math.cos(18843) * 24;
+acc += Math.sin(18843) + Math.cos(18844) * 25;
+acc += Math.sin(18844) + Math.cos(18845) * 26;
+acc += Math.sin(18845) + Math.cos(18846) * 27;
+acc += Math.sin(18846) + Math.cos(18847) * 28;
+acc += Math.sin(18847) + Math.cos(18848) * 29;
+acc += Math.sin(18848) + Math.cos(18849) * 30;
+acc += Math.sin(18849) + Math.cos(18850) * 31;
+acc += Math.sin(18850) + Math.cos(18851) * 32;
+acc += Math.sin(18851) + Math.cos(18852) * 33;
+acc += Math.sin(18852) + Math.cos(18853) * 34;
+acc += Math.sin(18853) + Math.cos(18854) * 35;
+acc += Math.sin(18854) + Math.cos(18855) * 36;
+acc += Math.sin(18855) + Math.cos(18856) * 37;
+acc += Math.sin(18856) + Math.cos(18857) * 38;
+acc += Math.sin(18857) + Math.cos(18858) * 39;
+acc += Math.sin(18858) + Math.cos(18859) * 40;
+acc += Math.sin(18859) + Math.cos(18860) * 41;
+acc += Math.sin(18860) + Math.cos(18861) * 42;
+acc += Math.sin(18861) + Math.cos(18862) * 43;
+acc += Math.sin(18862) + Math.cos(18863) * 44;
+acc += Math.sin(18863) + Math.cos(18864) * 45;
+acc += Math.sin(18864) + Math.cos(18865) * 46;
+acc += Math.sin(18865) + Math.cos(18866) * 47;
+acc += Math.sin(18866) + Math.cos(18867) * 48;
+acc += Math.sin(18867) + Math.cos(18868) * 49;
+acc += Math.sin(18868) + Math.cos(18869) * 50;
+acc += Math.sin(18869) + Math.cos(18870) * 51;
+acc += Math.sin(18870) + Math.cos(18871) * 52;
+acc += Math.sin(18871) + Math.cos(18872) * 53;
+acc += Math.sin(18872) + Math.cos(18873) * 54;
+acc += Math.sin(18873) + Math.cos(18874) * 55;
+acc += Math.sin(18874) + Math.cos(18875) * 56;
+acc += Math.sin(18875) + Math.cos(18876) * 57;
+acc += Math.sin(18876) + Math.cos(18877) * 58;
+acc += Math.sin(18877) + Math.cos(18878) * 59;
+acc += Math.sin(18878) + Math.cos(18879) * 60;
+acc += Math.sin(18879) + Math.cos(18880) * 61;
+acc += Math.sin(18880) + Math.cos(18881) * 62;
+acc += Math.sin(18881) + Math.cos(18882) * 63;
+acc += Math.sin(18882) + Math.cos(18883) * 64;
+acc += Math.sin(18883) + Math.cos(18884) * 65;
+acc += Math.sin(18884) + Math.cos(18885) * 66;
+acc += Math.sin(18885) + Math.cos(18886) * 67;
+acc += Math.sin(18886) + Math.cos(18887) * 68;
+acc += Math.sin(18887) + Math.cos(18888) * 69;
+acc += Math.sin(18888) + Math.cos(18889) * 70;
+acc += Math.sin(18889) + Math.cos(18890) * 71;
+acc += Math.sin(18890) + Math.cos(18891) * 72;
+acc += Math.sin(18891) + Math.cos(18892) * 73;
+acc += Math.sin(18892) + Math.cos(18893) * 74;
+acc += Math.sin(18893) + Math.cos(18894) * 75;
+acc += Math.sin(18894) + Math.cos(18895) * 76;
+acc += Math.sin(18895) + Math.cos(18896) * 77;
+acc += Math.sin(18896) + Math.cos(18897) * 78;
+acc += Math.sin(18897) + Math.cos(18898) * 79;
+acc += Math.sin(18898) + Math.cos(18899) * 80;
+acc += Math.sin(18899) + Math.cos(18900) * 81;
+acc += Math.sin(18900) + Math.cos(18901) * 82;
+acc += Math.sin(18901) + Math.cos(18902) * 83;
+acc += Math.sin(18902) + Math.cos(18903) * 84;
+acc += Math.sin(18903) + Math.cos(18904) * 85;
+acc += Math.sin(18904) + Math.cos(18905) * 86;
+acc += Math.sin(18905) + Math.cos(18906) * 87;
+acc += Math.sin(18906) + Math.cos(18907) * 88;
+acc += Math.sin(18907) + Math.cos(18908) * 89;
+acc += Math.sin(18908) + Math.cos(18909) * 90;
+acc += Math.sin(18909) + Math.cos(18910) * 91;
+acc += Math.sin(18910) + Math.cos(18911) * 92;
+acc += Math.sin(18911) + Math.cos(18912) * 93;
+acc += Math.sin(18912) + Math.cos(18913) * 94;
+acc += Math.sin(18913) + Math.cos(18914) * 95;
+acc += Math.sin(18914) + Math.cos(18915) * 96;
+acc += Math.sin(18915) + Math.cos(18916) * 0;
+acc += Math.sin(18916) + Math.cos(18917) * 1;
+acc += Math.sin(18917) + Math.cos(18918) * 2;
+acc += Math.sin(18918) + Math.cos(18919) * 3;
+acc += Math.sin(18919) + Math.cos(18920) * 4;
+acc += Math.sin(18920) + Math.cos(18921) * 5;
+acc += Math.sin(18921) + Math.cos(18922) * 6;
+acc += Math.sin(18922) + Math.cos(18923) * 7;
+acc += Math.sin(18923) + Math.cos(18924) * 8;
+acc += Math.sin(18924) + Math.cos(18925) * 9;
+acc += Math.sin(18925) + Math.cos(18926) * 10;
+acc += Math.sin(18926) + Math.cos(18927) * 11;
+acc += Math.sin(18927) + Math.cos(18928) * 12;
+acc += Math.sin(18928) + Math.cos(18929) * 13;
+acc += Math.sin(18929) + Math.cos(18930) * 14;
+acc += Math.sin(18930) + Math.cos(18931) * 15;
+acc += Math.sin(18931) + Math.cos(18932) * 16;
+acc += Math.sin(18932) + Math.cos(18933) * 17;
+acc += Math.sin(18933) + Math.cos(18934) * 18;
+acc += Math.sin(18934) + Math.cos(18935) * 19;
+acc += Math.sin(18935) + Math.cos(18936) * 20;
+acc += Math.sin(18936) + Math.cos(18937) * 21;
+acc += Math.sin(18937) + Math.cos(18938) * 22;
+acc += Math.sin(18938) + Math.cos(18939) * 23;
+acc += Math.sin(18939) + Math.cos(18940) * 24;
+acc += Math.sin(18940) + Math.cos(18941) * 25;
+acc += Math.sin(18941) + Math.cos(18942) * 26;
+acc += Math.sin(18942) + Math.cos(18943) * 27;
+acc += Math.sin(18943) + Math.cos(18944) * 28;
+acc += Math.sin(18944) + Math.cos(18945) * 29;
+acc += Math.sin(18945) + Math.cos(18946) * 30;
+acc += Math.sin(18946) + Math.cos(18947) * 31;
+acc += Math.sin(18947) + Math.cos(18948) * 32;
+acc += Math.sin(18948) + Math.cos(18949) * 33;
+acc += Math.sin(18949) + Math.cos(18950) * 34;
+acc += Math.sin(18950) + Math.cos(18951) * 35;
+acc += Math.sin(18951) + Math.cos(18952) * 36;
+acc += Math.sin(18952) + Math.cos(18953) * 37;
+acc += Math.sin(18953) + Math.cos(18954) * 38;
+acc += Math.sin(18954) + Math.cos(18955) * 39;
+acc += Math.sin(18955) + Math.cos(18956) * 40;
+acc += Math.sin(18956) + Math.cos(18957) * 41;
+acc += Math.sin(18957) + Math.cos(18958) * 42;
+acc += Math.sin(18958) + Math.cos(18959) * 43;
+acc += Math.sin(18959) + Math.cos(18960) * 44;
+acc += Math.sin(18960) + Math.cos(18961) * 45;
+acc += Math.sin(18961) + Math.cos(18962) * 46;
+acc += Math.sin(18962) + Math.cos(18963) * 47;
+acc += Math.sin(18963) + Math.cos(18964) * 48;
+acc += Math.sin(18964) + Math.cos(18965) * 49;
+acc += Math.sin(18965) + Math.cos(18966) * 50;
+acc += Math.sin(18966) + Math.cos(18967) * 51;
+acc += Math.sin(18967) + Math.cos(18968) * 52;
+acc += Math.sin(18968) + Math.cos(18969) * 53;
+acc += Math.sin(18969) + Math.cos(18970) * 54;
+acc += Math.sin(18970) + Math.cos(18971) * 55;
+acc += Math.sin(18971) + Math.cos(18972) * 56;
+acc += Math.sin(18972) + Math.cos(18973) * 57;
+acc += Math.sin(18973) + Math.cos(18974) * 58;
+acc += Math.sin(18974) + Math.cos(18975) * 59;
+acc += Math.sin(18975) + Math.cos(18976) * 60;
+acc += Math.sin(18976) + Math.cos(18977) * 61;
+acc += Math.sin(18977) + Math.cos(18978) * 62;
+acc += Math.sin(18978) + Math.cos(18979) * 63;
+acc += Math.sin(18979) + Math.cos(18980) * 64;
+acc += Math.sin(18980) + Math.cos(18981) * 65;
+acc += Math.sin(18981) + Math.cos(18982) * 66;
+acc += Math.sin(18982) + Math.cos(18983) * 67;
+acc += Math.sin(18983) + Math.cos(18984) * 68;
+acc += Math.sin(18984) + Math.cos(18985) * 69;
+acc += Math.sin(18985) + Math.cos(18986) * 70;
+acc += Math.sin(18986) + Math.cos(18987) * 71;
+acc += Math.sin(18987) + Math.cos(18988) * 72;
+acc += Math.sin(18988) + Math.cos(18989) * 73;
+acc += Math.sin(18989) + Math.cos(18990) * 74;
+acc += Math.sin(18990) + Math.cos(18991) * 75;
+acc += Math.sin(18991) + Math.cos(18992) * 76;
+acc += Math.sin(18992) + Math.cos(18993) * 77;
+acc += Math.sin(18993) + Math.cos(18994) * 78;
+acc += Math.sin(18994) + Math.cos(18995) * 79;
+acc += Math.sin(18995) + Math.cos(18996) * 80;
+acc += Math.sin(18996) + Math.cos(18997) * 81;
+acc += Math.sin(18997) + Math.cos(18998) * 82;
+acc += Math.sin(18998) + Math.cos(18999) * 83;
+acc += Math.sin(18999) + Math.cos(19000) * 84;
+acc += Math.sin(19000) + Math.cos(19001) * 85;
+acc += Math.sin(19001) + Math.cos(19002) * 86;
+acc += Math.sin(19002) + Math.cos(19003) * 87;
+acc += Math.sin(19003) + Math.cos(19004) * 88;
+acc += Math.sin(19004) + Math.cos(19005) * 89;
+acc += Math.sin(19005) + Math.cos(19006) * 90;
+acc += Math.sin(19006) + Math.cos(19007) * 91;
+acc += Math.sin(19007) + Math.cos(19008) * 92;
+acc += Math.sin(19008) + Math.cos(19009) * 93;
+acc += Math.sin(19009) + Math.cos(19010) * 94;
+acc += Math.sin(19010) + Math.cos(19011) * 95;
+acc += Math.sin(19011) + Math.cos(19012) * 96;
+acc += Math.sin(19012) + Math.cos(19013) * 0;
+acc += Math.sin(19013) + Math.cos(19014) * 1;
+acc += Math.sin(19014) + Math.cos(19015) * 2;
+acc += Math.sin(19015) + Math.cos(19016) * 3;
+acc += Math.sin(19016) + Math.cos(19017) * 4;
+acc += Math.sin(19017) + Math.cos(19018) * 5;
+acc += Math.sin(19018) + Math.cos(19019) * 6;
+acc += Math.sin(19019) + Math.cos(19020) * 7;
+acc += Math.sin(19020) + Math.cos(19021) * 8;
+acc += Math.sin(19021) + Math.cos(19022) * 9;
+acc += Math.sin(19022) + Math.cos(19023) * 10;
+acc += Math.sin(19023) + Math.cos(19024) * 11;
+acc += Math.sin(19024) + Math.cos(19025) * 12;
+acc += Math.sin(19025) + Math.cos(19026) * 13;
+acc += Math.sin(19026) + Math.cos(19027) * 14;
+acc += Math.sin(19027) + Math.cos(19028) * 15;
+acc += Math.sin(19028) + Math.cos(19029) * 16;
+acc += Math.sin(19029) + Math.cos(19030) * 17;
+acc += Math.sin(19030) + Math.cos(19031) * 18;
+acc += Math.sin(19031) + Math.cos(19032) * 19;
+acc += Math.sin(19032) + Math.cos(19033) * 20;
+acc += Math.sin(19033) + Math.cos(19034) * 21;
+acc += Math.sin(19034) + Math.cos(19035) * 22;
+acc += Math.sin(19035) + Math.cos(19036) * 23;
+acc += Math.sin(19036) + Math.cos(19037) * 24;
+acc += Math.sin(19037) + Math.cos(19038) * 25;
+acc += Math.sin(19038) + Math.cos(19039) * 26;
+acc += Math.sin(19039) + Math.cos(19040) * 27;
+acc += Math.sin(19040) + Math.cos(19041) * 28;
+acc += Math.sin(19041) + Math.cos(19042) * 29;
+acc += Math.sin(19042) + Math.cos(19043) * 30;
+acc += Math.sin(19043) + Math.cos(19044) * 31;
+acc += Math.sin(19044) + Math.cos(19045) * 32;
+acc += Math.sin(19045) + Math.cos(19046) * 33;
+acc += Math.sin(19046) + Math.cos(19047) * 34;
+acc += Math.sin(19047) + Math.cos(19048) * 35;
+acc += Math.sin(19048) + Math.cos(19049) * 36;
+acc += Math.sin(19049) + Math.cos(19050) * 37;
+acc += Math.sin(19050) + Math.cos(19051) * 38;
+acc += Math.sin(19051) + Math.cos(19052) * 39;
+acc += Math.sin(19052) + Math.cos(19053) * 40;
+acc += Math.sin(19053) + Math.cos(19054) * 41;
+acc += Math.sin(19054) + Math.cos(19055) * 42;
+acc += Math.sin(19055) + Math.cos(19056) * 43;
+acc += Math.sin(19056) + Math.cos(19057) * 44;
+acc += Math.sin(19057) + Math.cos(19058) * 45;
+acc += Math.sin(19058) + Math.cos(19059) * 46;
+acc += Math.sin(19059) + Math.cos(19060) * 47;
+acc += Math.sin(19060) + Math.cos(19061) * 48;
+acc += Math.sin(19061) + Math.cos(19062) * 49;
+acc += Math.sin(19062) + Math.cos(19063) * 50;
+acc += Math.sin(19063) + Math.cos(19064) * 51;
+acc += Math.sin(19064) + Math.cos(19065) * 52;
+acc += Math.sin(19065) + Math.cos(19066) * 53;
+acc += Math.sin(19066) + Math.cos(19067) * 54;
+acc += Math.sin(19067) + Math.cos(19068) * 55;
+acc += Math.sin(19068) + Math.cos(19069) * 56;
+acc += Math.sin(19069) + Math.cos(19070) * 57;
+acc += Math.sin(19070) + Math.cos(19071) * 58;
+acc += Math.sin(19071) + Math.cos(19072) * 59;
+acc += Math.sin(19072) + Math.cos(19073) * 60;
+acc += Math.sin(19073) + Math.cos(19074) * 61;
+acc += Math.sin(19074) + Math.cos(19075) * 62;
+acc += Math.sin(19075) + Math.cos(19076) * 63;
+acc += Math.sin(19076) + Math.cos(19077) * 64;
+acc += Math.sin(19077) + Math.cos(19078) * 65;
+acc += Math.sin(19078) + Math.cos(19079) * 66;
+acc += Math.sin(19079) + Math.cos(19080) * 67;
+acc += Math.sin(19080) + Math.cos(19081) * 68;
+acc += Math.sin(19081) + Math.cos(19082) * 69;
+acc += Math.sin(19082) + Math.cos(19083) * 70;
+acc += Math.sin(19083) + Math.cos(19084) * 71;
+acc += Math.sin(19084) + Math.cos(19085) * 72;
+acc += Math.sin(19085) + Math.cos(19086) * 73;
+acc += Math.sin(19086) + Math.cos(19087) * 74;
+acc += Math.sin(19087) + Math.cos(19088) * 75;
+acc += Math.sin(19088) + Math.cos(19089) * 76;
+acc += Math.sin(19089) + Math.cos(19090) * 77;
+acc += Math.sin(19090) + Math.cos(19091) * 78;
+acc += Math.sin(19091) + Math.cos(19092) * 79;
+acc += Math.sin(19092) + Math.cos(19093) * 80;
+acc += Math.sin(19093) + Math.cos(19094) * 81;
+acc += Math.sin(19094) + Math.cos(19095) * 82;
+acc += Math.sin(19095) + Math.cos(19096) * 83;
+acc += Math.sin(19096) + Math.cos(19097) * 84;
+acc += Math.sin(19097) + Math.cos(19098) * 85;
+acc += Math.sin(19098) + Math.cos(19099) * 86;
+acc += Math.sin(19099) + Math.cos(19100) * 87;
+acc += Math.sin(19100) + Math.cos(19101) * 88;
+acc += Math.sin(19101) + Math.cos(19102) * 89;
+acc += Math.sin(19102) + Math.cos(19103) * 90;
+acc += Math.sin(19103) + Math.cos(19104) * 91;
+acc += Math.sin(19104) + Math.cos(19105) * 92;
+acc += Math.sin(19105) + Math.cos(19106) * 93;
+acc += Math.sin(19106) + Math.cos(19107) * 94;
+acc += Math.sin(19107) + Math.cos(19108) * 95;
+acc += Math.sin(19108) + Math.cos(19109) * 96;
+acc += Math.sin(19109) + Math.cos(19110) * 0;
+acc += Math.sin(19110) + Math.cos(19111) * 1;
+acc += Math.sin(19111) + Math.cos(19112) * 2;
+acc += Math.sin(19112) + Math.cos(19113) * 3;
+acc += Math.sin(19113) + Math.cos(19114) * 4;
+acc += Math.sin(19114) + Math.cos(19115) * 5;
+acc += Math.sin(19115) + Math.cos(19116) * 6;
+acc += Math.sin(19116) + Math.cos(19117) * 7;
+acc += Math.sin(19117) + Math.cos(19118) * 8;
+acc += Math.sin(19118) + Math.cos(19119) * 9;
+acc += Math.sin(19119) + Math.cos(19120) * 10;
+acc += Math.sin(19120) + Math.cos(19121) * 11;
+acc += Math.sin(19121) + Math.cos(19122) * 12;
+acc += Math.sin(19122) + Math.cos(19123) * 13;
+acc += Math.sin(19123) + Math.cos(19124) * 14;
+acc += Math.sin(19124) + Math.cos(19125) * 15;
+acc += Math.sin(19125) + Math.cos(19126) * 16;
+acc += Math.sin(19126) + Math.cos(19127) * 17;
+acc += Math.sin(19127) + Math.cos(19128) * 18;
+acc += Math.sin(19128) + Math.cos(19129) * 19;
+acc += Math.sin(19129) + Math.cos(19130) * 20;
+acc += Math.sin(19130) + Math.cos(19131) * 21;
+acc += Math.sin(19131) + Math.cos(19132) * 22;
+acc += Math.sin(19132) + Math.cos(19133) * 23;
+acc += Math.sin(19133) + Math.cos(19134) * 24;
+acc += Math.sin(19134) + Math.cos(19135) * 25;
+acc += Math.sin(19135) + Math.cos(19136) * 26;
+acc += Math.sin(19136) + Math.cos(19137) * 27;
+acc += Math.sin(19137) + Math.cos(19138) * 28;
+acc += Math.sin(19138) + Math.cos(19139) * 29;
+acc += Math.sin(19139) + Math.cos(19140) * 30;
+acc += Math.sin(19140) + Math.cos(19141) * 31;
+acc += Math.sin(19141) + Math.cos(19142) * 32;
+acc += Math.sin(19142) + Math.cos(19143) * 33;
+acc += Math.sin(19143) + Math.cos(19144) * 34;
+acc += Math.sin(19144) + Math.cos(19145) * 35;
+acc += Math.sin(19145) + Math.cos(19146) * 36;
+acc += Math.sin(19146) + Math.cos(19147) * 37;
+acc += Math.sin(19147) + Math.cos(19148) * 38;
+acc += Math.sin(19148) + Math.cos(19149) * 39;
+acc += Math.sin(19149) + Math.cos(19150) * 40;
+acc += Math.sin(19150) + Math.cos(19151) * 41;
+acc += Math.sin(19151) + Math.cos(19152) * 42;
+acc += Math.sin(19152) + Math.cos(19153) * 43;
+acc += Math.sin(19153) + Math.cos(19154) * 44;
+acc += Math.sin(19154) + Math.cos(19155) * 45;
+acc += Math.sin(19155) + Math.cos(19156) * 46;
+acc += Math.sin(19156) + Math.cos(19157) * 47;
+acc += Math.sin(19157) + Math.cos(19158) * 48;
+acc += Math.sin(19158) + Math.cos(19159) * 49;
+acc += Math.sin(19159) + Math.cos(19160) * 50;
+acc += Math.sin(19160) + Math.cos(19161) * 51;
+acc += Math.sin(19161) + Math.cos(19162) * 52;
+acc += Math.sin(19162) + Math.cos(19163) * 53;
+acc += Math.sin(19163) + Math.cos(19164) * 54;
+acc += Math.sin(19164) + Math.cos(19165) * 55;
+acc += Math.sin(19165) + Math.cos(19166) * 56;
+acc += Math.sin(19166) + Math.cos(19167) * 57;
+acc += Math.sin(19167) + Math.cos(19168) * 58;
+acc += Math.sin(19168) + Math.cos(19169) * 59;
+acc += Math.sin(19169) + Math.cos(19170) * 60;
+acc += Math.sin(19170) + Math.cos(19171) * 61;
+acc += Math.sin(19171) + Math.cos(19172) * 62;
+acc += Math.sin(19172) + Math.cos(19173) * 63;
+acc += Math.sin(19173) + Math.cos(19174) * 64;
+acc += Math.sin(19174) + Math.cos(19175) * 65;
+acc += Math.sin(19175) + Math.cos(19176) * 66;
+acc += Math.sin(19176) + Math.cos(19177) * 67;
+acc += Math.sin(19177) + Math.cos(19178) * 68;
+acc += Math.sin(19178) + Math.cos(19179) * 69;
+acc += Math.sin(19179) + Math.cos(19180) * 70;
+acc += Math.sin(19180) + Math.cos(19181) * 71;
+acc += Math.sin(19181) + Math.cos(19182) * 72;
+acc += Math.sin(19182) + Math.cos(19183) * 73;
+acc += Math.sin(19183) + Math.cos(19184) * 74;
+acc += Math.sin(19184) + Math.cos(19185) * 75;
+acc += Math.sin(19185) + Math.cos(19186) * 76;
+acc += Math.sin(19186) + Math.cos(19187) * 77;
+acc += Math.sin(19187) + Math.cos(19188) * 78;
+acc += Math.sin(19188) + Math.cos(19189) * 79;
+acc += Math.sin(19189) + Math.cos(19190) * 80;
+acc += Math.sin(19190) + Math.cos(19191) * 81;
+acc += Math.sin(19191) + Math.cos(19192) * 82;
+acc += Math.sin(19192) + Math.cos(19193) * 83;
+acc += Math.sin(19193) + Math.cos(19194) * 84;
+acc += Math.sin(19194) + Math.cos(19195) * 85;
+acc += Math.sin(19195) + Math.cos(19196) * 86;
+acc += Math.sin(19196) + Math.cos(19197) * 87;
+acc += Math.sin(19197) + Math.cos(19198) * 88;
+acc += Math.sin(19198) + Math.cos(19199) * 89;
+acc += Math.sin(19199) + Math.cos(19200) * 90;
+acc += Math.sin(19200) + Math.cos(19201) * 91;
+acc += Math.sin(19201) + Math.cos(19202) * 92;
+acc += Math.sin(19202) + Math.cos(19203) * 93;
+acc += Math.sin(19203) + Math.cos(19204) * 94;
+acc += Math.sin(19204) + Math.cos(19205) * 95;
+acc += Math.sin(19205) + Math.cos(19206) * 96;
+acc += Math.sin(19206) + Math.cos(19207) * 0;
+acc += Math.sin(19207) + Math.cos(19208) * 1;
+acc += Math.sin(19208) + Math.cos(19209) * 2;
+acc += Math.sin(19209) + Math.cos(19210) * 3;
+acc += Math.sin(19210) + Math.cos(19211) * 4;
+acc += Math.sin(19211) + Math.cos(19212) * 5;
+acc += Math.sin(19212) + Math.cos(19213) * 6;
+acc += Math.sin(19213) + Math.cos(19214) * 7;
+acc += Math.sin(19214) + Math.cos(19215) * 8;
+acc += Math.sin(19215) + Math.cos(19216) * 9;
+acc += Math.sin(19216) + Math.cos(19217) * 10;
+acc += Math.sin(19217) + Math.cos(19218) * 11;
+acc += Math.sin(19218) + Math.cos(19219) * 12;
+acc += Math.sin(19219) + Math.cos(19220) * 13;
+acc += Math.sin(19220) + Math.cos(19221) * 14;
+acc += Math.sin(19221) + Math.cos(19222) * 15;
+acc += Math.sin(19222) + Math.cos(19223) * 16;
+acc += Math.sin(19223) + Math.cos(19224) * 17;
+acc += Math.sin(19224) + Math.cos(19225) * 18;
+acc += Math.sin(19225) + Math.cos(19226) * 19;
+acc += Math.sin(19226) + Math.cos(19227) * 20;
+acc += Math.sin(19227) + Math.cos(19228) * 21;
+acc += Math.sin(19228) + Math.cos(19229) * 22;
+acc += Math.sin(19229) + Math.cos(19230) * 23;
+acc += Math.sin(19230) + Math.cos(19231) * 24;
+acc += Math.sin(19231) + Math.cos(19232) * 25;
+acc += Math.sin(19232) + Math.cos(19233) * 26;
+acc += Math.sin(19233) + Math.cos(19234) * 27;
+acc += Math.sin(19234) + Math.cos(19235) * 28;
+acc += Math.sin(19235) + Math.cos(19236) * 29;
+acc += Math.sin(19236) + Math.cos(19237) * 30;
+acc += Math.sin(19237) + Math.cos(19238) * 31;
+acc += Math.sin(19238) + Math.cos(19239) * 32;
+acc += Math.sin(19239) + Math.cos(19240) * 33;
+acc += Math.sin(19240) + Math.cos(19241) * 34;
+acc += Math.sin(19241) + Math.cos(19242) * 35;
+acc += Math.sin(19242) + Math.cos(19243) * 36;
+acc += Math.sin(19243) + Math.cos(19244) * 37;
+acc += Math.sin(19244) + Math.cos(19245) * 38;
+acc += Math.sin(19245) + Math.cos(19246) * 39;
+acc += Math.sin(19246) + Math.cos(19247) * 40;
+acc += Math.sin(19247) + Math.cos(19248) * 41;
+acc += Math.sin(19248) + Math.cos(19249) * 42;
+acc += Math.sin(19249) + Math.cos(19250) * 43;
+acc += Math.sin(19250) + Math.cos(19251) * 44;
+acc += Math.sin(19251) + Math.cos(19252) * 45;
+acc += Math.sin(19252) + Math.cos(19253) * 46;
+acc += Math.sin(19253) + Math.cos(19254) * 47;
+acc += Math.sin(19254) + Math.cos(19255) * 48;
+acc += Math.sin(19255) + Math.cos(19256) * 49;
+acc += Math.sin(19256) + Math.cos(19257) * 50;
+acc += Math.sin(19257) + Math.cos(19258) * 51;
+acc += Math.sin(19258) + Math.cos(19259) * 52;
+acc += Math.sin(19259) + Math.cos(19260) * 53;
+acc += Math.sin(19260) + Math.cos(19261) * 54;
+acc += Math.sin(19261) + Math.cos(19262) * 55;
+acc += Math.sin(19262) + Math.cos(19263) * 56;
+acc += Math.sin(19263) + Math.cos(19264) * 57;
+acc += Math.sin(19264) + Math.cos(19265) * 58;
+acc += Math.sin(19265) + Math.cos(19266) * 59;
+acc += Math.sin(19266) + Math.cos(19267) * 60;
+acc += Math.sin(19267) + Math.cos(19268) * 61;
+acc += Math.sin(19268) + Math.cos(19269) * 62;
+acc += Math.sin(19269) + Math.cos(19270) * 63;
+acc += Math.sin(19270) + Math.cos(19271) * 64;
+acc += Math.sin(19271) + Math.cos(19272) * 65;
+acc += Math.sin(19272) + Math.cos(19273) * 66;
+acc += Math.sin(19273) + Math.cos(19274) * 67;
+acc += Math.sin(19274) + Math.cos(19275) * 68;
+acc += Math.sin(19275) + Math.cos(19276) * 69;
+acc += Math.sin(19276) + Math.cos(19277) * 70;
+acc += Math.sin(19277) + Math.cos(19278) * 71;
+acc += Math.sin(19278) + Math.cos(19279) * 72;
+acc += Math.sin(19279) + Math.cos(19280) * 73;
+acc += Math.sin(19280) + Math.cos(19281) * 74;
+acc += Math.sin(19281) + Math.cos(19282) * 75;
+acc += Math.sin(19282) + Math.cos(19283) * 76;
+acc += Math.sin(19283) + Math.cos(19284) * 77;
+acc += Math.sin(19284) + Math.cos(19285) * 78;
+acc += Math.sin(19285) + Math.cos(19286) * 79;
+acc += Math.sin(19286) + Math.cos(19287) * 80;
+acc += Math.sin(19287) + Math.cos(19288) * 81;
+acc += Math.sin(19288) + Math.cos(19289) * 82;
+acc += Math.sin(19289) + Math.cos(19290) * 83;
+acc += Math.sin(19290) + Math.cos(19291) * 84;
+acc += Math.sin(19291) + Math.cos(19292) * 85;
+acc += Math.sin(19292) + Math.cos(19293) * 86;
+acc += Math.sin(19293) + Math.cos(19294) * 87;
+acc += Math.sin(19294) + Math.cos(19295) * 88;
+acc += Math.sin(19295) + Math.cos(19296) * 89;
+acc += Math.sin(19296) + Math.cos(19297) * 90;
+acc += Math.sin(19297) + Math.cos(19298) * 91;
+acc += Math.sin(19298) + Math.cos(19299) * 92;
+acc += Math.sin(19299) + Math.cos(19300) * 93;
+acc += Math.sin(19300) + Math.cos(19301) * 94;
+acc += Math.sin(19301) + Math.cos(19302) * 95;
+acc += Math.sin(19302) + Math.cos(19303) * 96;
+acc += Math.sin(19303) + Math.cos(19304) * 0;
+acc += Math.sin(19304) + Math.cos(19305) * 1;
+acc += Math.sin(19305) + Math.cos(19306) * 2;
+acc += Math.sin(19306) + Math.cos(19307) * 3;
+acc += Math.sin(19307) + Math.cos(19308) * 4;
+acc += Math.sin(19308) + Math.cos(19309) * 5;
+acc += Math.sin(19309) + Math.cos(19310) * 6;
+acc += Math.sin(19310) + Math.cos(19311) * 7;
+acc += Math.sin(19311) + Math.cos(19312) * 8;
+acc += Math.sin(19312) + Math.cos(19313) * 9;
+acc += Math.sin(19313) + Math.cos(19314) * 10;
+acc += Math.sin(19314) + Math.cos(19315) * 11;
+acc += Math.sin(19315) + Math.cos(19316) * 12;
+acc += Math.sin(19316) + Math.cos(19317) * 13;
+acc += Math.sin(19317) + Math.cos(19318) * 14;
+acc += Math.sin(19318) + Math.cos(19319) * 15;
+acc += Math.sin(19319) + Math.cos(19320) * 16;
+acc += Math.sin(19320) + Math.cos(19321) * 17;
+acc += Math.sin(19321) + Math.cos(19322) * 18;
+acc += Math.sin(19322) + Math.cos(19323) * 19;
+acc += Math.sin(19323) + Math.cos(19324) * 20;
+acc += Math.sin(19324) + Math.cos(19325) * 21;
+acc += Math.sin(19325) + Math.cos(19326) * 22;
+acc += Math.sin(19326) + Math.cos(19327) * 23;
+acc += Math.sin(19327) + Math.cos(19328) * 24;
+acc += Math.sin(19328) + Math.cos(19329) * 25;
+acc += Math.sin(19329) + Math.cos(19330) * 26;
+acc += Math.sin(19330) + Math.cos(19331) * 27;
+acc += Math.sin(19331) + Math.cos(19332) * 28;
+acc += Math.sin(19332) + Math.cos(19333) * 29;
+acc += Math.sin(19333) + Math.cos(19334) * 30;
+acc += Math.sin(19334) + Math.cos(19335) * 31;
+acc += Math.sin(19335) + Math.cos(19336) * 32;
+acc += Math.sin(19336) + Math.cos(19337) * 33;
+acc += Math.sin(19337) + Math.cos(19338) * 34;
+acc += Math.sin(19338) + Math.cos(19339) * 35;
+acc += Math.sin(19339) + Math.cos(19340) * 36;
+acc += Math.sin(19340) + Math.cos(19341) * 37;
+acc += Math.sin(19341) + Math.cos(19342) * 38;
+acc += Math.sin(19342) + Math.cos(19343) * 39;
+acc += Math.sin(19343) + Math.cos(19344) * 40;
+acc += Math.sin(19344) + Math.cos(19345) * 41;
+acc += Math.sin(19345) + Math.cos(19346) * 42;
+acc += Math.sin(19346) + Math.cos(19347) * 43;
+acc += Math.sin(19347) + Math.cos(19348) * 44;
+acc += Math.sin(19348) + Math.cos(19349) * 45;
+acc += Math.sin(19349) + Math.cos(19350) * 46;
+acc += Math.sin(19350) + Math.cos(19351) * 47;
+acc += Math.sin(19351) + Math.cos(19352) * 48;
+acc += Math.sin(19352) + Math.cos(19353) * 49;
+acc += Math.sin(19353) + Math.cos(19354) * 50;
+acc += Math.sin(19354) + Math.cos(19355) * 51;
+acc += Math.sin(19355) + Math.cos(19356) * 52;
+acc += Math.sin(19356) + Math.cos(19357) * 53;
+acc += Math.sin(19357) + Math.cos(19358) * 54;
+acc += Math.sin(19358) + Math.cos(19359) * 55;
+acc += Math.sin(19359) + Math.cos(19360) * 56;
+acc += Math.sin(19360) + Math.cos(19361) * 57;
+acc += Math.sin(19361) + Math.cos(19362) * 58;
+acc += Math.sin(19362) + Math.cos(19363) * 59;
+acc += Math.sin(19363) + Math.cos(19364) * 60;
+acc += Math.sin(19364) + Math.cos(19365) * 61;
+acc += Math.sin(19365) + Math.cos(19366) * 62;
+acc += Math.sin(19366) + Math.cos(19367) * 63;
+acc += Math.sin(19367) + Math.cos(19368) * 64;
+acc += Math.sin(19368) + Math.cos(19369) * 65;
+acc += Math.sin(19369) + Math.cos(19370) * 66;
+acc += Math.sin(19370) + Math.cos(19371) * 67;
+acc += Math.sin(19371) + Math.cos(19372) * 68;
+acc += Math.sin(19372) + Math.cos(19373) * 69;
+acc += Math.sin(19373) + Math.cos(19374) * 70;
+acc += Math.sin(19374) + Math.cos(19375) * 71;
+acc += Math.sin(19375) + Math.cos(19376) * 72;
+acc += Math.sin(19376) + Math.cos(19377) * 73;
+acc += Math.sin(19377) + Math.cos(19378) * 74;
+acc += Math.sin(19378) + Math.cos(19379) * 75;
+acc += Math.sin(19379) + Math.cos(19380) * 76;
+acc += Math.sin(19380) + Math.cos(19381) * 77;
+acc += Math.sin(19381) + Math.cos(19382) * 78;
+acc += Math.sin(19382) + Math.cos(19383) * 79;
+acc += Math.sin(19383) + Math.cos(19384) * 80;
+acc += Math.sin(19384) + Math.cos(19385) * 81;
+acc += Math.sin(19385) + Math.cos(19386) * 82;
+acc += Math.sin(19386) + Math.cos(19387) * 83;
+acc += Math.sin(19387) + Math.cos(19388) * 84;
+acc += Math.sin(19388) + Math.cos(19389) * 85;
+acc += Math.sin(19389) + Math.cos(19390) * 86;
+acc += Math.sin(19390) + Math.cos(19391) * 87;
+acc += Math.sin(19391) + Math.cos(19392) * 88;
+acc += Math.sin(19392) + Math.cos(19393) * 89;
+acc += Math.sin(19393) + Math.cos(19394) * 90;
+acc += Math.sin(19394) + Math.cos(19395) * 91;
+acc += Math.sin(19395) + Math.cos(19396) * 92;
+acc += Math.sin(19396) + Math.cos(19397) * 93;
+acc += Math.sin(19397) + Math.cos(19398) * 94;
+acc += Math.sin(19398) + Math.cos(19399) * 95;
+acc += Math.sin(19399) + Math.cos(19400) * 96;
+acc += Math.sin(19400) + Math.cos(19401) * 0;
+acc += Math.sin(19401) + Math.cos(19402) * 1;
+acc += Math.sin(19402) + Math.cos(19403) * 2;
+acc += Math.sin(19403) + Math.cos(19404) * 3;
+acc += Math.sin(19404) + Math.cos(19405) * 4;
+acc += Math.sin(19405) + Math.cos(19406) * 5;
+acc += Math.sin(19406) + Math.cos(19407) * 6;
+acc += Math.sin(19407) + Math.cos(19408) * 7;
+acc += Math.sin(19408) + Math.cos(19409) * 8;
+acc += Math.sin(19409) + Math.cos(19410) * 9;
+acc += Math.sin(19410) + Math.cos(19411) * 10;
+acc += Math.sin(19411) + Math.cos(19412) * 11;
+acc += Math.sin(19412) + Math.cos(19413) * 12;
+acc += Math.sin(19413) + Math.cos(19414) * 13;
+acc += Math.sin(19414) + Math.cos(19415) * 14;
+acc += Math.sin(19415) + Math.cos(19416) * 15;
+acc += Math.sin(19416) + Math.cos(19417) * 16;
+acc += Math.sin(19417) + Math.cos(19418) * 17;
+acc += Math.sin(19418) + Math.cos(19419) * 18;
+acc += Math.sin(19419) + Math.cos(19420) * 19;
+acc += Math.sin(19420) + Math.cos(19421) * 20;
+acc += Math.sin(19421) + Math.cos(19422) * 21;
+acc += Math.sin(19422) + Math.cos(19423) * 22;
+acc += Math.sin(19423) + Math.cos(19424) * 23;
+acc += Math.sin(19424) + Math.cos(19425) * 24;
+acc += Math.sin(19425) + Math.cos(19426) * 25;
+acc += Math.sin(19426) + Math.cos(19427) * 26;
+acc += Math.sin(19427) + Math.cos(19428) * 27;
+acc += Math.sin(19428) + Math.cos(19429) * 28;
+acc += Math.sin(19429) + Math.cos(19430) * 29;
+acc += Math.sin(19430) + Math.cos(19431) * 30;
+acc += Math.sin(19431) + Math.cos(19432) * 31;
+acc += Math.sin(19432) + Math.cos(19433) * 32;
+acc += Math.sin(19433) + Math.cos(19434) * 33;
+acc += Math.sin(19434) + Math.cos(19435) * 34;
+acc += Math.sin(19435) + Math.cos(19436) * 35;
+acc += Math.sin(19436) + Math.cos(19437) * 36;
+acc += Math.sin(19437) + Math.cos(19438) * 37;
+acc += Math.sin(19438) + Math.cos(19439) * 38;
+acc += Math.sin(19439) + Math.cos(19440) * 39;
+acc += Math.sin(19440) + Math.cos(19441) * 40;
+acc += Math.sin(19441) + Math.cos(19442) * 41;
+acc += Math.sin(19442) + Math.cos(19443) * 42;
+acc += Math.sin(19443) + Math.cos(19444) * 43;
+acc += Math.sin(19444) + Math.cos(19445) * 44;
+acc += Math.sin(19445) + Math.cos(19446) * 45;
+acc += Math.sin(19446) + Math.cos(19447) * 46;
+acc += Math.sin(19447) + Math.cos(19448) * 47;
+acc += Math.sin(19448) + Math.cos(19449) * 48;
+acc += Math.sin(19449) + Math.cos(19450) * 49;
+acc += Math.sin(19450) + Math.cos(19451) * 50;
+acc += Math.sin(19451) + Math.cos(19452) * 51;
+acc += Math.sin(19452) + Math.cos(19453) * 52;
+acc += Math.sin(19453) + Math.cos(19454) * 53;
+acc += Math.sin(19454) + Math.cos(19455) * 54;
+acc += Math.sin(19455) + Math.cos(19456) * 55;
+acc += Math.sin(19456) + Math.cos(19457) * 56;
+acc += Math.sin(19457) + Math.cos(19458) * 57;
+acc += Math.sin(19458) + Math.cos(19459) * 58;
+acc += Math.sin(19459) + Math.cos(19460) * 59;
+acc += Math.sin(19460) + Math.cos(19461) * 60;
+acc += Math.sin(19461) + Math.cos(19462) * 61;
+acc += Math.sin(19462) + Math.cos(19463) * 62;
+acc += Math.sin(19463) + Math.cos(19464) * 63;
+acc += Math.sin(19464) + Math.cos(19465) * 64;
+acc += Math.sin(19465) + Math.cos(19466) * 65;
+acc += Math.sin(19466) + Math.cos(19467) * 66;
+acc += Math.sin(19467) + Math.cos(19468) * 67;
+acc += Math.sin(19468) + Math.cos(19469) * 68;
+acc += Math.sin(19469) + Math.cos(19470) * 69;
+acc += Math.sin(19470) + Math.cos(19471) * 70;
+acc += Math.sin(19471) + Math.cos(19472) * 71;
+acc += Math.sin(19472) + Math.cos(19473) * 72;
+acc += Math.sin(19473) + Math.cos(19474) * 73;
+acc += Math.sin(19474) + Math.cos(19475) * 74;
+acc += Math.sin(19475) + Math.cos(19476) * 75;
+acc += Math.sin(19476) + Math.cos(19477) * 76;
+acc += Math.sin(19477) + Math.cos(19478) * 77;
+acc += Math.sin(19478) + Math.cos(19479) * 78;
+acc += Math.sin(19479) + Math.cos(19480) * 79;
+acc += Math.sin(19480) + Math.cos(19481) * 80;
+acc += Math.sin(19481) + Math.cos(19482) * 81;
+acc += Math.sin(19482) + Math.cos(19483) * 82;
+acc += Math.sin(19483) + Math.cos(19484) * 83;
+acc += Math.sin(19484) + Math.cos(19485) * 84;
+acc += Math.sin(19485) + Math.cos(19486) * 85;
+acc += Math.sin(19486) + Math.cos(19487) * 86;
+acc += Math.sin(19487) + Math.cos(19488) * 87;
+acc += Math.sin(19488) + Math.cos(19489) * 88;
+acc += Math.sin(19489) + Math.cos(19490) * 89;
+acc += Math.sin(19490) + Math.cos(19491) * 90;
+acc += Math.sin(19491) + Math.cos(19492) * 91;
+acc += Math.sin(19492) + Math.cos(19493) * 92;
+acc += Math.sin(19493) + Math.cos(19494) * 93;
+acc += Math.sin(19494) + Math.cos(19495) * 94;
+acc += Math.sin(19495) + Math.cos(19496) * 95;
+acc += Math.sin(19496) + Math.cos(19497) * 96;
+acc += Math.sin(19497) + Math.cos(19498) * 0;
+acc += Math.sin(19498) + Math.cos(19499) * 1;
+acc += Math.sin(19499) + Math.cos(19500) * 2;
+acc += Math.sin(19500) + Math.cos(19501) * 3;
+acc += Math.sin(19501) + Math.cos(19502) * 4;
+acc += Math.sin(19502) + Math.cos(19503) * 5;
+acc += Math.sin(19503) + Math.cos(19504) * 6;
+acc += Math.sin(19504) + Math.cos(19505) * 7;
+acc += Math.sin(19505) + Math.cos(19506) * 8;
+acc += Math.sin(19506) + Math.cos(19507) * 9;
+acc += Math.sin(19507) + Math.cos(19508) * 10;
+acc += Math.sin(19508) + Math.cos(19509) * 11;
+acc += Math.sin(19509) + Math.cos(19510) * 12;
+acc += Math.sin(19510) + Math.cos(19511) * 13;
+acc += Math.sin(19511) + Math.cos(19512) * 14;
+acc += Math.sin(19512) + Math.cos(19513) * 15;
+acc += Math.sin(19513) + Math.cos(19514) * 16;
+acc += Math.sin(19514) + Math.cos(19515) * 17;
+acc += Math.sin(19515) + Math.cos(19516) * 18;
+acc += Math.sin(19516) + Math.cos(19517) * 19;
+acc += Math.sin(19517) + Math.cos(19518) * 20;
+acc += Math.sin(19518) + Math.cos(19519) * 21;
+acc += Math.sin(19519) + Math.cos(19520) * 22;
+acc += Math.sin(19520) + Math.cos(19521) * 23;
+acc += Math.sin(19521) + Math.cos(19522) * 24;
+acc += Math.sin(19522) + Math.cos(19523) * 25;
+acc += Math.sin(19523) + Math.cos(19524) * 26;
+acc += Math.sin(19524) + Math.cos(19525) * 27;
+acc += Math.sin(19525) + Math.cos(19526) * 28;
+acc += Math.sin(19526) + Math.cos(19527) * 29;
+acc += Math.sin(19527) + Math.cos(19528) * 30;
+acc += Math.sin(19528) + Math.cos(19529) * 31;
+acc += Math.sin(19529) + Math.cos(19530) * 32;
+acc += Math.sin(19530) + Math.cos(19531) * 33;
+acc += Math.sin(19531) + Math.cos(19532) * 34;
+acc += Math.sin(19532) + Math.cos(19533) * 35;
+acc += Math.sin(19533) + Math.cos(19534) * 36;
+acc += Math.sin(19534) + Math.cos(19535) * 37;
+acc += Math.sin(19535) + Math.cos(19536) * 38;
+acc += Math.sin(19536) + Math.cos(19537) * 39;
+acc += Math.sin(19537) + Math.cos(19538) * 40;
+acc += Math.sin(19538) + Math.cos(19539) * 41;
+acc += Math.sin(19539) + Math.cos(19540) * 42;
+acc += Math.sin(19540) + Math.cos(19541) * 43;
+acc += Math.sin(19541) + Math.cos(19542) * 44;
+acc += Math.sin(19542) + Math.cos(19543) * 45;
+acc += Math.sin(19543) + Math.cos(19544) * 46;
+acc += Math.sin(19544) + Math.cos(19545) * 47;
+acc += Math.sin(19545) + Math.cos(19546) * 48;
+acc += Math.sin(19546) + Math.cos(19547) * 49;
+acc += Math.sin(19547) + Math.cos(19548) * 50;
+acc += Math.sin(19548) + Math.cos(19549) * 51;
+acc += Math.sin(19549) + Math.cos(19550) * 52;
+acc += Math.sin(19550) + Math.cos(19551) * 53;
+acc += Math.sin(19551) + Math.cos(19552) * 54;
+acc += Math.sin(19552) + Math.cos(19553) * 55;
+acc += Math.sin(19553) + Math.cos(19554) * 56;
+acc += Math.sin(19554) + Math.cos(19555) * 57;
+acc += Math.sin(19555) + Math.cos(19556) * 58;
+acc += Math.sin(19556) + Math.cos(19557) * 59;
+acc += Math.sin(19557) + Math.cos(19558) * 60;
+acc += Math.sin(19558) + Math.cos(19559) * 61;
+acc += Math.sin(19559) + Math.cos(19560) * 62;
+acc += Math.sin(19560) + Math.cos(19561) * 63;
+acc += Math.sin(19561) + Math.cos(19562) * 64;
+acc += Math.sin(19562) + Math.cos(19563) * 65;
+acc += Math.sin(19563) + Math.cos(19564) * 66;
+acc += Math.sin(19564) + Math.cos(19565) * 67;
+acc += Math.sin(19565) + Math.cos(19566) * 68;
+acc += Math.sin(19566) + Math.cos(19567) * 69;
+acc += Math.sin(19567) + Math.cos(19568) * 70;
+acc += Math.sin(19568) + Math.cos(19569) * 71;
+acc += Math.sin(19569) + Math.cos(19570) * 72;
+acc += Math.sin(19570) + Math.cos(19571) * 73;
+acc += Math.sin(19571) + Math.cos(19572) * 74;
+acc += Math.sin(19572) + Math.cos(19573) * 75;
+acc += Math.sin(19573) + Math.cos(19574) * 76;
+acc += Math.sin(19574) + Math.cos(19575) * 77;
+acc += Math.sin(19575) + Math.cos(19576) * 78;
+acc += Math.sin(19576) + Math.cos(19577) * 79;
+acc += Math.sin(19577) + Math.cos(19578) * 80;
+acc += Math.sin(19578) + Math.cos(19579) * 81;
+acc += Math.sin(19579) + Math.cos(19580) * 82;
+acc += Math.sin(19580) + Math.cos(19581) * 83;
+acc += Math.sin(19581) + Math.cos(19582) * 84;
+acc += Math.sin(19582) + Math.cos(19583) * 85;
+acc += Math.sin(19583) + Math.cos(19584) * 86;
+acc += Math.sin(19584) + Math.cos(19585) * 87;
+acc += Math.sin(19585) + Math.cos(19586) * 88;
+acc += Math.sin(19586) + Math.cos(19587) * 89;
+acc += Math.sin(19587) + Math.cos(19588) * 90;
+acc += Math.sin(19588) + Math.cos(19589) * 91;
+acc += Math.sin(19589) + Math.cos(19590) * 92;
+acc += Math.sin(19590) + Math.cos(19591) * 93;
+acc += Math.sin(19591) + Math.cos(19592) * 94;
+acc += Math.sin(19592) + Math.cos(19593) * 95;
+acc += Math.sin(19593) + Math.cos(19594) * 96;
+acc += Math.sin(19594) + Math.cos(19595) * 0;
+acc += Math.sin(19595) + Math.cos(19596) * 1;
+acc += Math.sin(19596) + Math.cos(19597) * 2;
+acc += Math.sin(19597) + Math.cos(19598) * 3;
+acc += Math.sin(19598) + Math.cos(19599) * 4;
+acc += Math.sin(19599) + Math.cos(19600) * 5;
+acc += Math.sin(19600) + Math.cos(19601) * 6;
+acc += Math.sin(19601) + Math.cos(19602) * 7;
+acc += Math.sin(19602) + Math.cos(19603) * 8;
+acc += Math.sin(19603) + Math.cos(19604) * 9;
+acc += Math.sin(19604) + Math.cos(19605) * 10;
+acc += Math.sin(19605) + Math.cos(19606) * 11;
+acc += Math.sin(19606) + Math.cos(19607) * 12;
+acc += Math.sin(19607) + Math.cos(19608) * 13;
+acc += Math.sin(19608) + Math.cos(19609) * 14;
+acc += Math.sin(19609) + Math.cos(19610) * 15;
+acc += Math.sin(19610) + Math.cos(19611) * 16;
+acc += Math.sin(19611) + Math.cos(19612) * 17;
+acc += Math.sin(19612) + Math.cos(19613) * 18;
+acc += Math.sin(19613) + Math.cos(19614) * 19;
+acc += Math.sin(19614) + Math.cos(19615) * 20;
+acc += Math.sin(19615) + Math.cos(19616) * 21;
+acc += Math.sin(19616) + Math.cos(19617) * 22;
+acc += Math.sin(19617) + Math.cos(19618) * 23;
+acc += Math.sin(19618) + Math.cos(19619) * 24;
+acc += Math.sin(19619) + Math.cos(19620) * 25;
+acc += Math.sin(19620) + Math.cos(19621) * 26;
+acc += Math.sin(19621) + Math.cos(19622) * 27;
+acc += Math.sin(19622) + Math.cos(19623) * 28;
+acc += Math.sin(19623) + Math.cos(19624) * 29;
+acc += Math.sin(19624) + Math.cos(19625) * 30;
+acc += Math.sin(19625) + Math.cos(19626) * 31;
+acc += Math.sin(19626) + Math.cos(19627) * 32;
+acc += Math.sin(19627) + Math.cos(19628) * 33;
+acc += Math.sin(19628) + Math.cos(19629) * 34;
+acc += Math.sin(19629) + Math.cos(19630) * 35;
+acc += Math.sin(19630) + Math.cos(19631) * 36;
+acc += Math.sin(19631) + Math.cos(19632) * 37;
+acc += Math.sin(19632) + Math.cos(19633) * 38;
+acc += Math.sin(19633) + Math.cos(19634) * 39;
+acc += Math.sin(19634) + Math.cos(19635) * 40;
+acc += Math.sin(19635) + Math.cos(19636) * 41;
+acc += Math.sin(19636) + Math.cos(19637) * 42;
+acc += Math.sin(19637) + Math.cos(19638) * 43;
+acc += Math.sin(19638) + Math.cos(19639) * 44;
+acc += Math.sin(19639) + Math.cos(19640) * 45;
+acc += Math.sin(19640) + Math.cos(19641) * 46;
+acc += Math.sin(19641) + Math.cos(19642) * 47;
+acc += Math.sin(19642) + Math.cos(19643) * 48;
+acc += Math.sin(19643) + Math.cos(19644) * 49;
+acc += Math.sin(19644) + Math.cos(19645) * 50;
+acc += Math.sin(19645) + Math.cos(19646) * 51;
+acc += Math.sin(19646) + Math.cos(19647) * 52;
+acc += Math.sin(19647) + Math.cos(19648) * 53;
+acc += Math.sin(19648) + Math.cos(19649) * 54;
+acc += Math.sin(19649) + Math.cos(19650) * 55;
+acc += Math.sin(19650) + Math.cos(19651) * 56;
+acc += Math.sin(19651) + Math.cos(19652) * 57;
+acc += Math.sin(19652) + Math.cos(19653) * 58;
+acc += Math.sin(19653) + Math.cos(19654) * 59;
+acc += Math.sin(19654) + Math.cos(19655) * 60;
+acc += Math.sin(19655) + Math.cos(19656) * 61;
+acc += Math.sin(19656) + Math.cos(19657) * 62;
+acc += Math.sin(19657) + Math.cos(19658) * 63;
+acc += Math.sin(19658) + Math.cos(19659) * 64;
+acc += Math.sin(19659) + Math.cos(19660) * 65;
+acc += Math.sin(19660) + Math.cos(19661) * 66;
+acc += Math.sin(19661) + Math.cos(19662) * 67;
+acc += Math.sin(19662) + Math.cos(19663) * 68;
+acc += Math.sin(19663) + Math.cos(19664) * 69;
+acc += Math.sin(19664) + Math.cos(19665) * 70;
+acc += Math.sin(19665) + Math.cos(19666) * 71;
+acc += Math.sin(19666) + Math.cos(19667) * 72;
+acc += Math.sin(19667) + Math.cos(19668) * 73;
+acc += Math.sin(19668) + Math.cos(19669) * 74;
+acc += Math.sin(19669) + Math.cos(19670) * 75;
+acc += Math.sin(19670) + Math.cos(19671) * 76;
+acc += Math.sin(19671) + Math.cos(19672) * 77;
+acc += Math.sin(19672) + Math.cos(19673) * 78;
+acc += Math.sin(19673) + Math.cos(19674) * 79;
+acc += Math.sin(19674) + Math.cos(19675) * 80;
+acc += Math.sin(19675) + Math.cos(19676) * 81;
+acc += Math.sin(19676) + Math.cos(19677) * 82;
+acc += Math.sin(19677) + Math.cos(19678) * 83;
+acc += Math.sin(19678) + Math.cos(19679) * 84;
+acc += Math.sin(19679) + Math.cos(19680) * 85;
+acc += Math.sin(19680) + Math.cos(19681) * 86;
+acc += Math.sin(19681) + Math.cos(19682) * 87;
+acc += Math.sin(19682) + Math.cos(19683) * 88;
+acc += Math.sin(19683) + Math.cos(19684) * 89;
+acc += Math.sin(19684) + Math.cos(19685) * 90;
+acc += Math.sin(19685) + Math.cos(19686) * 91;
+acc += Math.sin(19686) + Math.cos(19687) * 92;
+acc += Math.sin(19687) + Math.cos(19688) * 93;
+acc += Math.sin(19688) + Math.cos(19689) * 94;
+acc += Math.sin(19689) + Math.cos(19690) * 95;
+acc += Math.sin(19690) + Math.cos(19691) * 96;
+acc += Math.sin(19691) + Math.cos(19692) * 0;
+acc += Math.sin(19692) + Math.cos(19693) * 1;
+acc += Math.sin(19693) + Math.cos(19694) * 2;
+acc += Math.sin(19694) + Math.cos(19695) * 3;
+acc += Math.sin(19695) + Math.cos(19696) * 4;
+acc += Math.sin(19696) + Math.cos(19697) * 5;
+acc += Math.sin(19697) + Math.cos(19698) * 6;
+acc += Math.sin(19698) + Math.cos(19699) * 7;
+acc += Math.sin(19699) + Math.cos(19700) * 8;
+acc += Math.sin(19700) + Math.cos(19701) * 9;
+acc += Math.sin(19701) + Math.cos(19702) * 10;
+acc += Math.sin(19702) + Math.cos(19703) * 11;
+acc += Math.sin(19703) + Math.cos(19704) * 12;
+acc += Math.sin(19704) + Math.cos(19705) * 13;
+acc += Math.sin(19705) + Math.cos(19706) * 14;
+acc += Math.sin(19706) + Math.cos(19707) * 15;
+acc += Math.sin(19707) + Math.cos(19708) * 16;
+acc += Math.sin(19708) + Math.cos(19709) * 17;
+acc += Math.sin(19709) + Math.cos(19710) * 18;
+acc += Math.sin(19710) + Math.cos(19711) * 19;
+acc += Math.sin(19711) + Math.cos(19712) * 20;
+acc += Math.sin(19712) + Math.cos(19713) * 21;
+acc += Math.sin(19713) + Math.cos(19714) * 22;
+acc += Math.sin(19714) + Math.cos(19715) * 23;
+acc += Math.sin(19715) + Math.cos(19716) * 24;
+acc += Math.sin(19716) + Math.cos(19717) * 25;
+acc += Math.sin(19717) + Math.cos(19718) * 26;
+acc += Math.sin(19718) + Math.cos(19719) * 27;
+acc += Math.sin(19719) + Math.cos(19720) * 28;
+acc += Math.sin(19720) + Math.cos(19721) * 29;
+acc += Math.sin(19721) + Math.cos(19722) * 30;
+acc += Math.sin(19722) + Math.cos(19723) * 31;
+acc += Math.sin(19723) + Math.cos(19724) * 32;
+acc += Math.sin(19724) + Math.cos(19725) * 33;
+acc += Math.sin(19725) + Math.cos(19726) * 34;
+acc += Math.sin(19726) + Math.cos(19727) * 35;
+acc += Math.sin(19727) + Math.cos(19728) * 36;
+acc += Math.sin(19728) + Math.cos(19729) * 37;
+acc += Math.sin(19729) + Math.cos(19730) * 38;
+acc += Math.sin(19730) + Math.cos(19731) * 39;
+acc += Math.sin(19731) + Math.cos(19732) * 40;
+acc += Math.sin(19732) + Math.cos(19733) * 41;
+acc += Math.sin(19733) + Math.cos(19734) * 42;
+acc += Math.sin(19734) + Math.cos(19735) * 43;
+acc += Math.sin(19735) + Math.cos(19736) * 44;
+acc += Math.sin(19736) + Math.cos(19737) * 45;
+acc += Math.sin(19737) + Math.cos(19738) * 46;
+acc += Math.sin(19738) + Math.cos(19739) * 47;
+acc += Math.sin(19739) + Math.cos(19740) * 48;
+acc += Math.sin(19740) + Math.cos(19741) * 49;
+acc += Math.sin(19741) + Math.cos(19742) * 50;
+acc += Math.sin(19742) + Math.cos(19743) * 51;
+acc += Math.sin(19743) + Math.cos(19744) * 52;
+acc += Math.sin(19744) + Math.cos(19745) * 53;
+acc += Math.sin(19745) + Math.cos(19746) * 54;
+acc += Math.sin(19746) + Math.cos(19747) * 55;
+acc += Math.sin(19747) + Math.cos(19748) * 56;
+acc += Math.sin(19748) + Math.cos(19749) * 57;
+acc += Math.sin(19749) + Math.cos(19750) * 58;
+acc += Math.sin(19750) + Math.cos(19751) * 59;
+acc += Math.sin(19751) + Math.cos(19752) * 60;
+acc += Math.sin(19752) + Math.cos(19753) * 61;
+acc += Math.sin(19753) + Math.cos(19754) * 62;
+acc += Math.sin(19754) + Math.cos(19755) * 63;
+acc += Math.sin(19755) + Math.cos(19756) * 64;
+acc += Math.sin(19756) + Math.cos(19757) * 65;
+acc += Math.sin(19757) + Math.cos(19758) * 66;
+acc += Math.sin(19758) + Math.cos(19759) * 67;
+acc += Math.sin(19759) + Math.cos(19760) * 68;
+acc += Math.sin(19760) + Math.cos(19761) * 69;
+acc += Math.sin(19761) + Math.cos(19762) * 70;
+acc += Math.sin(19762) + Math.cos(19763) * 71;
+acc += Math.sin(19763) + Math.cos(19764) * 72;
+acc += Math.sin(19764) + Math.cos(19765) * 73;
+acc += Math.sin(19765) + Math.cos(19766) * 74;
+acc += Math.sin(19766) + Math.cos(19767) * 75;
+acc += Math.sin(19767) + Math.cos(19768) * 76;
+acc += Math.sin(19768) + Math.cos(19769) * 77;
+acc += Math.sin(19769) + Math.cos(19770) * 78;
+acc += Math.sin(19770) + Math.cos(19771) * 79;
+acc += Math.sin(19771) + Math.cos(19772) * 80;
+acc += Math.sin(19772) + Math.cos(19773) * 81;
+acc += Math.sin(19773) + Math.cos(19774) * 82;
+acc += Math.sin(19774) + Math.cos(19775) * 83;
+acc += Math.sin(19775) + Math.cos(19776) * 84;
+acc += Math.sin(19776) + Math.cos(19777) * 85;
+acc += Math.sin(19777) + Math.cos(19778) * 86;
+acc += Math.sin(19778) + Math.cos(19779) * 87;
+acc += Math.sin(19779) + Math.cos(19780) * 88;
+acc += Math.sin(19780) + Math.cos(19781) * 89;
+acc += Math.sin(19781) + Math.cos(19782) * 90;
+acc += Math.sin(19782) + Math.cos(19783) * 91;
+acc += Math.sin(19783) + Math.cos(19784) * 92;
+acc += Math.sin(19784) + Math.cos(19785) * 93;
+acc += Math.sin(19785) + Math.cos(19786) * 94;
+acc += Math.sin(19786) + Math.cos(19787) * 95;
+acc += Math.sin(19787) + Math.cos(19788) * 96;
+acc += Math.sin(19788) + Math.cos(19789) * 0;
+acc += Math.sin(19789) + Math.cos(19790) * 1;
+acc += Math.sin(19790) + Math.cos(19791) * 2;
+acc += Math.sin(19791) + Math.cos(19792) * 3;
+acc += Math.sin(19792) + Math.cos(19793) * 4;
+acc += Math.sin(19793) + Math.cos(19794) * 5;
+acc += Math.sin(19794) + Math.cos(19795) * 6;
+acc += Math.sin(19795) + Math.cos(19796) * 7;
+acc += Math.sin(19796) + Math.cos(19797) * 8;
+acc += Math.sin(19797) + Math.cos(19798) * 9;
+acc += Math.sin(19798) + Math.cos(19799) * 10;
+acc += Math.sin(19799) + Math.cos(19800) * 11;
+acc += Math.sin(19800) + Math.cos(19801) * 12;
+acc += Math.sin(19801) + Math.cos(19802) * 13;
+acc += Math.sin(19802) + Math.cos(19803) * 14;
+acc += Math.sin(19803) + Math.cos(19804) * 15;
+acc += Math.sin(19804) + Math.cos(19805) * 16;
+acc += Math.sin(19805) + Math.cos(19806) * 17;
+acc += Math.sin(19806) + Math.cos(19807) * 18;
+acc += Math.sin(19807) + Math.cos(19808) * 19;
+acc += Math.sin(19808) + Math.cos(19809) * 20;
+acc += Math.sin(19809) + Math.cos(19810) * 21;
+acc += Math.sin(19810) + Math.cos(19811) * 22;
+acc += Math.sin(19811) + Math.cos(19812) * 23;
+acc += Math.sin(19812) + Math.cos(19813) * 24;
+acc += Math.sin(19813) + Math.cos(19814) * 25;
+acc += Math.sin(19814) + Math.cos(19815) * 26;
+acc += Math.sin(19815) + Math.cos(19816) * 27;
+acc += Math.sin(19816) + Math.cos(19817) * 28;
+acc += Math.sin(19817) + Math.cos(19818) * 29;
+acc += Math.sin(19818) + Math.cos(19819) * 30;
+acc += Math.sin(19819) + Math.cos(19820) * 31;
+acc += Math.sin(19820) + Math.cos(19821) * 32;
+acc += Math.sin(19821) + Math.cos(19822) * 33;
+acc += Math.sin(19822) + Math.cos(19823) * 34;
+acc += Math.sin(19823) + Math.cos(19824) * 35;
+acc += Math.sin(19824) + Math.cos(19825) * 36;
+acc += Math.sin(19825) + Math.cos(19826) * 37;
+acc += Math.sin(19826) + Math.cos(19827) * 38;
+acc += Math.sin(19827) + Math.cos(19828) * 39;
+acc += Math.sin(19828) + Math.cos(19829) * 40;
+acc += Math.sin(19829) + Math.cos(19830) * 41;
+acc += Math.sin(19830) + Math.cos(19831) * 42;
+acc += Math.sin(19831) + Math.cos(19832) * 43;
+acc += Math.sin(19832) + Math.cos(19833) * 44;
+acc += Math.sin(19833) + Math.cos(19834) * 45;
+acc += Math.sin(19834) + Math.cos(19835) * 46;
+acc += Math.sin(19835) + Math.cos(19836) * 47;
+acc += Math.sin(19836) + Math.cos(19837) * 48;
+acc += Math.sin(19837) + Math.cos(19838) * 49;
+acc += Math.sin(19838) + Math.cos(19839) * 50;
+acc += Math.sin(19839) + Math.cos(19840) * 51;
+acc += Math.sin(19840) + Math.cos(19841) * 52;
+acc += Math.sin(19841) + Math.cos(19842) * 53;
+acc += Math.sin(19842) + Math.cos(19843) * 54;
+acc += Math.sin(19843) + Math.cos(19844) * 55;
+acc += Math.sin(19844) + Math.cos(19845) * 56;
+acc += Math.sin(19845) + Math.cos(19846) * 57;
+acc += Math.sin(19846) + Math.cos(19847) * 58;
+acc += Math.sin(19847) + Math.cos(19848) * 59;
+acc += Math.sin(19848) + Math.cos(19849) * 60;
+acc += Math.sin(19849) + Math.cos(19850) * 61;
+acc += Math.sin(19850) + Math.cos(19851) * 62;
+acc += Math.sin(19851) + Math.cos(19852) * 63;
+acc += Math.sin(19852) + Math.cos(19853) * 64;
+acc += Math.sin(19853) + Math.cos(19854) * 65;
+acc += Math.sin(19854) + Math.cos(19855) * 66;
+acc += Math.sin(19855) + Math.cos(19856) * 67;
+acc += Math.sin(19856) + Math.cos(19857) * 68;
+acc += Math.sin(19857) + Math.cos(19858) * 69;
+acc += Math.sin(19858) + Math.cos(19859) * 70;
+acc += Math.sin(19859) + Math.cos(19860) * 71;
+acc += Math.sin(19860) + Math.cos(19861) * 72;
+acc += Math.sin(19861) + Math.cos(19862) * 73;
+acc += Math.sin(19862) + Math.cos(19863) * 74;
+acc += Math.sin(19863) + Math.cos(19864) * 75;
+acc += Math.sin(19864) + Math.cos(19865) * 76;
+acc += Math.sin(19865) + Math.cos(19866) * 77;
+acc += Math.sin(19866) + Math.cos(19867) * 78;
+acc += Math.sin(19867) + Math.cos(19868) * 79;
+acc += Math.sin(19868) + Math.cos(19869) * 80;
+acc += Math.sin(19869) + Math.cos(19870) * 81;
+acc += Math.sin(19870) + Math.cos(19871) * 82;
+acc += Math.sin(19871) + Math.cos(19872) * 83;
+acc += Math.sin(19872) + Math.cos(19873) * 84;
+acc += Math.sin(19873) + Math.cos(19874) * 85;
+acc += Math.sin(19874) + Math.cos(19875) * 86;
+acc += Math.sin(19875) + Math.cos(19876) * 87;
+acc += Math.sin(19876) + Math.cos(19877) * 88;
+acc += Math.sin(19877) + Math.cos(19878) * 89;
+acc += Math.sin(19878) + Math.cos(19879) * 90;
+acc += Math.sin(19879) + Math.cos(19880) * 91;
+acc += Math.sin(19880) + Math.cos(19881) * 92;
+acc += Math.sin(19881) + Math.cos(19882) * 93;
+acc += Math.sin(19882) + Math.cos(19883) * 94;
+acc += Math.sin(19883) + Math.cos(19884) * 95;
+acc += Math.sin(19884) + Math.cos(19885) * 96;
+acc += Math.sin(19885) + Math.cos(19886) * 0;
+acc += Math.sin(19886) + Math.cos(19887) * 1;
+acc += Math.sin(19887) + Math.cos(19888) * 2;
+acc += Math.sin(19888) + Math.cos(19889) * 3;
+acc += Math.sin(19889) + Math.cos(19890) * 4;
+acc += Math.sin(19890) + Math.cos(19891) * 5;
+acc += Math.sin(19891) + Math.cos(19892) * 6;
+acc += Math.sin(19892) + Math.cos(19893) * 7;
+acc += Math.sin(19893) + Math.cos(19894) * 8;
+acc += Math.sin(19894) + Math.cos(19895) * 9;
+acc += Math.sin(19895) + Math.cos(19896) * 10;
+acc += Math.sin(19896) + Math.cos(19897) * 11;
+acc += Math.sin(19897) + Math.cos(19898) * 12;
+acc += Math.sin(19898) + Math.cos(19899) * 13;
+acc += Math.sin(19899) + Math.cos(19900) * 14;
+acc += Math.sin(19900) + Math.cos(19901) * 15;
+acc += Math.sin(19901) + Math.cos(19902) * 16;
+acc += Math.sin(19902) + Math.cos(19903) * 17;
+acc += Math.sin(19903) + Math.cos(19904) * 18;
+acc += Math.sin(19904) + Math.cos(19905) * 19;
+acc += Math.sin(19905) + Math.cos(19906) * 20;
+acc += Math.sin(19906) + Math.cos(19907) * 21;
+acc += Math.sin(19907) + Math.cos(19908) * 22;
+acc += Math.sin(19908) + Math.cos(19909) * 23;
+acc += Math.sin(19909) + Math.cos(19910) * 24;
+acc += Math.sin(19910) + Math.cos(19911) * 25;
+acc += Math.sin(19911) + Math.cos(19912) * 26;
+acc += Math.sin(19912) + Math.cos(19913) * 27;
+acc += Math.sin(19913) + Math.cos(19914) * 28;
+acc += Math.sin(19914) + Math.cos(19915) * 29;
+acc += Math.sin(19915) + Math.cos(19916) * 30;
+acc += Math.sin(19916) + Math.cos(19917) * 31;
+acc += Math.sin(19917) + Math.cos(19918) * 32;
+acc += Math.sin(19918) + Math.cos(19919) * 33;
+acc += Math.sin(19919) + Math.cos(19920) * 34;
+acc += Math.sin(19920) + Math.cos(19921) * 35;
+acc += Math.sin(19921) + Math.cos(19922) * 36;
+acc += Math.sin(19922) + Math.cos(19923) * 37;
+acc += Math.sin(19923) + Math.cos(19924) * 38;
+acc += Math.sin(19924) + Math.cos(19925) * 39;
+acc += Math.sin(19925) + Math.cos(19926) * 40;
+acc += Math.sin(19926) + Math.cos(19927) * 41;
+acc += Math.sin(19927) + Math.cos(19928) * 42;
+acc += Math.sin(19928) + Math.cos(19929) * 43;
+acc += Math.sin(19929) + Math.cos(19930) * 44;
+acc += Math.sin(19930) + Math.cos(19931) * 45;
+acc += Math.sin(19931) + Math.cos(19932) * 46;
+acc += Math.sin(19932) + Math.cos(19933) * 47;
+acc += Math.sin(19933) + Math.cos(19934) * 48;
+acc += Math.sin(19934) + Math.cos(19935) * 49;
+acc += Math.sin(19935) + Math.cos(19936) * 50;
+acc += Math.sin(19936) + Math.cos(19937) * 51;
+acc += Math.sin(19937) + Math.cos(19938) * 52;
+acc += Math.sin(19938) + Math.cos(19939) * 53;
+acc += Math.sin(19939) + Math.cos(19940) * 54;
+acc += Math.sin(19940) + Math.cos(19941) * 55;
+acc += Math.sin(19941) + Math.cos(19942) * 56;
+acc += Math.sin(19942) + Math.cos(19943) * 57;
+acc += Math.sin(19943) + Math.cos(19944) * 58;
+acc += Math.sin(19944) + Math.cos(19945) * 59;
+acc += Math.sin(19945) + Math.cos(19946) * 60;
+acc += Math.sin(19946) + Math.cos(19947) * 61;
+acc += Math.sin(19947) + Math.cos(19948) * 62;
+acc += Math.sin(19948) + Math.cos(19949) * 63;
+acc += Math.sin(19949) + Math.cos(19950) * 64;
+acc += Math.sin(19950) + Math.cos(19951) * 65;
+acc += Math.sin(19951) + Math.cos(19952) * 66;
+acc += Math.sin(19952) + Math.cos(19953) * 67;
+acc += Math.sin(19953) + Math.cos(19954) * 68;
+acc += Math.sin(19954) + Math.cos(19955) * 69;
+acc += Math.sin(19955) + Math.cos(19956) * 70;
+acc += Math.sin(19956) + Math.cos(19957) * 71;
+acc += Math.sin(19957) + Math.cos(19958) * 72;
+acc += Math.sin(19958) + Math.cos(19959) * 73;
+acc += Math.sin(19959) + Math.cos(19960) * 74;
+acc += Math.sin(19960) + Math.cos(19961) * 75;
+acc += Math.sin(19961) + Math.cos(19962) * 76;
+acc += Math.sin(19962) + Math.cos(19963) * 77;
+acc += Math.sin(19963) + Math.cos(19964) * 78;
+acc += Math.sin(19964) + Math.cos(19965) * 79;
+acc += Math.sin(19965) + Math.cos(19966) * 80;
+acc += Math.sin(19966) + Math.cos(19967) * 81;
+acc += Math.sin(19967) + Math.cos(19968) * 82;
+acc += Math.sin(19968) + Math.cos(19969) * 83;
+acc += Math.sin(19969) + Math.cos(19970) * 84;
+acc += Math.sin(19970) + Math.cos(19971) * 85;
+acc += Math.sin(19971) + Math.cos(19972) * 86;
+acc += Math.sin(19972) + Math.cos(19973) * 87;
+acc += Math.sin(19973) + Math.cos(19974) * 88;
+acc += Math.sin(19974) + Math.cos(19975) * 89;
+acc += Math.sin(19975) + Math.cos(19976) * 90;
+acc += Math.sin(19976) + Math.cos(19977) * 91;
+acc += Math.sin(19977) + Math.cos(19978) * 92;
+acc += Math.sin(19978) + Math.cos(19979) * 93;
+acc += Math.sin(19979) + Math.cos(19980) * 94;
+acc += Math.sin(19980) + Math.cos(19981) * 95;
+acc += Math.sin(19981) + Math.cos(19982) * 96;
+acc += Math.sin(19982) + Math.cos(19983) * 0;
+acc += Math.sin(19983) + Math.cos(19984) * 1;
+acc += Math.sin(19984) + Math.cos(19985) * 2;
+acc += Math.sin(19985) + Math.cos(19986) * 3;
+acc += Math.sin(19986) + Math.cos(19987) * 4;
+acc += Math.sin(19987) + Math.cos(19988) * 5;
+acc += Math.sin(19988) + Math.cos(19989) * 6;
+acc += Math.sin(19989) + Math.cos(19990) * 7;
+acc += Math.sin(19990) + Math.cos(19991) * 8;
+acc += Math.sin(19991) + Math.cos(19992) * 9;
+acc += Math.sin(19992) + Math.cos(19993) * 10;
+acc += Math.sin(19993) + Math.cos(19994) * 11;
+acc += Math.sin(19994) + Math.cos(19995) * 12;
+acc += Math.sin(19995) + Math.cos(19996) * 13;
+acc += Math.sin(19996) + Math.cos(19997) * 14;
+acc += Math.sin(19997) + Math.cos(19998) * 15;
+acc += Math.sin(19998) + Math.cos(19999) * 16;
+acc += Math.sin(19999) + Math.cos(20000) * 17;
+acc += Math.sin(20000) + Math.cos(20001) * 18;
+acc += Math.sin(20001) + Math.cos(20002) * 19;
+acc += Math.sin(20002) + Math.cos(20003) * 20;
+acc += Math.sin(20003) + Math.cos(20004) * 21;
+acc += Math.sin(20004) + Math.cos(20005) * 22;
+acc += Math.sin(20005) + Math.cos(20006) * 23;
+acc += Math.sin(20006) + Math.cos(20007) * 24;
+acc += Math.sin(20007) + Math.cos(20008) * 25;
+acc += Math.sin(20008) + Math.cos(20009) * 26;
+acc += Math.sin(20009) + Math.cos(20010) * 27;
+acc += Math.sin(20010) + Math.cos(20011) * 28;
+acc += Math.sin(20011) + Math.cos(20012) * 29;
+acc += Math.sin(20012) + Math.cos(20013) * 30;
+acc += Math.sin(20013) + Math.cos(20014) * 31;
+acc += Math.sin(20014) + Math.cos(20015) * 32;
+acc += Math.sin(20015) + Math.cos(20016) * 33;
+acc += Math.sin(20016) + Math.cos(20017) * 34;
+acc += Math.sin(20017) + Math.cos(20018) * 35;
+acc += Math.sin(20018) + Math.cos(20019) * 36;
+acc += Math.sin(20019) + Math.cos(20020) * 37;
+acc += Math.sin(20020) + Math.cos(20021) * 38;
+acc += Math.sin(20021) + Math.cos(20022) * 39;
+acc += Math.sin(20022) + Math.cos(20023) * 40;
+acc += Math.sin(20023) + Math.cos(20024) * 41;
+acc += Math.sin(20024) + Math.cos(20025) * 42;
+acc += Math.sin(20025) + Math.cos(20026) * 43;
+acc += Math.sin(20026) + Math.cos(20027) * 44;
+acc += Math.sin(20027) + Math.cos(20028) * 45;
+acc += Math.sin(20028) + Math.cos(20029) * 46;
+acc += Math.sin(20029) + Math.cos(20030) * 47;
+acc += Math.sin(20030) + Math.cos(20031) * 48;
+acc += Math.sin(20031) + Math.cos(20032) * 49;
+acc += Math.sin(20032) + Math.cos(20033) * 50;
+acc += Math.sin(20033) + Math.cos(20034) * 51;
+acc += Math.sin(20034) + Math.cos(20035) * 52;
+acc += Math.sin(20035) + Math.cos(20036) * 53;
+acc += Math.sin(20036) + Math.cos(20037) * 54;
+acc += Math.sin(20037) + Math.cos(20038) * 55;
+acc += Math.sin(20038) + Math.cos(20039) * 56;
+acc += Math.sin(20039) + Math.cos(20040) * 57;
+acc += Math.sin(20040) + Math.cos(20041) * 58;
+acc += Math.sin(20041) + Math.cos(20042) * 59;
+acc += Math.sin(20042) + Math.cos(20043) * 60;
+acc += Math.sin(20043) + Math.cos(20044) * 61;
+acc += Math.sin(20044) + Math.cos(20045) * 62;
+acc += Math.sin(20045) + Math.cos(20046) * 63;
+acc += Math.sin(20046) + Math.cos(20047) * 64;
+acc += Math.sin(20047) + Math.cos(20048) * 65;
+acc += Math.sin(20048) + Math.cos(20049) * 66;
+acc += Math.sin(20049) + Math.cos(20050) * 67;
+acc += Math.sin(20050) + Math.cos(20051) * 68;
+acc += Math.sin(20051) + Math.cos(20052) * 69;
+acc += Math.sin(20052) + Math.cos(20053) * 70;
+acc += Math.sin(20053) + Math.cos(20054) * 71;
+acc += Math.sin(20054) + Math.cos(20055) * 72;
+acc += Math.sin(20055) + Math.cos(20056) * 73;
+acc += Math.sin(20056) + Math.cos(20057) * 74;
+acc += Math.sin(20057) + Math.cos(20058) * 75;
+acc += Math.sin(20058) + Math.cos(20059) * 76;
+acc += Math.sin(20059) + Math.cos(20060) * 77;
+acc += Math.sin(20060) + Math.cos(20061) * 78;
+acc += Math.sin(20061) + Math.cos(20062) * 79;
+acc += Math.sin(20062) + Math.cos(20063) * 80;
+acc += Math.sin(20063) + Math.cos(20064) * 81;
+acc += Math.sin(20064) + Math.cos(20065) * 82;
+acc += Math.sin(20065) + Math.cos(20066) * 83;
+acc += Math.sin(20066) + Math.cos(20067) * 84;
+acc += Math.sin(20067) + Math.cos(20068) * 85;
+acc += Math.sin(20068) + Math.cos(20069) * 86;
+acc += Math.sin(20069) + Math.cos(20070) * 87;
+acc += Math.sin(20070) + Math.cos(20071) * 88;
+acc += Math.sin(20071) + Math.cos(20072) * 89;
+acc += Math.sin(20072) + Math.cos(20073) * 90;
+acc += Math.sin(20073) + Math.cos(20074) * 91;
+acc += Math.sin(20074) + Math.cos(20075) * 92;
+acc += Math.sin(20075) + Math.cos(20076) * 93;
+acc += Math.sin(20076) + Math.cos(20077) * 94;
+acc += Math.sin(20077) + Math.cos(20078) * 95;
+acc += Math.sin(20078) + Math.cos(20079) * 96;
+acc += Math.sin(20079) + Math.cos(20080) * 0;
+acc += Math.sin(20080) + Math.cos(20081) * 1;
+acc += Math.sin(20081) + Math.cos(20082) * 2;
+acc += Math.sin(20082) + Math.cos(20083) * 3;
+acc += Math.sin(20083) + Math.cos(20084) * 4;
+acc += Math.sin(20084) + Math.cos(20085) * 5;
+acc += Math.sin(20085) + Math.cos(20086) * 6;
+acc += Math.sin(20086) + Math.cos(20087) * 7;
+acc += Math.sin(20087) + Math.cos(20088) * 8;
+acc += Math.sin(20088) + Math.cos(20089) * 9;
+acc += Math.sin(20089) + Math.cos(20090) * 10;
+acc += Math.sin(20090) + Math.cos(20091) * 11;
+acc += Math.sin(20091) + Math.cos(20092) * 12;
+acc += Math.sin(20092) + Math.cos(20093) * 13;
+acc += Math.sin(20093) + Math.cos(20094) * 14;
+acc += Math.sin(20094) + Math.cos(20095) * 15;
+acc += Math.sin(20095) + Math.cos(20096) * 16;
+acc += Math.sin(20096) + Math.cos(20097) * 17;
+acc += Math.sin(20097) + Math.cos(20098) * 18;
+acc += Math.sin(20098) + Math.cos(20099) * 19;
+acc += Math.sin(20099) + Math.cos(20100) * 20;
+acc += Math.sin(20100) + Math.cos(20101) * 21;
+acc += Math.sin(20101) + Math.cos(20102) * 22;
+acc += Math.sin(20102) + Math.cos(20103) * 23;
+acc += Math.sin(20103) + Math.cos(20104) * 24;
+acc += Math.sin(20104) + Math.cos(20105) * 25;
+acc += Math.sin(20105) + Math.cos(20106) * 26;
+acc += Math.sin(20106) + Math.cos(20107) * 27;
+acc += Math.sin(20107) + Math.cos(20108) * 28;
+acc += Math.sin(20108) + Math.cos(20109) * 29;
+acc += Math.sin(20109) + Math.cos(20110) * 30;
+acc += Math.sin(20110) + Math.cos(20111) * 31;
+acc += Math.sin(20111) + Math.cos(20112) * 32;
+acc += Math.sin(20112) + Math.cos(20113) * 33;
+acc += Math.sin(20113) + Math.cos(20114) * 34;
+acc += Math.sin(20114) + Math.cos(20115) * 35;
+acc += Math.sin(20115) + Math.cos(20116) * 36;
+acc += Math.sin(20116) + Math.cos(20117) * 37;
+acc += Math.sin(20117) + Math.cos(20118) * 38;
+acc += Math.sin(20118) + Math.cos(20119) * 39;
+acc += Math.sin(20119) + Math.cos(20120) * 40;
+acc += Math.sin(20120) + Math.cos(20121) * 41;
+acc += Math.sin(20121) + Math.cos(20122) * 42;
+acc += Math.sin(20122) + Math.cos(20123) * 43;
+acc += Math.sin(20123) + Math.cos(20124) * 44;
+acc += Math.sin(20124) + Math.cos(20125) * 45;
+acc += Math.sin(20125) + Math.cos(20126) * 46;
+acc += Math.sin(20126) + Math.cos(20127) * 47;
+acc += Math.sin(20127) + Math.cos(20128) * 48;
+acc += Math.sin(20128) + Math.cos(20129) * 49;
+acc += Math.sin(20129) + Math.cos(20130) * 50;
+acc += Math.sin(20130) + Math.cos(20131) * 51;
+acc += Math.sin(20131) + Math.cos(20132) * 52;
+acc += Math.sin(20132) + Math.cos(20133) * 53;
+acc += Math.sin(20133) + Math.cos(20134) * 54;
+acc += Math.sin(20134) + Math.cos(20135) * 55;
+acc += Math.sin(20135) + Math.cos(20136) * 56;
+acc += Math.sin(20136) + Math.cos(20137) * 57;
+acc += Math.sin(20137) + Math.cos(20138) * 58;
+acc += Math.sin(20138) + Math.cos(20139) * 59;
+acc += Math.sin(20139) + Math.cos(20140) * 60;
+acc += Math.sin(20140) + Math.cos(20141) * 61;
+acc += Math.sin(20141) + Math.cos(20142) * 62;
+acc += Math.sin(20142) + Math.cos(20143) * 63;
+acc += Math.sin(20143) + Math.cos(20144) * 64;
+acc += Math.sin(20144) + Math.cos(20145) * 65;
+acc += Math.sin(20145) + Math.cos(20146) * 66;
+acc += Math.sin(20146) + Math.cos(20147) * 67;
+acc += Math.sin(20147) + Math.cos(20148) * 68;
+acc += Math.sin(20148) + Math.cos(20149) * 69;
+acc += Math.sin(20149) + Math.cos(20150) * 70;
+acc += Math.sin(20150) + Math.cos(20151) * 71;
+acc += Math.sin(20151) + Math.cos(20152) * 72;
+acc += Math.sin(20152) + Math.cos(20153) * 73;
+acc += Math.sin(20153) + Math.cos(20154) * 74;
+acc += Math.sin(20154) + Math.cos(20155) * 75;
+acc += Math.sin(20155) + Math.cos(20156) * 76;
+acc += Math.sin(20156) + Math.cos(20157) * 77;
+acc += Math.sin(20157) + Math.cos(20158) * 78;
+acc += Math.sin(20158) + Math.cos(20159) * 79;
+acc += Math.sin(20159) + Math.cos(20160) * 80;
+acc += Math.sin(20160) + Math.cos(20161) * 81;
+acc += Math.sin(20161) + Math.cos(20162) * 82;
+acc += Math.sin(20162) + Math.cos(20163) * 83;
+acc += Math.sin(20163) + Math.cos(20164) * 84;
+acc += Math.sin(20164) + Math.cos(20165) * 85;
+acc += Math.sin(20165) + Math.cos(20166) * 86;
+acc += Math.sin(20166) + Math.cos(20167) * 87;
+acc += Math.sin(20167) + Math.cos(20168) * 88;
+acc += Math.sin(20168) + Math.cos(20169) * 89;
+acc += Math.sin(20169) + Math.cos(20170) * 90;
+acc += Math.sin(20170) + Math.cos(20171) * 91;
+acc += Math.sin(20171) + Math.cos(20172) * 92;
+acc += Math.sin(20172) + Math.cos(20173) * 93;
+acc += Math.sin(20173) + Math.cos(20174) * 94;
+acc += Math.sin(20174) + Math.cos(20175) * 95;
+acc += Math.sin(20175) + Math.cos(20176) * 96;
+acc += Math.sin(20176) + Math.cos(20177) * 0;
+acc += Math.sin(20177) + Math.cos(20178) * 1;
+acc += Math.sin(20178) + Math.cos(20179) * 2;
+acc += Math.sin(20179) + Math.cos(20180) * 3;
+acc += Math.sin(20180) + Math.cos(20181) * 4;
+acc += Math.sin(20181) + Math.cos(20182) * 5;
+acc += Math.sin(20182) + Math.cos(20183) * 6;
+acc += Math.sin(20183) + Math.cos(20184) * 7;
+acc += Math.sin(20184) + Math.cos(20185) * 8;
+acc += Math.sin(20185) + Math.cos(20186) * 9;
+acc += Math.sin(20186) + Math.cos(20187) * 10;
+acc += Math.sin(20187) + Math.cos(20188) * 11;
+acc += Math.sin(20188) + Math.cos(20189) * 12;
+acc += Math.sin(20189) + Math.cos(20190) * 13;
+acc += Math.sin(20190) + Math.cos(20191) * 14;
+acc += Math.sin(20191) + Math.cos(20192) * 15;
+acc += Math.sin(20192) + Math.cos(20193) * 16;
+acc += Math.sin(20193) + Math.cos(20194) * 17;
+acc += Math.sin(20194) + Math.cos(20195) * 18;
+acc += Math.sin(20195) + Math.cos(20196) * 19;
+acc += Math.sin(20196) + Math.cos(20197) * 20;
+acc += Math.sin(20197) + Math.cos(20198) * 21;
+acc += Math.sin(20198) + Math.cos(20199) * 22;
+acc += Math.sin(20199) + Math.cos(20200) * 23;
+acc += Math.sin(20200) + Math.cos(20201) * 24;
+acc += Math.sin(20201) + Math.cos(20202) * 25;
+acc += Math.sin(20202) + Math.cos(20203) * 26;
+acc += Math.sin(20203) + Math.cos(20204) * 27;
+acc += Math.sin(20204) + Math.cos(20205) * 28;
+acc += Math.sin(20205) + Math.cos(20206) * 29;
+acc += Math.sin(20206) + Math.cos(20207) * 30;
+acc += Math.sin(20207) + Math.cos(20208) * 31;
+acc += Math.sin(20208) + Math.cos(20209) * 32;
+acc += Math.sin(20209) + Math.cos(20210) * 33;
+acc += Math.sin(20210) + Math.cos(20211) * 34;
+acc += Math.sin(20211) + Math.cos(20212) * 35;
+acc += Math.sin(20212) + Math.cos(20213) * 36;
+acc += Math.sin(20213) + Math.cos(20214) * 37;
+acc += Math.sin(20214) + Math.cos(20215) * 38;
+acc += Math.sin(20215) + Math.cos(20216) * 39;
+acc += Math.sin(20216) + Math.cos(20217) * 40;
+acc += Math.sin(20217) + Math.cos(20218) * 41;
+acc += Math.sin(20218) + Math.cos(20219) * 42;
+acc += Math.sin(20219) + Math.cos(20220) * 43;
+acc += Math.sin(20220) + Math.cos(20221) * 44;
+acc += Math.sin(20221) + Math.cos(20222) * 45;
+acc += Math.sin(20222) + Math.cos(20223) * 46;
+acc += Math.sin(20223) + Math.cos(20224) * 47;
+acc += Math.sin(20224) + Math.cos(20225) * 48;
+acc += Math.sin(20225) + Math.cos(20226) * 49;
+acc += Math.sin(20226) + Math.cos(20227) * 50;
+acc += Math.sin(20227) + Math.cos(20228) * 51;
+acc += Math.sin(20228) + Math.cos(20229) * 52;
+acc += Math.sin(20229) + Math.cos(20230) * 53;
+acc += Math.sin(20230) + Math.cos(20231) * 54;
+acc += Math.sin(20231) + Math.cos(20232) * 55;
+acc += Math.sin(20232) + Math.cos(20233) * 56;
+acc += Math.sin(20233) + Math.cos(20234) * 57;
+acc += Math.sin(20234) + Math.cos(20235) * 58;
+acc += Math.sin(20235) + Math.cos(20236) * 59;
+acc += Math.sin(20236) + Math.cos(20237) * 60;
+acc += Math.sin(20237) + Math.cos(20238) * 61;
+acc += Math.sin(20238) + Math.cos(20239) * 62;
+acc += Math.sin(20239) + Math.cos(20240) * 63;
+acc += Math.sin(20240) + Math.cos(20241) * 64;
+acc += Math.sin(20241) + Math.cos(20242) * 65;
+acc += Math.sin(20242) + Math.cos(20243) * 66;
+acc += Math.sin(20243) + Math.cos(20244) * 67;
+acc += Math.sin(20244) + Math.cos(20245) * 68;
+acc += Math.sin(20245) + Math.cos(20246) * 69;
+acc += Math.sin(20246) + Math.cos(20247) * 70;
+acc += Math.sin(20247) + Math.cos(20248) * 71;
+acc += Math.sin(20248) + Math.cos(20249) * 72;
+acc += Math.sin(20249) + Math.cos(20250) * 73;
+acc += Math.sin(20250) + Math.cos(20251) * 74;
+acc += Math.sin(20251) + Math.cos(20252) * 75;
+acc += Math.sin(20252) + Math.cos(20253) * 76;
+acc += Math.sin(20253) + Math.cos(20254) * 77;
+acc += Math.sin(20254) + Math.cos(20255) * 78;
+acc += Math.sin(20255) + Math.cos(20256) * 79;
+acc += Math.sin(20256) + Math.cos(20257) * 80;
+acc += Math.sin(20257) + Math.cos(20258) * 81;
+acc += Math.sin(20258) + Math.cos(20259) * 82;
+acc += Math.sin(20259) + Math.cos(20260) * 83;
+acc += Math.sin(20260) + Math.cos(20261) * 84;
+acc += Math.sin(20261) + Math.cos(20262) * 85;
+acc += Math.sin(20262) + Math.cos(20263) * 86;
+acc += Math.sin(20263) + Math.cos(20264) * 87;
+acc += Math.sin(20264) + Math.cos(20265) * 88;
+acc += Math.sin(20265) + Math.cos(20266) * 89;
+acc += Math.sin(20266) + Math.cos(20267) * 90;
+acc += Math.sin(20267) + Math.cos(20268) * 91;
+acc += Math.sin(20268) + Math.cos(20269) * 92;
+acc += Math.sin(20269) + Math.cos(20270) * 93;
+acc += Math.sin(20270) + Math.cos(20271) * 94;
+acc += Math.sin(20271) + Math.cos(20272) * 95;
+acc += Math.sin(20272) + Math.cos(20273) * 96;
+acc += Math.sin(20273) + Math.cos(20274) * 0;
+acc += Math.sin(20274) + Math.cos(20275) * 1;
+acc += Math.sin(20275) + Math.cos(20276) * 2;
+acc += Math.sin(20276) + Math.cos(20277) * 3;
+acc += Math.sin(20277) + Math.cos(20278) * 4;
+acc += Math.sin(20278) + Math.cos(20279) * 5;
+acc += Math.sin(20279) + Math.cos(20280) * 6;
+acc += Math.sin(20280) + Math.cos(20281) * 7;
+acc += Math.sin(20281) + Math.cos(20282) * 8;
+acc += Math.sin(20282) + Math.cos(20283) * 9;
+acc += Math.sin(20283) + Math.cos(20284) * 10;
+acc += Math.sin(20284) + Math.cos(20285) * 11;
+acc += Math.sin(20285) + Math.cos(20286) * 12;
+acc += Math.sin(20286) + Math.cos(20287) * 13;
+acc += Math.sin(20287) + Math.cos(20288) * 14;
+acc += Math.sin(20288) + Math.cos(20289) * 15;
+acc += Math.sin(20289) + Math.cos(20290) * 16;
+acc += Math.sin(20290) + Math.cos(20291) * 17;
+acc += Math.sin(20291) + Math.cos(20292) * 18;
+acc += Math.sin(20292) + Math.cos(20293) * 19;
+acc += Math.sin(20293) + Math.cos(20294) * 20;
+acc += Math.sin(20294) + Math.cos(20295) * 21;
+acc += Math.sin(20295) + Math.cos(20296) * 22;
+acc += Math.sin(20296) + Math.cos(20297) * 23;
+acc += Math.sin(20297) + Math.cos(20298) * 24;
+acc += Math.sin(20298) + Math.cos(20299) * 25;
+acc += Math.sin(20299) + Math.cos(20300) * 26;
+acc += Math.sin(20300) + Math.cos(20301) * 27;
+acc += Math.sin(20301) + Math.cos(20302) * 28;
+acc += Math.sin(20302) + Math.cos(20303) * 29;
+acc += Math.sin(20303) + Math.cos(20304) * 30;
+acc += Math.sin(20304) + Math.cos(20305) * 31;
+acc += Math.sin(20305) + Math.cos(20306) * 32;
+acc += Math.sin(20306) + Math.cos(20307) * 33;
+acc += Math.sin(20307) + Math.cos(20308) * 34;
+acc += Math.sin(20308) + Math.cos(20309) * 35;
+acc += Math.sin(20309) + Math.cos(20310) * 36;
+acc += Math.sin(20310) + Math.cos(20311) * 37;
+acc += Math.sin(20311) + Math.cos(20312) * 38;
+acc += Math.sin(20312) + Math.cos(20313) * 39;
+acc += Math.sin(20313) + Math.cos(20314) * 40;
+acc += Math.sin(20314) + Math.cos(20315) * 41;
+acc += Math.sin(20315) + Math.cos(20316) * 42;
+acc += Math.sin(20316) + Math.cos(20317) * 43;
+acc += Math.sin(20317) + Math.cos(20318) * 44;
+acc += Math.sin(20318) + Math.cos(20319) * 45;
+acc += Math.sin(20319) + Math.cos(20320) * 46;
+acc += Math.sin(20320) + Math.cos(20321) * 47;
+acc += Math.sin(20321) + Math.cos(20322) * 48;
+acc += Math.sin(20322) + Math.cos(20323) * 49;
+acc += Math.sin(20323) + Math.cos(20324) * 50;
+acc += Math.sin(20324) + Math.cos(20325) * 51;
+acc += Math.sin(20325) + Math.cos(20326) * 52;
+acc += Math.sin(20326) + Math.cos(20327) * 53;
+acc += Math.sin(20327) + Math.cos(20328) * 54;
+acc += Math.sin(20328) + Math.cos(20329) * 55;
+acc += Math.sin(20329) + Math.cos(20330) * 56;
+acc += Math.sin(20330) + Math.cos(20331) * 57;
+acc += Math.sin(20331) + Math.cos(20332) * 58;
+acc += Math.sin(20332) + Math.cos(20333) * 59;
+acc += Math.sin(20333) + Math.cos(20334) * 60;
+acc += Math.sin(20334) + Math.cos(20335) * 61;
+acc += Math.sin(20335) + Math.cos(20336) * 62;
+acc += Math.sin(20336) + Math.cos(20337) * 63;
+acc += Math.sin(20337) + Math.cos(20338) * 64;
+acc += Math.sin(20338) + Math.cos(20339) * 65;
+acc += Math.sin(20339) + Math.cos(20340) * 66;
+acc += Math.sin(20340) + Math.cos(20341) * 67;
+acc += Math.sin(20341) + Math.cos(20342) * 68;
+acc += Math.sin(20342) + Math.cos(20343) * 69;
+acc += Math.sin(20343) + Math.cos(20344) * 70;
+acc += Math.sin(20344) + Math.cos(20345) * 71;
+acc += Math.sin(20345) + Math.cos(20346) * 72;
+acc += Math.sin(20346) + Math.cos(20347) * 73;
+acc += Math.sin(20347) + Math.cos(20348) * 74;
+acc += Math.sin(20348) + Math.cos(20349) * 75;
+acc += Math.sin(20349) + Math.cos(20350) * 76;
+acc += Math.sin(20350) + Math.cos(20351) * 77;
+acc += Math.sin(20351) + Math.cos(20352) * 78;
+acc += Math.sin(20352) + Math.cos(20353) * 79;
+acc += Math.sin(20353) + Math.cos(20354) * 80;
+acc += Math.sin(20354) + Math.cos(20355) * 81;
+acc += Math.sin(20355) + Math.cos(20356) * 82;
+acc += Math.sin(20356) + Math.cos(20357) * 83;
+acc += Math.sin(20357) + Math.cos(20358) * 84;
+acc += Math.sin(20358) + Math.cos(20359) * 85;
+acc += Math.sin(20359) + Math.cos(20360) * 86;
+acc += Math.sin(20360) + Math.cos(20361) * 87;
+acc += Math.sin(20361) + Math.cos(20362) * 88;
+acc += Math.sin(20362) + Math.cos(20363) * 89;
+acc += Math.sin(20363) + Math.cos(20364) * 90;
+acc += Math.sin(20364) + Math.cos(20365) * 91;
+acc += Math.sin(20365) + Math.cos(20366) * 92;
+acc += Math.sin(20366) + Math.cos(20367) * 93;
+acc += Math.sin(20367) + Math.cos(20368) * 94;
+acc += Math.sin(20368) + Math.cos(20369) * 95;
+acc += Math.sin(20369) + Math.cos(20370) * 96;
+acc += Math.sin(20370) + Math.cos(20371) * 0;
+acc += Math.sin(20371) + Math.cos(20372) * 1;
+acc += Math.sin(20372) + Math.cos(20373) * 2;
+acc += Math.sin(20373) + Math.cos(20374) * 3;
+acc += Math.sin(20374) + Math.cos(20375) * 4;
+acc += Math.sin(20375) + Math.cos(20376) * 5;
+acc += Math.sin(20376) + Math.cos(20377) * 6;
+acc += Math.sin(20377) + Math.cos(20378) * 7;
+acc += Math.sin(20378) + Math.cos(20379) * 8;
+acc += Math.sin(20379) + Math.cos(20380) * 9;
+acc += Math.sin(20380) + Math.cos(20381) * 10;
+acc += Math.sin(20381) + Math.cos(20382) * 11;
+acc += Math.sin(20382) + Math.cos(20383) * 12;
+acc += Math.sin(20383) + Math.cos(20384) * 13;
+acc += Math.sin(20384) + Math.cos(20385) * 14;
+acc += Math.sin(20385) + Math.cos(20386) * 15;
+acc += Math.sin(20386) + Math.cos(20387) * 16;
+acc += Math.sin(20387) + Math.cos(20388) * 17;
+acc += Math.sin(20388) + Math.cos(20389) * 18;
+acc += Math.sin(20389) + Math.cos(20390) * 19;
+acc += Math.sin(20390) + Math.cos(20391) * 20;
+acc += Math.sin(20391) + Math.cos(20392) * 21;
+acc += Math.sin(20392) + Math.cos(20393) * 22;
+acc += Math.sin(20393) + Math.cos(20394) * 23;
+acc += Math.sin(20394) + Math.cos(20395) * 24;
+acc += Math.sin(20395) + Math.cos(20396) * 25;
+acc += Math.sin(20396) + Math.cos(20397) * 26;
+acc += Math.sin(20397) + Math.cos(20398) * 27;
+acc += Math.sin(20398) + Math.cos(20399) * 28;
+acc += Math.sin(20399) + Math.cos(20400) * 29;
+acc += Math.sin(20400) + Math.cos(20401) * 30;
+acc += Math.sin(20401) + Math.cos(20402) * 31;
+acc += Math.sin(20402) + Math.cos(20403) * 32;
+acc += Math.sin(20403) + Math.cos(20404) * 33;
+acc += Math.sin(20404) + Math.cos(20405) * 34;
+acc += Math.sin(20405) + Math.cos(20406) * 35;
+acc += Math.sin(20406) + Math.cos(20407) * 36;
+acc += Math.sin(20407) + Math.cos(20408) * 37;
+acc += Math.sin(20408) + Math.cos(20409) * 38;
+acc += Math.sin(20409) + Math.cos(20410) * 39;
+acc += Math.sin(20410) + Math.cos(20411) * 40;
+acc += Math.sin(20411) + Math.cos(20412) * 41;
+acc += Math.sin(20412) + Math.cos(20413) * 42;
+acc += Math.sin(20413) + Math.cos(20414) * 43;
+acc += Math.sin(20414) + Math.cos(20415) * 44;
+acc += Math.sin(20415) + Math.cos(20416) * 45;
+acc += Math.sin(20416) + Math.cos(20417) * 46;
+acc += Math.sin(20417) + Math.cos(20418) * 47;
+acc += Math.sin(20418) + Math.cos(20419) * 48;
+acc += Math.sin(20419) + Math.cos(20420) * 49;
+acc += Math.sin(20420) + Math.cos(20421) * 50;
+acc += Math.sin(20421) + Math.cos(20422) * 51;
+acc += Math.sin(20422) + Math.cos(20423) * 52;
+acc += Math.sin(20423) + Math.cos(20424) * 53;
+acc += Math.sin(20424) + Math.cos(20425) * 54;
+acc += Math.sin(20425) + Math.cos(20426) * 55;
+acc += Math.sin(20426) + Math.cos(20427) * 56;
+acc += Math.sin(20427) + Math.cos(20428) * 57;
+acc += Math.sin(20428) + Math.cos(20429) * 58;
+acc += Math.sin(20429) + Math.cos(20430) * 59;
+acc += Math.sin(20430) + Math.cos(20431) * 60;
+acc += Math.sin(20431) + Math.cos(20432) * 61;
+acc += Math.sin(20432) + Math.cos(20433) * 62;
+acc += Math.sin(20433) + Math.cos(20434) * 63;
+acc += Math.sin(20434) + Math.cos(20435) * 64;
+acc += Math.sin(20435) + Math.cos(20436) * 65;
+acc += Math.sin(20436) + Math.cos(20437) * 66;
+acc += Math.sin(20437) + Math.cos(20438) * 67;
+acc += Math.sin(20438) + Math.cos(20439) * 68;
+acc += Math.sin(20439) + Math.cos(20440) * 69;
+acc += Math.sin(20440) + Math.cos(20441) * 70;
+acc += Math.sin(20441) + Math.cos(20442) * 71;
+acc += Math.sin(20442) + Math.cos(20443) * 72;
+acc += Math.sin(20443) + Math.cos(20444) * 73;
+acc += Math.sin(20444) + Math.cos(20445) * 74;
+acc += Math.sin(20445) + Math.cos(20446) * 75;
+acc += Math.sin(20446) + Math.cos(20447) * 76;
+acc += Math.sin(20447) + Math.cos(20448) * 77;
+acc += Math.sin(20448) + Math.cos(20449) * 78;
+acc += Math.sin(20449) + Math.cos(20450) * 79;
+acc += Math.sin(20450) + Math.cos(20451) * 80;
+acc += Math.sin(20451) + Math.cos(20452) * 81;
+acc += Math.sin(20452) + Math.cos(20453) * 82;
+acc += Math.sin(20453) + Math.cos(20454) * 83;
+acc += Math.sin(20454) + Math.cos(20455) * 84;
+acc += Math.sin(20455) + Math.cos(20456) * 85;
+acc += Math.sin(20456) + Math.cos(20457) * 86;
+acc += Math.sin(20457) + Math.cos(20458) * 87;
+acc += Math.sin(20458) + Math.cos(20459) * 88;
+acc += Math.sin(20459) + Math.cos(20460) * 89;
+acc += Math.sin(20460) + Math.cos(20461) * 90;
+acc += Math.sin(20461) + Math.cos(20462) * 91;
+acc += Math.sin(20462) + Math.cos(20463) * 92;
+acc += Math.sin(20463) + Math.cos(20464) * 93;
+acc += Math.sin(20464) + Math.cos(20465) * 94;
+acc += Math.sin(20465) + Math.cos(20466) * 95;
+acc += Math.sin(20466) + Math.cos(20467) * 96;
+acc += Math.sin(20467) + Math.cos(20468) * 0;
+acc += Math.sin(20468) + Math.cos(20469) * 1;
+acc += Math.sin(20469) + Math.cos(20470) * 2;
+acc += Math.sin(20470) + Math.cos(20471) * 3;
+acc += Math.sin(20471) + Math.cos(20472) * 4;
+acc += Math.sin(20472) + Math.cos(20473) * 5;
+acc += Math.sin(20473) + Math.cos(20474) * 6;
+acc += Math.sin(20474) + Math.cos(20475) * 7;
+acc += Math.sin(20475) + Math.cos(20476) * 8;
+acc += Math.sin(20476) + Math.cos(20477) * 9;
+acc += Math.sin(20477) + Math.cos(20478) * 10;
+acc += Math.sin(20478) + Math.cos(20479) * 11;
+acc += Math.sin(20479) + Math.cos(20480) * 12;
+acc += Math.sin(20480) + Math.cos(20481) * 13;
+acc += Math.sin(20481) + Math.cos(20482) * 14;
+acc += Math.sin(20482) + Math.cos(20483) * 15;
+acc += Math.sin(20483) + Math.cos(20484) * 16;
+acc += Math.sin(20484) + Math.cos(20485) * 17;
+acc += Math.sin(20485) + Math.cos(20486) * 18;
+acc += Math.sin(20486) + Math.cos(20487) * 19;
+acc += Math.sin(20487) + Math.cos(20488) * 20;
+acc += Math.sin(20488) + Math.cos(20489) * 21;
+acc += Math.sin(20489) + Math.cos(20490) * 22;
+acc += Math.sin(20490) + Math.cos(20491) * 23;
+acc += Math.sin(20491) + Math.cos(20492) * 24;
+acc += Math.sin(20492) + Math.cos(20493) * 25;
+acc += Math.sin(20493) + Math.cos(20494) * 26;
+acc += Math.sin(20494) + Math.cos(20495) * 27;
+acc += Math.sin(20495) + Math.cos(20496) * 28;
+acc += Math.sin(20496) + Math.cos(20497) * 29;
+acc += Math.sin(20497) + Math.cos(20498) * 30;
+acc += Math.sin(20498) + Math.cos(20499) * 31;
+acc += Math.sin(20499) + Math.cos(20500) * 32;
+acc += Math.sin(20500) + Math.cos(20501) * 33;
+acc += Math.sin(20501) + Math.cos(20502) * 34;
+acc += Math.sin(20502) + Math.cos(20503) * 35;
+acc += Math.sin(20503) + Math.cos(20504) * 36;
+acc += Math.sin(20504) + Math.cos(20505) * 37;
+acc += Math.sin(20505) + Math.cos(20506) * 38;
+acc += Math.sin(20506) + Math.cos(20507) * 39;
+acc += Math.sin(20507) + Math.cos(20508) * 40;
+acc += Math.sin(20508) + Math.cos(20509) * 41;
+acc += Math.sin(20509) + Math.cos(20510) * 42;
+acc += Math.sin(20510) + Math.cos(20511) * 43;
+acc += Math.sin(20511) + Math.cos(20512) * 44;
+acc += Math.sin(20512) + Math.cos(20513) * 45;
+acc += Math.sin(20513) + Math.cos(20514) * 46;
+acc += Math.sin(20514) + Math.cos(20515) * 47;
+acc += Math.sin(20515) + Math.cos(20516) * 48;
+acc += Math.sin(20516) + Math.cos(20517) * 49;
+acc += Math.sin(20517) + Math.cos(20518) * 50;
+acc += Math.sin(20518) + Math.cos(20519) * 51;
+acc += Math.sin(20519) + Math.cos(20520) * 52;
+acc += Math.sin(20520) + Math.cos(20521) * 53;
+acc += Math.sin(20521) + Math.cos(20522) * 54;
+acc += Math.sin(20522) + Math.cos(20523) * 55;
+acc += Math.sin(20523) + Math.cos(20524) * 56;
+acc += Math.sin(20524) + Math.cos(20525) * 57;
+acc += Math.sin(20525) + Math.cos(20526) * 58;
+acc += Math.sin(20526) + Math.cos(20527) * 59;
+acc += Math.sin(20527) + Math.cos(20528) * 60;
+acc += Math.sin(20528) + Math.cos(20529) * 61;
+acc += Math.sin(20529) + Math.cos(20530) * 62;
+acc += Math.sin(20530) + Math.cos(20531) * 63;
+acc += Math.sin(20531) + Math.cos(20532) * 64;
+acc += Math.sin(20532) + Math.cos(20533) * 65;
+acc += Math.sin(20533) + Math.cos(20534) * 66;
+acc += Math.sin(20534) + Math.cos(20535) * 67;
+acc += Math.sin(20535) + Math.cos(20536) * 68;
+acc += Math.sin(20536) + Math.cos(20537) * 69;
+acc += Math.sin(20537) + Math.cos(20538) * 70;
+acc += Math.sin(20538) + Math.cos(20539) * 71;
+acc += Math.sin(20539) + Math.cos(20540) * 72;
+acc += Math.sin(20540) + Math.cos(20541) * 73;
+acc += Math.sin(20541) + Math.cos(20542) * 74;
+acc += Math.sin(20542) + Math.cos(20543) * 75;
+acc += Math.sin(20543) + Math.cos(20544) * 76;
+acc += Math.sin(20544) + Math.cos(20545) * 77;
+acc += Math.sin(20545) + Math.cos(20546) * 78;
+acc += Math.sin(20546) + Math.cos(20547) * 79;
+acc += Math.sin(20547) + Math.cos(20548) * 80;
+acc += Math.sin(20548) + Math.cos(20549) * 81;
+acc += Math.sin(20549) + Math.cos(20550) * 82;
+acc += Math.sin(20550) + Math.cos(20551) * 83;
+acc += Math.sin(20551) + Math.cos(20552) * 84;
+acc += Math.sin(20552) + Math.cos(20553) * 85;
+acc += Math.sin(20553) + Math.cos(20554) * 86;
+acc += Math.sin(20554) + Math.cos(20555) * 87;
+acc += Math.sin(20555) + Math.cos(20556) * 88;
+acc += Math.sin(20556) + Math.cos(20557) * 89;
+acc += Math.sin(20557) + Math.cos(20558) * 90;
+acc += Math.sin(20558) + Math.cos(20559) * 91;
+acc += Math.sin(20559) + Math.cos(20560) * 92;
+acc += Math.sin(20560) + Math.cos(20561) * 93;
+acc += Math.sin(20561) + Math.cos(20562) * 94;
+acc += Math.sin(20562) + Math.cos(20563) * 95;
+acc += Math.sin(20563) + Math.cos(20564) * 96;
+acc += Math.sin(20564) + Math.cos(20565) * 0;
+acc += Math.sin(20565) + Math.cos(20566) * 1;
+acc += Math.sin(20566) + Math.cos(20567) * 2;
+acc += Math.sin(20567) + Math.cos(20568) * 3;
+acc += Math.sin(20568) + Math.cos(20569) * 4;
+acc += Math.sin(20569) + Math.cos(20570) * 5;
+acc += Math.sin(20570) + Math.cos(20571) * 6;
+acc += Math.sin(20571) + Math.cos(20572) * 7;
+acc += Math.sin(20572) + Math.cos(20573) * 8;
+acc += Math.sin(20573) + Math.cos(20574) * 9;
+acc += Math.sin(20574) + Math.cos(20575) * 10;
+acc += Math.sin(20575) + Math.cos(20576) * 11;
+acc += Math.sin(20576) + Math.cos(20577) * 12;
+acc += Math.sin(20577) + Math.cos(20578) * 13;
+acc += Math.sin(20578) + Math.cos(20579) * 14;
+acc += Math.sin(20579) + Math.cos(20580) * 15;
+acc += Math.sin(20580) + Math.cos(20581) * 16;
+acc += Math.sin(20581) + Math.cos(20582) * 17;
+acc += Math.sin(20582) + Math.cos(20583) * 18;
+acc += Math.sin(20583) + Math.cos(20584) * 19;
+acc += Math.sin(20584) + Math.cos(20585) * 20;
+acc += Math.sin(20585) + Math.cos(20586) * 21;
+acc += Math.sin(20586) + Math.cos(20587) * 22;
+acc += Math.sin(20587) + Math.cos(20588) * 23;
+acc += Math.sin(20588) + Math.cos(20589) * 24;
+acc += Math.sin(20589) + Math.cos(20590) * 25;
+acc += Math.sin(20590) + Math.cos(20591) * 26;
+acc += Math.sin(20591) + Math.cos(20592) * 27;
+acc += Math.sin(20592) + Math.cos(20593) * 28;
+acc += Math.sin(20593) + Math.cos(20594) * 29;
+acc += Math.sin(20594) + Math.cos(20595) * 30;
+acc += Math.sin(20595) + Math.cos(20596) * 31;
+acc += Math.sin(20596) + Math.cos(20597) * 32;
+acc += Math.sin(20597) + Math.cos(20598) * 33;
+acc += Math.sin(20598) + Math.cos(20599) * 34;
+acc += Math.sin(20599) + Math.cos(20600) * 35;
+acc += Math.sin(20600) + Math.cos(20601) * 36;
+acc += Math.sin(20601) + Math.cos(20602) * 37;
+acc += Math.sin(20602) + Math.cos(20603) * 38;
+acc += Math.sin(20603) + Math.cos(20604) * 39;
+acc += Math.sin(20604) + Math.cos(20605) * 40;
+acc += Math.sin(20605) + Math.cos(20606) * 41;
+acc += Math.sin(20606) + Math.cos(20607) * 42;
+acc += Math.sin(20607) + Math.cos(20608) * 43;
+acc += Math.sin(20608) + Math.cos(20609) * 44;
+acc += Math.sin(20609) + Math.cos(20610) * 45;
+acc += Math.sin(20610) + Math.cos(20611) * 46;
+acc += Math.sin(20611) + Math.cos(20612) * 47;
+acc += Math.sin(20612) + Math.cos(20613) * 48;
+acc += Math.sin(20613) + Math.cos(20614) * 49;
+acc += Math.sin(20614) + Math.cos(20615) * 50;
+acc += Math.sin(20615) + Math.cos(20616) * 51;
+acc += Math.sin(20616) + Math.cos(20617) * 52;
+acc += Math.sin(20617) + Math.cos(20618) * 53;
+acc += Math.sin(20618) + Math.cos(20619) * 54;
+acc += Math.sin(20619) + Math.cos(20620) * 55;
+acc += Math.sin(20620) + Math.cos(20621) * 56;
+acc += Math.sin(20621) + Math.cos(20622) * 57;
+acc += Math.sin(20622) + Math.cos(20623) * 58;
+acc += Math.sin(20623) + Math.cos(20624) * 59;
+acc += Math.sin(20624) + Math.cos(20625) * 60;
+acc += Math.sin(20625) + Math.cos(20626) * 61;
+acc += Math.sin(20626) + Math.cos(20627) * 62;
+acc += Math.sin(20627) + Math.cos(20628) * 63;
+acc += Math.sin(20628) + Math.cos(20629) * 64;
+acc += Math.sin(20629) + Math.cos(20630) * 65;
+acc += Math.sin(20630) + Math.cos(20631) * 66;
+acc += Math.sin(20631) + Math.cos(20632) * 67;
+acc += Math.sin(20632) + Math.cos(20633) * 68;
+acc += Math.sin(20633) + Math.cos(20634) * 69;
+acc += Math.sin(20634) + Math.cos(20635) * 70;
+acc += Math.sin(20635) + Math.cos(20636) * 71;
+acc += Math.sin(20636) + Math.cos(20637) * 72;
+acc += Math.sin(20637) + Math.cos(20638) * 73;
+acc += Math.sin(20638) + Math.cos(20639) * 74;
+acc += Math.sin(20639) + Math.cos(20640) * 75;
+acc += Math.sin(20640) + Math.cos(20641) * 76;
+acc += Math.sin(20641) + Math.cos(20642) * 77;
+acc += Math.sin(20642) + Math.cos(20643) * 78;
+acc += Math.sin(20643) + Math.cos(20644) * 79;
+acc += Math.sin(20644) + Math.cos(20645) * 80;
+acc += Math.sin(20645) + Math.cos(20646) * 81;
+acc += Math.sin(20646) + Math.cos(20647) * 82;
+acc += Math.sin(20647) + Math.cos(20648) * 83;
+acc += Math.sin(20648) + Math.cos(20649) * 84;
+acc += Math.sin(20649) + Math.cos(20650) * 85;
+acc += Math.sin(20650) + Math.cos(20651) * 86;
+acc += Math.sin(20651) + Math.cos(20652) * 87;
+acc += Math.sin(20652) + Math.cos(20653) * 88;
+acc += Math.sin(20653) + Math.cos(20654) * 89;
+acc += Math.sin(20654) + Math.cos(20655) * 90;
+acc += Math.sin(20655) + Math.cos(20656) * 91;
+acc += Math.sin(20656) + Math.cos(20657) * 92;
+acc += Math.sin(20657) + Math.cos(20658) * 93;
+acc += Math.sin(20658) + Math.cos(20659) * 94;
+acc += Math.sin(20659) + Math.cos(20660) * 95;
+acc += Math.sin(20660) + Math.cos(20661) * 96;
+acc += Math.sin(20661) + Math.cos(20662) * 0;
+acc += Math.sin(20662) + Math.cos(20663) * 1;
+acc += Math.sin(20663) + Math.cos(20664) * 2;
+acc += Math.sin(20664) + Math.cos(20665) * 3;
+acc += Math.sin(20665) + Math.cos(20666) * 4;
+acc += Math.sin(20666) + Math.cos(20667) * 5;
+acc += Math.sin(20667) + Math.cos(20668) * 6;
+acc += Math.sin(20668) + Math.cos(20669) * 7;
+acc += Math.sin(20669) + Math.cos(20670) * 8;
+acc += Math.sin(20670) + Math.cos(20671) * 9;
+acc += Math.sin(20671) + Math.cos(20672) * 10;
+acc += Math.sin(20672) + Math.cos(20673) * 11;
+acc += Math.sin(20673) + Math.cos(20674) * 12;
+acc += Math.sin(20674) + Math.cos(20675) * 13;
+acc += Math.sin(20675) + Math.cos(20676) * 14;
+acc += Math.sin(20676) + Math.cos(20677) * 15;
+acc += Math.sin(20677) + Math.cos(20678) * 16;
+acc += Math.sin(20678) + Math.cos(20679) * 17;
+acc += Math.sin(20679) + Math.cos(20680) * 18;
+acc += Math.sin(20680) + Math.cos(20681) * 19;
+acc += Math.sin(20681) + Math.cos(20682) * 20;
+acc += Math.sin(20682) + Math.cos(20683) * 21;
+acc += Math.sin(20683) + Math.cos(20684) * 22;
+acc += Math.sin(20684) + Math.cos(20685) * 23;
+acc += Math.sin(20685) + Math.cos(20686) * 24;
+acc += Math.sin(20686) + Math.cos(20687) * 25;
+acc += Math.sin(20687) + Math.cos(20688) * 26;
+acc += Math.sin(20688) + Math.cos(20689) * 27;
+acc += Math.sin(20689) + Math.cos(20690) * 28;
+acc += Math.sin(20690) + Math.cos(20691) * 29;
+acc += Math.sin(20691) + Math.cos(20692) * 30;
+acc += Math.sin(20692) + Math.cos(20693) * 31;
+acc += Math.sin(20693) + Math.cos(20694) * 32;
+acc += Math.sin(20694) + Math.cos(20695) * 33;
+acc += Math.sin(20695) + Math.cos(20696) * 34;
+acc += Math.sin(20696) + Math.cos(20697) * 35;
+acc += Math.sin(20697) + Math.cos(20698) * 36;
+acc += Math.sin(20698) + Math.cos(20699) * 37;
+acc += Math.sin(20699) + Math.cos(20700) * 38;
+acc += Math.sin(20700) + Math.cos(20701) * 39;
+acc += Math.sin(20701) + Math.cos(20702) * 40;
+acc += Math.sin(20702) + Math.cos(20703) * 41;
+acc += Math.sin(20703) + Math.cos(20704) * 42;
+acc += Math.sin(20704) + Math.cos(20705) * 43;
+acc += Math.sin(20705) + Math.cos(20706) * 44;
+acc += Math.sin(20706) + Math.cos(20707) * 45;
+acc += Math.sin(20707) + Math.cos(20708) * 46;
+acc += Math.sin(20708) + Math.cos(20709) * 47;
+acc += Math.sin(20709) + Math.cos(20710) * 48;
+acc += Math.sin(20710) + Math.cos(20711) * 49;
+acc += Math.sin(20711) + Math.cos(20712) * 50;
+acc += Math.sin(20712) + Math.cos(20713) * 51;
+acc += Math.sin(20713) + Math.cos(20714) * 52;
+acc += Math.sin(20714) + Math.cos(20715) * 53;
+acc += Math.sin(20715) + Math.cos(20716) * 54;
+acc += Math.sin(20716) + Math.cos(20717) * 55;
+acc += Math.sin(20717) + Math.cos(20718) * 56;
+acc += Math.sin(20718) + Math.cos(20719) * 57;
+acc += Math.sin(20719) + Math.cos(20720) * 58;
+acc += Math.sin(20720) + Math.cos(20721) * 59;
+acc += Math.sin(20721) + Math.cos(20722) * 60;
+acc += Math.sin(20722) + Math.cos(20723) * 61;
+acc += Math.sin(20723) + Math.cos(20724) * 62;
+acc += Math.sin(20724) + Math.cos(20725) * 63;
+acc += Math.sin(20725) + Math.cos(20726) * 64;
+acc += Math.sin(20726) + Math.cos(20727) * 65;
+acc += Math.sin(20727) + Math.cos(20728) * 66;
+acc += Math.sin(20728) + Math.cos(20729) * 67;
+acc += Math.sin(20729) + Math.cos(20730) * 68;
+acc += Math.sin(20730) + Math.cos(20731) * 69;
+acc += Math.sin(20731) + Math.cos(20732) * 70;
+acc += Math.sin(20732) + Math.cos(20733) * 71;
+acc += Math.sin(20733) + Math.cos(20734) * 72;
+acc += Math.sin(20734) + Math.cos(20735) * 73;
+acc += Math.sin(20735) + Math.cos(20736) * 74;
+acc += Math.sin(20736) + Math.cos(20737) * 75;
+acc += Math.sin(20737) + Math.cos(20738) * 76;
+acc += Math.sin(20738) + Math.cos(20739) * 77;
+acc += Math.sin(20739) + Math.cos(20740) * 78;
+acc += Math.sin(20740) + Math.cos(20741) * 79;
+acc += Math.sin(20741) + Math.cos(20742) * 80;
+acc += Math.sin(20742) + Math.cos(20743) * 81;
+acc += Math.sin(20743) + Math.cos(20744) * 82;
+acc += Math.sin(20744) + Math.cos(20745) * 83;
+acc += Math.sin(20745) + Math.cos(20746) * 84;
+acc += Math.sin(20746) + Math.cos(20747) * 85;
+acc += Math.sin(20747) + Math.cos(20748) * 86;
+acc += Math.sin(20748) + Math.cos(20749) * 87;
+acc += Math.sin(20749) + Math.cos(20750) * 88;
+acc += Math.sin(20750) + Math.cos(20751) * 89;
+acc += Math.sin(20751) + Math.cos(20752) * 90;
+acc += Math.sin(20752) + Math.cos(20753) * 91;
+acc += Math.sin(20753) + Math.cos(20754) * 92;
+acc += Math.sin(20754) + Math.cos(20755) * 93;
+acc += Math.sin(20755) + Math.cos(20756) * 94;
+acc += Math.sin(20756) + Math.cos(20757) * 95;
+acc += Math.sin(20757) + Math.cos(20758) * 96;
+acc += Math.sin(20758) + Math.cos(20759) * 0;
+acc += Math.sin(20759) + Math.cos(20760) * 1;
+acc += Math.sin(20760) + Math.cos(20761) * 2;
+acc += Math.sin(20761) + Math.cos(20762) * 3;
+acc += Math.sin(20762) + Math.cos(20763) * 4;
+acc += Math.sin(20763) + Math.cos(20764) * 5;
+acc += Math.sin(20764) + Math.cos(20765) * 6;
+acc += Math.sin(20765) + Math.cos(20766) * 7;
+acc += Math.sin(20766) + Math.cos(20767) * 8;
+acc += Math.sin(20767) + Math.cos(20768) * 9;
+acc += Math.sin(20768) + Math.cos(20769) * 10;
+acc += Math.sin(20769) + Math.cos(20770) * 11;
+acc += Math.sin(20770) + Math.cos(20771) * 12;
+acc += Math.sin(20771) + Math.cos(20772) * 13;
+acc += Math.sin(20772) + Math.cos(20773) * 14;
+acc += Math.sin(20773) + Math.cos(20774) * 15;
+acc += Math.sin(20774) + Math.cos(20775) * 16;
+acc += Math.sin(20775) + Math.cos(20776) * 17;
+acc += Math.sin(20776) + Math.cos(20777) * 18;
+acc += Math.sin(20777) + Math.cos(20778) * 19;
+acc += Math.sin(20778) + Math.cos(20779) * 20;
+acc += Math.sin(20779) + Math.cos(20780) * 21;
+acc += Math.sin(20780) + Math.cos(20781) * 22;
+acc += Math.sin(20781) + Math.cos(20782) * 23;
+acc += Math.sin(20782) + Math.cos(20783) * 24;
+acc += Math.sin(20783) + Math.cos(20784) * 25;
+acc += Math.sin(20784) + Math.cos(20785) * 26;
+acc += Math.sin(20785) + Math.cos(20786) * 27;
+acc += Math.sin(20786) + Math.cos(20787) * 28;
+acc += Math.sin(20787) + Math.cos(20788) * 29;
+acc += Math.sin(20788) + Math.cos(20789) * 30;
+acc += Math.sin(20789) + Math.cos(20790) * 31;
+acc += Math.sin(20790) + Math.cos(20791) * 32;
+acc += Math.sin(20791) + Math.cos(20792) * 33;
+acc += Math.sin(20792) + Math.cos(20793) * 34;
+acc += Math.sin(20793) + Math.cos(20794) * 35;
+acc += Math.sin(20794) + Math.cos(20795) * 36;
+acc += Math.sin(20795) + Math.cos(20796) * 37;
+acc += Math.sin(20796) + Math.cos(20797) * 38;
+acc += Math.sin(20797) + Math.cos(20798) * 39;
+acc += Math.sin(20798) + Math.cos(20799) * 40;
+acc += Math.sin(20799) + Math.cos(20800) * 41;
+acc += Math.sin(20800) + Math.cos(20801) * 42;
+acc += Math.sin(20801) + Math.cos(20802) * 43;
+acc += Math.sin(20802) + Math.cos(20803) * 44;
+acc += Math.sin(20803) + Math.cos(20804) * 45;
+acc += Math.sin(20804) + Math.cos(20805) * 46;
+acc += Math.sin(20805) + Math.cos(20806) * 47;
+acc += Math.sin(20806) + Math.cos(20807) * 48;
+acc += Math.sin(20807) + Math.cos(20808) * 49;
+acc += Math.sin(20808) + Math.cos(20809) * 50;
+acc += Math.sin(20809) + Math.cos(20810) * 51;
+acc += Math.sin(20810) + Math.cos(20811) * 52;
+acc += Math.sin(20811) + Math.cos(20812) * 53;
+acc += Math.sin(20812) + Math.cos(20813) * 54;
+acc += Math.sin(20813) + Math.cos(20814) * 55;
+acc += Math.sin(20814) + Math.cos(20815) * 56;
+acc += Math.sin(20815) + Math.cos(20816) * 57;
+acc += Math.sin(20816) + Math.cos(20817) * 58;
+acc += Math.sin(20817) + Math.cos(20818) * 59;
+acc += Math.sin(20818) + Math.cos(20819) * 60;
+acc += Math.sin(20819) + Math.cos(20820) * 61;
+acc += Math.sin(20820) + Math.cos(20821) * 62;
+acc += Math.sin(20821) + Math.cos(20822) * 63;
+acc += Math.sin(20822) + Math.cos(20823) * 64;
+acc += Math.sin(20823) + Math.cos(20824) * 65;
+acc += Math.sin(20824) + Math.cos(20825) * 66;
+acc += Math.sin(20825) + Math.cos(20826) * 67;
+acc += Math.sin(20826) + Math.cos(20827) * 68;
+acc += Math.sin(20827) + Math.cos(20828) * 69;
+acc += Math.sin(20828) + Math.cos(20829) * 70;
+acc += Math.sin(20829) + Math.cos(20830) * 71;
+acc += Math.sin(20830) + Math.cos(20831) * 72;
+acc += Math.sin(20831) + Math.cos(20832) * 73;
+acc += Math.sin(20832) + Math.cos(20833) * 74;
+acc += Math.sin(20833) + Math.cos(20834) * 75;
+acc += Math.sin(20834) + Math.cos(20835) * 76;
+acc += Math.sin(20835) + Math.cos(20836) * 77;
+acc += Math.sin(20836) + Math.cos(20837) * 78;
+acc += Math.sin(20837) + Math.cos(20838) * 79;
+acc += Math.sin(20838) + Math.cos(20839) * 80;
+acc += Math.sin(20839) + Math.cos(20840) * 81;
+acc += Math.sin(20840) + Math.cos(20841) * 82;
+acc += Math.sin(20841) + Math.cos(20842) * 83;
+acc += Math.sin(20842) + Math.cos(20843) * 84;
+acc += Math.sin(20843) + Math.cos(20844) * 85;
+acc += Math.sin(20844) + Math.cos(20845) * 86;
+acc += Math.sin(20845) + Math.cos(20846) * 87;
+acc += Math.sin(20846) + Math.cos(20847) * 88;
+acc += Math.sin(20847) + Math.cos(20848) * 89;
+acc += Math.sin(20848) + Math.cos(20849) * 90;
+acc += Math.sin(20849) + Math.cos(20850) * 91;
+acc += Math.sin(20850) + Math.cos(20851) * 92;
+acc += Math.sin(20851) + Math.cos(20852) * 93;
+acc += Math.sin(20852) + Math.cos(20853) * 94;
+acc += Math.sin(20853) + Math.cos(20854) * 95;
+acc += Math.sin(20854) + Math.cos(20855) * 96;
+acc += Math.sin(20855) + Math.cos(20856) * 0;
+acc += Math.sin(20856) + Math.cos(20857) * 1;
+acc += Math.sin(20857) + Math.cos(20858) * 2;
+acc += Math.sin(20858) + Math.cos(20859) * 3;
+acc += Math.sin(20859) + Math.cos(20860) * 4;
+acc += Math.sin(20860) + Math.cos(20861) * 5;
+acc += Math.sin(20861) + Math.cos(20862) * 6;
+acc += Math.sin(20862) + Math.cos(20863) * 7;
+acc += Math.sin(20863) + Math.cos(20864) * 8;
+acc += Math.sin(20864) + Math.cos(20865) * 9;
+acc += Math.sin(20865) + Math.cos(20866) * 10;
+acc += Math.sin(20866) + Math.cos(20867) * 11;
+acc += Math.sin(20867) + Math.cos(20868) * 12;
+acc += Math.sin(20868) + Math.cos(20869) * 13;
+acc += Math.sin(20869) + Math.cos(20870) * 14;
+acc += Math.sin(20870) + Math.cos(20871) * 15;
+acc += Math.sin(20871) + Math.cos(20872) * 16;
+acc += Math.sin(20872) + Math.cos(20873) * 17;
+acc += Math.sin(20873) + Math.cos(20874) * 18;
+acc += Math.sin(20874) + Math.cos(20875) * 19;
+acc += Math.sin(20875) + Math.cos(20876) * 20;
+acc += Math.sin(20876) + Math.cos(20877) * 21;
+acc += Math.sin(20877) + Math.cos(20878) * 22;
+acc += Math.sin(20878) + Math.cos(20879) * 23;
+acc += Math.sin(20879) + Math.cos(20880) * 24;
+acc += Math.sin(20880) + Math.cos(20881) * 25;
+acc += Math.sin(20881) + Math.cos(20882) * 26;
+acc += Math.sin(20882) + Math.cos(20883) * 27;
+acc += Math.sin(20883) + Math.cos(20884) * 28;
+acc += Math.sin(20884) + Math.cos(20885) * 29;
+acc += Math.sin(20885) + Math.cos(20886) * 30;
+acc += Math.sin(20886) + Math.cos(20887) * 31;
+acc += Math.sin(20887) + Math.cos(20888) * 32;
+acc += Math.sin(20888) + Math.cos(20889) * 33;
+acc += Math.sin(20889) + Math.cos(20890) * 34;
+acc += Math.sin(20890) + Math.cos(20891) * 35;
+acc += Math.sin(20891) + Math.cos(20892) * 36;
+acc += Math.sin(20892) + Math.cos(20893) * 37;
+acc += Math.sin(20893) + Math.cos(20894) * 38;
+acc += Math.sin(20894) + Math.cos(20895) * 39;
+acc += Math.sin(20895) + Math.cos(20896) * 40;
+acc += Math.sin(20896) + Math.cos(20897) * 41;
+acc += Math.sin(20897) + Math.cos(20898) * 42;
+acc += Math.sin(20898) + Math.cos(20899) * 43;
+acc += Math.sin(20899) + Math.cos(20900) * 44;
+acc += Math.sin(20900) + Math.cos(20901) * 45;
+acc += Math.sin(20901) + Math.cos(20902) * 46;
+acc += Math.sin(20902) + Math.cos(20903) * 47;
+acc += Math.sin(20903) + Math.cos(20904) * 48;
+acc += Math.sin(20904) + Math.cos(20905) * 49;
+acc += Math.sin(20905) + Math.cos(20906) * 50;
+acc += Math.sin(20906) + Math.cos(20907) * 51;
+acc += Math.sin(20907) + Math.cos(20908) * 52;
+acc += Math.sin(20908) + Math.cos(20909) * 53;
+acc += Math.sin(20909) + Math.cos(20910) * 54;
+acc += Math.sin(20910) + Math.cos(20911) * 55;
+acc += Math.sin(20911) + Math.cos(20912) * 56;
+acc += Math.sin(20912) + Math.cos(20913) * 57;
+acc += Math.sin(20913) + Math.cos(20914) * 58;
+acc += Math.sin(20914) + Math.cos(20915) * 59;
+acc += Math.sin(20915) + Math.cos(20916) * 60;
+acc += Math.sin(20916) + Math.cos(20917) * 61;
+acc += Math.sin(20917) + Math.cos(20918) * 62;
+acc += Math.sin(20918) + Math.cos(20919) * 63;
+acc += Math.sin(20919) + Math.cos(20920) * 64;
+acc += Math.sin(20920) + Math.cos(20921) * 65;
+acc += Math.sin(20921) + Math.cos(20922) * 66;
+acc += Math.sin(20922) + Math.cos(20923) * 67;
+acc += Math.sin(20923) + Math.cos(20924) * 68;
+acc += Math.sin(20924) + Math.cos(20925) * 69;
+acc += Math.sin(20925) + Math.cos(20926) * 70;
+acc += Math.sin(20926) + Math.cos(20927) * 71;
+acc += Math.sin(20927) + Math.cos(20928) * 72;
+acc += Math.sin(20928) + Math.cos(20929) * 73;
+acc += Math.sin(20929) + Math.cos(20930) * 74;
+acc += Math.sin(20930) + Math.cos(20931) * 75;
+acc += Math.sin(20931) + Math.cos(20932) * 76;
+acc += Math.sin(20932) + Math.cos(20933) * 77;
+acc += Math.sin(20933) + Math.cos(20934) * 78;
+acc += Math.sin(20934) + Math.cos(20935) * 79;
+acc += Math.sin(20935) + Math.cos(20936) * 80;
+acc += Math.sin(20936) + Math.cos(20937) * 81;
+acc += Math.sin(20937) + Math.cos(20938) * 82;
+acc += Math.sin(20938) + Math.cos(20939) * 83;
+acc += Math.sin(20939) + Math.cos(20940) * 84;
+acc += Math.sin(20940) + Math.cos(20941) * 85;
+acc += Math.sin(20941) + Math.cos(20942) * 86;
+acc += Math.sin(20942) + Math.cos(20943) * 87;
+acc += Math.sin(20943) + Math.cos(20944) * 88;
+acc += Math.sin(20944) + Math.cos(20945) * 89;
+acc += Math.sin(20945) + Math.cos(20946) * 90;
+acc += Math.sin(20946) + Math.cos(20947) * 91;
+acc += Math.sin(20947) + Math.cos(20948) * 92;
+acc += Math.sin(20948) + Math.cos(20949) * 93;
+acc += Math.sin(20949) + Math.cos(20950) * 94;
+acc += Math.sin(20950) + Math.cos(20951) * 95;
+acc += Math.sin(20951) + Math.cos(20952) * 96;
+acc += Math.sin(20952) + Math.cos(20953) * 0;
+acc += Math.sin(20953) + Math.cos(20954) * 1;
+acc += Math.sin(20954) + Math.cos(20955) * 2;
+acc += Math.sin(20955) + Math.cos(20956) * 3;
+acc += Math.sin(20956) + Math.cos(20957) * 4;
+acc += Math.sin(20957) + Math.cos(20958) * 5;
+acc += Math.sin(20958) + Math.cos(20959) * 6;
+acc += Math.sin(20959) + Math.cos(20960) * 7;
+acc += Math.sin(20960) + Math.cos(20961) * 8;
+acc += Math.sin(20961) + Math.cos(20962) * 9;
+acc += Math.sin(20962) + Math.cos(20963) * 10;
+acc += Math.sin(20963) + Math.cos(20964) * 11;
+acc += Math.sin(20964) + Math.cos(20965) * 12;
+acc += Math.sin(20965) + Math.cos(20966) * 13;
+acc += Math.sin(20966) + Math.cos(20967) * 14;
+acc += Math.sin(20967) + Math.cos(20968) * 15;
+acc += Math.sin(20968) + Math.cos(20969) * 16;
+acc += Math.sin(20969) + Math.cos(20970) * 17;
+acc += Math.sin(20970) + Math.cos(20971) * 18;
+acc += Math.sin(20971) + Math.cos(20972) * 19;
+acc += Math.sin(20972) + Math.cos(20973) * 20;
+acc += Math.sin(20973) + Math.cos(20974) * 21;
+acc += Math.sin(20974) + Math.cos(20975) * 22;
+acc += Math.sin(20975) + Math.cos(20976) * 23;
+acc += Math.sin(20976) + Math.cos(20977) * 24;
+acc += Math.sin(20977) + Math.cos(20978) * 25;
+acc += Math.sin(20978) + Math.cos(20979) * 26;
+acc += Math.sin(20979) + Math.cos(20980) * 27;
+acc += Math.sin(20980) + Math.cos(20981) * 28;
+acc += Math.sin(20981) + Math.cos(20982) * 29;
+acc += Math.sin(20982) + Math.cos(20983) * 30;
+acc += Math.sin(20983) + Math.cos(20984) * 31;
+acc += Math.sin(20984) + Math.cos(20985) * 32;
+acc += Math.sin(20985) + Math.cos(20986) * 33;
+acc += Math.sin(20986) + Math.cos(20987) * 34;
+acc += Math.sin(20987) + Math.cos(20988) * 35;
+acc += Math.sin(20988) + Math.cos(20989) * 36;
+acc += Math.sin(20989) + Math.cos(20990) * 37;
+acc += Math.sin(20990) + Math.cos(20991) * 38;
+acc += Math.sin(20991) + Math.cos(20992) * 39;
+acc += Math.sin(20992) + Math.cos(20993) * 40;
+acc += Math.sin(20993) + Math.cos(20994) * 41;
+acc += Math.sin(20994) + Math.cos(20995) * 42;
+acc += Math.sin(20995) + Math.cos(20996) * 43;
+acc += Math.sin(20996) + Math.cos(20997) * 44;
+acc += Math.sin(20997) + Math.cos(20998) * 45;
+acc += Math.sin(20998) + Math.cos(20999) * 46;
+acc += Math.sin(20999) + Math.cos(21000) * 47;
+acc += Math.sin(21000) + Math.cos(21001) * 48;
+acc += Math.sin(21001) + Math.cos(21002) * 49;
+acc += Math.sin(21002) + Math.cos(21003) * 50;
+acc += Math.sin(21003) + Math.cos(21004) * 51;
+acc += Math.sin(21004) + Math.cos(21005) * 52;
+acc += Math.sin(21005) + Math.cos(21006) * 53;
+acc += Math.sin(21006) + Math.cos(21007) * 54;
+acc += Math.sin(21007) + Math.cos(21008) * 55;
+acc += Math.sin(21008) + Math.cos(21009) * 56;
+acc += Math.sin(21009) + Math.cos(21010) * 57;
+acc += Math.sin(21010) + Math.cos(21011) * 58;
+acc += Math.sin(21011) + Math.cos(21012) * 59;
+acc += Math.sin(21012) + Math.cos(21013) * 60;
+acc += Math.sin(21013) + Math.cos(21014) * 61;
+acc += Math.sin(21014) + Math.cos(21015) * 62;
+acc += Math.sin(21015) + Math.cos(21016) * 63;
+acc += Math.sin(21016) + Math.cos(21017) * 64;
+acc += Math.sin(21017) + Math.cos(21018) * 65;
+acc += Math.sin(21018) + Math.cos(21019) * 66;
+acc += Math.sin(21019) + Math.cos(21020) * 67;
+acc += Math.sin(21020) + Math.cos(21021) * 68;
+acc += Math.sin(21021) + Math.cos(21022) * 69;
+acc += Math.sin(21022) + Math.cos(21023) * 70;
+acc += Math.sin(21023) + Math.cos(21024) * 71;
+acc += Math.sin(21024) + Math.cos(21025) * 72;
+acc += Math.sin(21025) + Math.cos(21026) * 73;
+acc += Math.sin(21026) + Math.cos(21027) * 74;
+acc += Math.sin(21027) + Math.cos(21028) * 75;
+acc += Math.sin(21028) + Math.cos(21029) * 76;
+acc += Math.sin(21029) + Math.cos(21030) * 77;
+acc += Math.sin(21030) + Math.cos(21031) * 78;
+acc += Math.sin(21031) + Math.cos(21032) * 79;
+acc += Math.sin(21032) + Math.cos(21033) * 80;
+acc += Math.sin(21033) + Math.cos(21034) * 81;
+acc += Math.sin(21034) + Math.cos(21035) * 82;
+acc += Math.sin(21035) + Math.cos(21036) * 83;
+acc += Math.sin(21036) + Math.cos(21037) * 84;
+acc += Math.sin(21037) + Math.cos(21038) * 85;
+acc += Math.sin(21038) + Math.cos(21039) * 86;
+acc += Math.sin(21039) + Math.cos(21040) * 87;
+acc += Math.sin(21040) + Math.cos(21041) * 88;
+acc += Math.sin(21041) + Math.cos(21042) * 89;
+acc += Math.sin(21042) + Math.cos(21043) * 90;
+acc += Math.sin(21043) + Math.cos(21044) * 91;
+acc += Math.sin(21044) + Math.cos(21045) * 92;
+acc += Math.sin(21045) + Math.cos(21046) * 93;
+acc += Math.sin(21046) + Math.cos(21047) * 94;
+acc += Math.sin(21047) + Math.cos(21048) * 95;
+acc += Math.sin(21048) + Math.cos(21049) * 96;
+acc += Math.sin(21049) + Math.cos(21050) * 0;
+acc += Math.sin(21050) + Math.cos(21051) * 1;
+acc += Math.sin(21051) + Math.cos(21052) * 2;
+acc += Math.sin(21052) + Math.cos(21053) * 3;
+acc += Math.sin(21053) + Math.cos(21054) * 4;
+acc += Math.sin(21054) + Math.cos(21055) * 5;
+acc += Math.sin(21055) + Math.cos(21056) * 6;
+acc += Math.sin(21056) + Math.cos(21057) * 7;
+acc += Math.sin(21057) + Math.cos(21058) * 8;
+acc += Math.sin(21058) + Math.cos(21059) * 9;
+acc += Math.sin(21059) + Math.cos(21060) * 10;
+acc += Math.sin(21060) + Math.cos(21061) * 11;
+acc += Math.sin(21061) + Math.cos(21062) * 12;
+acc += Math.sin(21062) + Math.cos(21063) * 13;
+acc += Math.sin(21063) + Math.cos(21064) * 14;
+acc += Math.sin(21064) + Math.cos(21065) * 15;
+acc += Math.sin(21065) + Math.cos(21066) * 16;
+acc += Math.sin(21066) + Math.cos(21067) * 17;
+acc += Math.sin(21067) + Math.cos(21068) * 18;
+acc += Math.sin(21068) + Math.cos(21069) * 19;
+acc += Math.sin(21069) + Math.cos(21070) * 20;
+acc += Math.sin(21070) + Math.cos(21071) * 21;
+acc += Math.sin(21071) + Math.cos(21072) * 22;
+acc += Math.sin(21072) + Math.cos(21073) * 23;
+acc += Math.sin(21073) + Math.cos(21074) * 24;
+acc += Math.sin(21074) + Math.cos(21075) * 25;
+acc += Math.sin(21075) + Math.cos(21076) * 26;
+acc += Math.sin(21076) + Math.cos(21077) * 27;
+acc += Math.sin(21077) + Math.cos(21078) * 28;
+acc += Math.sin(21078) + Math.cos(21079) * 29;
+acc += Math.sin(21079) + Math.cos(21080) * 30;
+acc += Math.sin(21080) + Math.cos(21081) * 31;
+acc += Math.sin(21081) + Math.cos(21082) * 32;
+acc += Math.sin(21082) + Math.cos(21083) * 33;
+acc += Math.sin(21083) + Math.cos(21084) * 34;
+acc += Math.sin(21084) + Math.cos(21085) * 35;
+acc += Math.sin(21085) + Math.cos(21086) * 36;
+acc += Math.sin(21086) + Math.cos(21087) * 37;
+acc += Math.sin(21087) + Math.cos(21088) * 38;
+acc += Math.sin(21088) + Math.cos(21089) * 39;
+acc += Math.sin(21089) + Math.cos(21090) * 40;
+acc += Math.sin(21090) + Math.cos(21091) * 41;
+acc += Math.sin(21091) + Math.cos(21092) * 42;
+acc += Math.sin(21092) + Math.cos(21093) * 43;
+acc += Math.sin(21093) + Math.cos(21094) * 44;
+acc += Math.sin(21094) + Math.cos(21095) * 45;
+acc += Math.sin(21095) + Math.cos(21096) * 46;
+acc += Math.sin(21096) + Math.cos(21097) * 47;
+acc += Math.sin(21097) + Math.cos(21098) * 48;
+acc += Math.sin(21098) + Math.cos(21099) * 49;
+acc += Math.sin(21099) + Math.cos(21100) * 50;
+acc += Math.sin(21100) + Math.cos(21101) * 51;
+acc += Math.sin(21101) + Math.cos(21102) * 52;
+acc += Math.sin(21102) + Math.cos(21103) * 53;
+acc += Math.sin(21103) + Math.cos(21104) * 54;
+acc += Math.sin(21104) + Math.cos(21105) * 55;
+acc += Math.sin(21105) + Math.cos(21106) * 56;
+acc += Math.sin(21106) + Math.cos(21107) * 57;
+acc += Math.sin(21107) + Math.cos(21108) * 58;
+acc += Math.sin(21108) + Math.cos(21109) * 59;
+acc += Math.sin(21109) + Math.cos(21110) * 60;
+acc += Math.sin(21110) + Math.cos(21111) * 61;
+acc += Math.sin(21111) + Math.cos(21112) * 62;
+acc += Math.sin(21112) + Math.cos(21113) * 63;
+acc += Math.sin(21113) + Math.cos(21114) * 64;
+acc += Math.sin(21114) + Math.cos(21115) * 65;
+acc += Math.sin(21115) + Math.cos(21116) * 66;
+acc += Math.sin(21116) + Math.cos(21117) * 67;
+acc += Math.sin(21117) + Math.cos(21118) * 68;
+acc += Math.sin(21118) + Math.cos(21119) * 69;
+acc += Math.sin(21119) + Math.cos(21120) * 70;
+acc += Math.sin(21120) + Math.cos(21121) * 71;
+acc += Math.sin(21121) + Math.cos(21122) * 72;
+acc += Math.sin(21122) + Math.cos(21123) * 73;
+acc += Math.sin(21123) + Math.cos(21124) * 74;
+acc += Math.sin(21124) + Math.cos(21125) * 75;
+acc += Math.sin(21125) + Math.cos(21126) * 76;
+acc += Math.sin(21126) + Math.cos(21127) * 77;
+acc += Math.sin(21127) + Math.cos(21128) * 78;
+acc += Math.sin(21128) + Math.cos(21129) * 79;
+acc += Math.sin(21129) + Math.cos(21130) * 80;
+acc += Math.sin(21130) + Math.cos(21131) * 81;
+acc += Math.sin(21131) + Math.cos(21132) * 82;
+acc += Math.sin(21132) + Math.cos(21133) * 83;
+acc += Math.sin(21133) + Math.cos(21134) * 84;
+acc += Math.sin(21134) + Math.cos(21135) * 85;
+acc += Math.sin(21135) + Math.cos(21136) * 86;
+acc += Math.sin(21136) + Math.cos(21137) * 87;
+acc += Math.sin(21137) + Math.cos(21138) * 88;
+acc += Math.sin(21138) + Math.cos(21139) * 89;
+acc += Math.sin(21139) + Math.cos(21140) * 90;
+acc += Math.sin(21140) + Math.cos(21141) * 91;
+acc += Math.sin(21141) + Math.cos(21142) * 92;
+acc += Math.sin(21142) + Math.cos(21143) * 93;
+acc += Math.sin(21143) + Math.cos(21144) * 94;
+acc += Math.sin(21144) + Math.cos(21145) * 95;
+acc += Math.sin(21145) + Math.cos(21146) * 96;
+acc += Math.sin(21146) + Math.cos(21147) * 0;
+acc += Math.sin(21147) + Math.cos(21148) * 1;
+acc += Math.sin(21148) + Math.cos(21149) * 2;
+acc += Math.sin(21149) + Math.cos(21150) * 3;
+acc += Math.sin(21150) + Math.cos(21151) * 4;
+acc += Math.sin(21151) + Math.cos(21152) * 5;
+acc += Math.sin(21152) + Math.cos(21153) * 6;
+acc += Math.sin(21153) + Math.cos(21154) * 7;
+acc += Math.sin(21154) + Math.cos(21155) * 8;
+acc += Math.sin(21155) + Math.cos(21156) * 9;
+acc += Math.sin(21156) + Math.cos(21157) * 10;
+acc += Math.sin(21157) + Math.cos(21158) * 11;
+acc += Math.sin(21158) + Math.cos(21159) * 12;
+acc += Math.sin(21159) + Math.cos(21160) * 13;
+acc += Math.sin(21160) + Math.cos(21161) * 14;
+acc += Math.sin(21161) + Math.cos(21162) * 15;
+acc += Math.sin(21162) + Math.cos(21163) * 16;
+acc += Math.sin(21163) + Math.cos(21164) * 17;
+acc += Math.sin(21164) + Math.cos(21165) * 18;
+acc += Math.sin(21165) + Math.cos(21166) * 19;
+acc += Math.sin(21166) + Math.cos(21167) * 20;
+acc += Math.sin(21167) + Math.cos(21168) * 21;
+acc += Math.sin(21168) + Math.cos(21169) * 22;
+acc += Math.sin(21169) + Math.cos(21170) * 23;
+acc += Math.sin(21170) + Math.cos(21171) * 24;
+acc += Math.sin(21171) + Math.cos(21172) * 25;
+acc += Math.sin(21172) + Math.cos(21173) * 26;
+acc += Math.sin(21173) + Math.cos(21174) * 27;
+acc += Math.sin(21174) + Math.cos(21175) * 28;
+acc += Math.sin(21175) + Math.cos(21176) * 29;
+acc += Math.sin(21176) + Math.cos(21177) * 30;
+acc += Math.sin(21177) + Math.cos(21178) * 31;
+acc += Math.sin(21178) + Math.cos(21179) * 32;
+acc += Math.sin(21179) + Math.cos(21180) * 33;
+acc += Math.sin(21180) + Math.cos(21181) * 34;
+acc += Math.sin(21181) + Math.cos(21182) * 35;
+acc += Math.sin(21182) + Math.cos(21183) * 36;
+acc += Math.sin(21183) + Math.cos(21184) * 37;
+acc += Math.sin(21184) + Math.cos(21185) * 38;
+acc += Math.sin(21185) + Math.cos(21186) * 39;
+acc += Math.sin(21186) + Math.cos(21187) * 40;
+acc += Math.sin(21187) + Math.cos(21188) * 41;
+acc += Math.sin(21188) + Math.cos(21189) * 42;
+acc += Math.sin(21189) + Math.cos(21190) * 43;
+acc += Math.sin(21190) + Math.cos(21191) * 44;
+acc += Math.sin(21191) + Math.cos(21192) * 45;
+acc += Math.sin(21192) + Math.cos(21193) * 46;
+acc += Math.sin(21193) + Math.cos(21194) * 47;
+acc += Math.sin(21194) + Math.cos(21195) * 48;
+acc += Math.sin(21195) + Math.cos(21196) * 49;
+acc += Math.sin(21196) + Math.cos(21197) * 50;
+acc += Math.sin(21197) + Math.cos(21198) * 51;
+acc += Math.sin(21198) + Math.cos(21199) * 52;
+acc += Math.sin(21199) + Math.cos(21200) * 53;
+acc += Math.sin(21200) + Math.cos(21201) * 54;
+acc += Math.sin(21201) + Math.cos(21202) * 55;
+acc += Math.sin(21202) + Math.cos(21203) * 56;
+acc += Math.sin(21203) + Math.cos(21204) * 57;
+acc += Math.sin(21204) + Math.cos(21205) * 58;
+acc += Math.sin(21205) + Math.cos(21206) * 59;
+acc += Math.sin(21206) + Math.cos(21207) * 60;
+acc += Math.sin(21207) + Math.cos(21208) * 61;
+acc += Math.sin(21208) + Math.cos(21209) * 62;
+acc += Math.sin(21209) + Math.cos(21210) * 63;
+acc += Math.sin(21210) + Math.cos(21211) * 64;
+acc += Math.sin(21211) + Math.cos(21212) * 65;
+acc += Math.sin(21212) + Math.cos(21213) * 66;
+acc += Math.sin(21213) + Math.cos(21214) * 67;
+acc += Math.sin(21214) + Math.cos(21215) * 68;
+acc += Math.sin(21215) + Math.cos(21216) * 69;
+acc += Math.sin(21216) + Math.cos(21217) * 70;
+acc += Math.sin(21217) + Math.cos(21218) * 71;
+acc += Math.sin(21218) + Math.cos(21219) * 72;
+acc += Math.sin(21219) + Math.cos(21220) * 73;
+acc += Math.sin(21220) + Math.cos(21221) * 74;
+acc += Math.sin(21221) + Math.cos(21222) * 75;
+acc += Math.sin(21222) + Math.cos(21223) * 76;
+acc += Math.sin(21223) + Math.cos(21224) * 77;
+acc += Math.sin(21224) + Math.cos(21225) * 78;
+acc += Math.sin(21225) + Math.cos(21226) * 79;
+acc += Math.sin(21226) + Math.cos(21227) * 80;
+acc += Math.sin(21227) + Math.cos(21228) * 81;
+acc += Math.sin(21228) + Math.cos(21229) * 82;
+acc += Math.sin(21229) + Math.cos(21230) * 83;
+acc += Math.sin(21230) + Math.cos(21231) * 84;
+acc += Math.sin(21231) + Math.cos(21232) * 85;
+acc += Math.sin(21232) + Math.cos(21233) * 86;
+acc += Math.sin(21233) + Math.cos(21234) * 87;
+acc += Math.sin(21234) + Math.cos(21235) * 88;
+acc += Math.sin(21235) + Math.cos(21236) * 89;
+acc += Math.sin(21236) + Math.cos(21237) * 90;
+acc += Math.sin(21237) + Math.cos(21238) * 91;
+acc += Math.sin(21238) + Math.cos(21239) * 92;
+acc += Math.sin(21239) + Math.cos(21240) * 93;
+acc += Math.sin(21240) + Math.cos(21241) * 94;
+acc += Math.sin(21241) + Math.cos(21242) * 95;
+acc += Math.sin(21242) + Math.cos(21243) * 96;
+acc += Math.sin(21243) + Math.cos(21244) * 0;
+acc += Math.sin(21244) + Math.cos(21245) * 1;
+acc += Math.sin(21245) + Math.cos(21246) * 2;
+acc += Math.sin(21246) + Math.cos(21247) * 3;
+acc += Math.sin(21247) + Math.cos(21248) * 4;
+acc += Math.sin(21248) + Math.cos(21249) * 5;
+acc += Math.sin(21249) + Math.cos(21250) * 6;
+acc += Math.sin(21250) + Math.cos(21251) * 7;
+acc += Math.sin(21251) + Math.cos(21252) * 8;
+acc += Math.sin(21252) + Math.cos(21253) * 9;
+acc += Math.sin(21253) + Math.cos(21254) * 10;
+acc += Math.sin(21254) + Math.cos(21255) * 11;
+acc += Math.sin(21255) + Math.cos(21256) * 12;
+acc += Math.sin(21256) + Math.cos(21257) * 13;
+acc += Math.sin(21257) + Math.cos(21258) * 14;
+acc += Math.sin(21258) + Math.cos(21259) * 15;
+acc += Math.sin(21259) + Math.cos(21260) * 16;
+acc += Math.sin(21260) + Math.cos(21261) * 17;
+acc += Math.sin(21261) + Math.cos(21262) * 18;
+acc += Math.sin(21262) + Math.cos(21263) * 19;
+acc += Math.sin(21263) + Math.cos(21264) * 20;
+acc += Math.sin(21264) + Math.cos(21265) * 21;
+acc += Math.sin(21265) + Math.cos(21266) * 22;
+acc += Math.sin(21266) + Math.cos(21267) * 23;
+acc += Math.sin(21267) + Math.cos(21268) * 24;
+acc += Math.sin(21268) + Math.cos(21269) * 25;
+acc += Math.sin(21269) + Math.cos(21270) * 26;
+acc += Math.sin(21270) + Math.cos(21271) * 27;
+acc += Math.sin(21271) + Math.cos(21272) * 28;
+acc += Math.sin(21272) + Math.cos(21273) * 29;
+acc += Math.sin(21273) + Math.cos(21274) * 30;
+acc += Math.sin(21274) + Math.cos(21275) * 31;
+acc += Math.sin(21275) + Math.cos(21276) * 32;
+acc += Math.sin(21276) + Math.cos(21277) * 33;
+acc += Math.sin(21277) + Math.cos(21278) * 34;
+acc += Math.sin(21278) + Math.cos(21279) * 35;
+acc += Math.sin(21279) + Math.cos(21280) * 36;
+acc += Math.sin(21280) + Math.cos(21281) * 37;
+acc += Math.sin(21281) + Math.cos(21282) * 38;
+acc += Math.sin(21282) + Math.cos(21283) * 39;
+acc += Math.sin(21283) + Math.cos(21284) * 40;
+acc += Math.sin(21284) + Math.cos(21285) * 41;
+acc += Math.sin(21285) + Math.cos(21286) * 42;
+acc += Math.sin(21286) + Math.cos(21287) * 43;
+acc += Math.sin(21287) + Math.cos(21288) * 44;
+acc += Math.sin(21288) + Math.cos(21289) * 45;
+acc += Math.sin(21289) + Math.cos(21290) * 46;
+acc += Math.sin(21290) + Math.cos(21291) * 47;
+acc += Math.sin(21291) + Math.cos(21292) * 48;
+acc += Math.sin(21292) + Math.cos(21293) * 49;
+acc += Math.sin(21293) + Math.cos(21294) * 50;
+acc += Math.sin(21294) + Math.cos(21295) * 51;
+acc += Math.sin(21295) + Math.cos(21296) * 52;
+acc += Math.sin(21296) + Math.cos(21297) * 53;
+acc += Math.sin(21297) + Math.cos(21298) * 54;
+acc += Math.sin(21298) + Math.cos(21299) * 55;
+acc += Math.sin(21299) + Math.cos(21300) * 56;
+acc += Math.sin(21300) + Math.cos(21301) * 57;
+acc += Math.sin(21301) + Math.cos(21302) * 58;
+acc += Math.sin(21302) + Math.cos(21303) * 59;
+acc += Math.sin(21303) + Math.cos(21304) * 60;
+acc += Math.sin(21304) + Math.cos(21305) * 61;
+acc += Math.sin(21305) + Math.cos(21306) * 62;
+acc += Math.sin(21306) + Math.cos(21307) * 63;
+acc += Math.sin(21307) + Math.cos(21308) * 64;
+acc += Math.sin(21308) + Math.cos(21309) * 65;
+acc += Math.sin(21309) + Math.cos(21310) * 66;
+acc += Math.sin(21310) + Math.cos(21311) * 67;
+acc += Math.sin(21311) + Math.cos(21312) * 68;
+acc += Math.sin(21312) + Math.cos(21313) * 69;
+acc += Math.sin(21313) + Math.cos(21314) * 70;
+acc += Math.sin(21314) + Math.cos(21315) * 71;
+acc += Math.sin(21315) + Math.cos(21316) * 72;
+acc += Math.sin(21316) + Math.cos(21317) * 73;
+acc += Math.sin(21317) + Math.cos(21318) * 74;
+acc += Math.sin(21318) + Math.cos(21319) * 75;
+acc += Math.sin(21319) + Math.cos(21320) * 76;
+acc += Math.sin(21320) + Math.cos(21321) * 77;
+acc += Math.sin(21321) + Math.cos(21322) * 78;
+acc += Math.sin(21322) + Math.cos(21323) * 79;
+acc += Math.sin(21323) + Math.cos(21324) * 80;
+acc += Math.sin(21324) + Math.cos(21325) * 81;
+acc += Math.sin(21325) + Math.cos(21326) * 82;
+acc += Math.sin(21326) + Math.cos(21327) * 83;
+acc += Math.sin(21327) + Math.cos(21328) * 84;
+acc += Math.sin(21328) + Math.cos(21329) * 85;
+acc += Math.sin(21329) + Math.cos(21330) * 86;
+acc += Math.sin(21330) + Math.cos(21331) * 87;
+acc += Math.sin(21331) + Math.cos(21332) * 88;
+acc += Math.sin(21332) + Math.cos(21333) * 89;
+acc += Math.sin(21333) + Math.cos(21334) * 90;
+acc += Math.sin(21334) + Math.cos(21335) * 91;
+acc += Math.sin(21335) + Math.cos(21336) * 92;
+acc += Math.sin(21336) + Math.cos(21337) * 93;
+acc += Math.sin(21337) + Math.cos(21338) * 94;
+acc += Math.sin(21338) + Math.cos(21339) * 95;
+acc += Math.sin(21339) + Math.cos(21340) * 96;
+acc += Math.sin(21340) + Math.cos(21341) * 0;
+acc += Math.sin(21341) + Math.cos(21342) * 1;
+acc += Math.sin(21342) + Math.cos(21343) * 2;
+acc += Math.sin(21343) + Math.cos(21344) * 3;
+acc += Math.sin(21344) + Math.cos(21345) * 4;
+acc += Math.sin(21345) + Math.cos(21346) * 5;
+acc += Math.sin(21346) + Math.cos(21347) * 6;
+acc += Math.sin(21347) + Math.cos(21348) * 7;
+acc += Math.sin(21348) + Math.cos(21349) * 8;
+acc += Math.sin(21349) + Math.cos(21350) * 9;
+acc += Math.sin(21350) + Math.cos(21351) * 10;
+acc += Math.sin(21351) + Math.cos(21352) * 11;
+acc += Math.sin(21352) + Math.cos(21353) * 12;
+acc += Math.sin(21353) + Math.cos(21354) * 13;
+acc += Math.sin(21354) + Math.cos(21355) * 14;
+acc += Math.sin(21355) + Math.cos(21356) * 15;
+acc += Math.sin(21356) + Math.cos(21357) * 16;
+acc += Math.sin(21357) + Math.cos(21358) * 17;
+acc += Math.sin(21358) + Math.cos(21359) * 18;
+acc += Math.sin(21359) + Math.cos(21360) * 19;
+acc += Math.sin(21360) + Math.cos(21361) * 20;
+acc += Math.sin(21361) + Math.cos(21362) * 21;
+acc += Math.sin(21362) + Math.cos(21363) * 22;
+acc += Math.sin(21363) + Math.cos(21364) * 23;
+acc += Math.sin(21364) + Math.cos(21365) * 24;
+acc += Math.sin(21365) + Math.cos(21366) * 25;
+acc += Math.sin(21366) + Math.cos(21367) * 26;
+acc += Math.sin(21367) + Math.cos(21368) * 27;
+acc += Math.sin(21368) + Math.cos(21369) * 28;
+acc += Math.sin(21369) + Math.cos(21370) * 29;
+acc += Math.sin(21370) + Math.cos(21371) * 30;
+acc += Math.sin(21371) + Math.cos(21372) * 31;
+acc += Math.sin(21372) + Math.cos(21373) * 32;
+acc += Math.sin(21373) + Math.cos(21374) * 33;
+acc += Math.sin(21374) + Math.cos(21375) * 34;
+acc += Math.sin(21375) + Math.cos(21376) * 35;
+acc += Math.sin(21376) + Math.cos(21377) * 36;
+acc += Math.sin(21377) + Math.cos(21378) * 37;
+acc += Math.sin(21378) + Math.cos(21379) * 38;
+acc += Math.sin(21379) + Math.cos(21380) * 39;
+acc += Math.sin(21380) + Math.cos(21381) * 40;
+acc += Math.sin(21381) + Math.cos(21382) * 41;
+acc += Math.sin(21382) + Math.cos(21383) * 42;
+acc += Math.sin(21383) + Math.cos(21384) * 43;
+acc += Math.sin(21384) + Math.cos(21385) * 44;
+acc += Math.sin(21385) + Math.cos(21386) * 45;
+acc += Math.sin(21386) + Math.cos(21387) * 46;
+acc += Math.sin(21387) + Math.cos(21388) * 47;
+acc += Math.sin(21388) + Math.cos(21389) * 48;
+acc += Math.sin(21389) + Math.cos(21390) * 49;
+acc += Math.sin(21390) + Math.cos(21391) * 50;
+acc += Math.sin(21391) + Math.cos(21392) * 51;
+acc += Math.sin(21392) + Math.cos(21393) * 52;
+acc += Math.sin(21393) + Math.cos(21394) * 53;
+acc += Math.sin(21394) + Math.cos(21395) * 54;
+acc += Math.sin(21395) + Math.cos(21396) * 55;
+acc += Math.sin(21396) + Math.cos(21397) * 56;
+acc += Math.sin(21397) + Math.cos(21398) * 57;
+acc += Math.sin(21398) + Math.cos(21399) * 58;
+acc += Math.sin(21399) + Math.cos(21400) * 59;
+acc += Math.sin(21400) + Math.cos(21401) * 60;
+acc += Math.sin(21401) + Math.cos(21402) * 61;
+acc += Math.sin(21402) + Math.cos(21403) * 62;
+acc += Math.sin(21403) + Math.cos(21404) * 63;
+acc += Math.sin(21404) + Math.cos(21405) * 64;
+acc += Math.sin(21405) + Math.cos(21406) * 65;
+acc += Math.sin(21406) + Math.cos(21407) * 66;
+acc += Math.sin(21407) + Math.cos(21408) * 67;
+acc += Math.sin(21408) + Math.cos(21409) * 68;
+acc += Math.sin(21409) + Math.cos(21410) * 69;
+acc += Math.sin(21410) + Math.cos(21411) * 70;
+acc += Math.sin(21411) + Math.cos(21412) * 71;
+acc += Math.sin(21412) + Math.cos(21413) * 72;
+acc += Math.sin(21413) + Math.cos(21414) * 73;
+acc += Math.sin(21414) + Math.cos(21415) * 74;
+acc += Math.sin(21415) + Math.cos(21416) * 75;
+acc += Math.sin(21416) + Math.cos(21417) * 76;
+acc += Math.sin(21417) + Math.cos(21418) * 77;
+acc += Math.sin(21418) + Math.cos(21419) * 78;
+acc += Math.sin(21419) + Math.cos(21420) * 79;
+acc += Math.sin(21420) + Math.cos(21421) * 80;
+acc += Math.sin(21421) + Math.cos(21422) * 81;
+acc += Math.sin(21422) + Math.cos(21423) * 82;
+acc += Math.sin(21423) + Math.cos(21424) * 83;
+acc += Math.sin(21424) + Math.cos(21425) * 84;
+acc += Math.sin(21425) + Math.cos(21426) * 85;
+acc += Math.sin(21426) + Math.cos(21427) * 86;
+acc += Math.sin(21427) + Math.cos(21428) * 87;
+acc += Math.sin(21428) + Math.cos(21429) * 88;
+acc += Math.sin(21429) + Math.cos(21430) * 89;
+acc += Math.sin(21430) + Math.cos(21431) * 90;
+acc += Math.sin(21431) + Math.cos(21432) * 91;
+acc += Math.sin(21432) + Math.cos(21433) * 92;
+acc += Math.sin(21433) + Math.cos(21434) * 93;
+acc += Math.sin(21434) + Math.cos(21435) * 94;
+acc += Math.sin(21435) + Math.cos(21436) * 95;
+acc += Math.sin(21436) + Math.cos(21437) * 96;
+acc += Math.sin(21437) + Math.cos(21438) * 0;
+acc += Math.sin(21438) + Math.cos(21439) * 1;
+acc += Math.sin(21439) + Math.cos(21440) * 2;
+acc += Math.sin(21440) + Math.cos(21441) * 3;
+acc += Math.sin(21441) + Math.cos(21442) * 4;
+acc += Math.sin(21442) + Math.cos(21443) * 5;
+acc += Math.sin(21443) + Math.cos(21444) * 6;
+acc += Math.sin(21444) + Math.cos(21445) * 7;
+acc += Math.sin(21445) + Math.cos(21446) * 8;
+acc += Math.sin(21446) + Math.cos(21447) * 9;
+acc += Math.sin(21447) + Math.cos(21448) * 10;
+acc += Math.sin(21448) + Math.cos(21449) * 11;
+acc += Math.sin(21449) + Math.cos(21450) * 12;
+acc += Math.sin(21450) + Math.cos(21451) * 13;
+acc += Math.sin(21451) + Math.cos(21452) * 14;
+acc += Math.sin(21452) + Math.cos(21453) * 15;
+acc += Math.sin(21453) + Math.cos(21454) * 16;
+acc += Math.sin(21454) + Math.cos(21455) * 17;
+acc += Math.sin(21455) + Math.cos(21456) * 18;
+acc += Math.sin(21456) + Math.cos(21457) * 19;
+acc += Math.sin(21457) + Math.cos(21458) * 20;
+acc += Math.sin(21458) + Math.cos(21459) * 21;
+acc += Math.sin(21459) + Math.cos(21460) * 22;
+acc += Math.sin(21460) + Math.cos(21461) * 23;
+acc += Math.sin(21461) + Math.cos(21462) * 24;
+acc += Math.sin(21462) + Math.cos(21463) * 25;
+acc += Math.sin(21463) + Math.cos(21464) * 26;
+acc += Math.sin(21464) + Math.cos(21465) * 27;
+acc += Math.sin(21465) + Math.cos(21466) * 28;
+acc += Math.sin(21466) + Math.cos(21467) * 29;
+acc += Math.sin(21467) + Math.cos(21468) * 30;
+acc += Math.sin(21468) + Math.cos(21469) * 31;
+acc += Math.sin(21469) + Math.cos(21470) * 32;
+acc += Math.sin(21470) + Math.cos(21471) * 33;
+acc += Math.sin(21471) + Math.cos(21472) * 34;
+acc += Math.sin(21472) + Math.cos(21473) * 35;
+acc += Math.sin(21473) + Math.cos(21474) * 36;
+acc += Math.sin(21474) + Math.cos(21475) * 37;
+acc += Math.sin(21475) + Math.cos(21476) * 38;
+acc += Math.sin(21476) + Math.cos(21477) * 39;
+acc += Math.sin(21477) + Math.cos(21478) * 40;
+acc += Math.sin(21478) + Math.cos(21479) * 41;
+acc += Math.sin(21479) + Math.cos(21480) * 42;
+acc += Math.sin(21480) + Math.cos(21481) * 43;
+acc += Math.sin(21481) + Math.cos(21482) * 44;
+acc += Math.sin(21482) + Math.cos(21483) * 45;
+acc += Math.sin(21483) + Math.cos(21484) * 46;
+acc += Math.sin(21484) + Math.cos(21485) * 47;
+acc += Math.sin(21485) + Math.cos(21486) * 48;
+acc += Math.sin(21486) + Math.cos(21487) * 49;
+acc += Math.sin(21487) + Math.cos(21488) * 50;
+acc += Math.sin(21488) + Math.cos(21489) * 51;
+acc += Math.sin(21489) + Math.cos(21490) * 52;
+acc += Math.sin(21490) + Math.cos(21491) * 53;
+acc += Math.sin(21491) + Math.cos(21492) * 54;
+acc += Math.sin(21492) + Math.cos(21493) * 55;
+acc += Math.sin(21493) + Math.cos(21494) * 56;
+acc += Math.sin(21494) + Math.cos(21495) * 57;
+acc += Math.sin(21495) + Math.cos(21496) * 58;
+acc += Math.sin(21496) + Math.cos(21497) * 59;
+acc += Math.sin(21497) + Math.cos(21498) * 60;
+acc += Math.sin(21498) + Math.cos(21499) * 61;
+acc += Math.sin(21499) + Math.cos(21500) * 62;
+acc += Math.sin(21500) + Math.cos(21501) * 63;
+acc += Math.sin(21501) + Math.cos(21502) * 64;
+acc += Math.sin(21502) + Math.cos(21503) * 65;
+acc += Math.sin(21503) + Math.cos(21504) * 66;
+acc += Math.sin(21504) + Math.cos(21505) * 67;
+acc += Math.sin(21505) + Math.cos(21506) * 68;
+acc += Math.sin(21506) + Math.cos(21507) * 69;
+acc += Math.sin(21507) + Math.cos(21508) * 70;
+acc += Math.sin(21508) + Math.cos(21509) * 71;
+acc += Math.sin(21509) + Math.cos(21510) * 72;
+acc += Math.sin(21510) + Math.cos(21511) * 73;
+acc += Math.sin(21511) + Math.cos(21512) * 74;
+acc += Math.sin(21512) + Math.cos(21513) * 75;
+acc += Math.sin(21513) + Math.cos(21514) * 76;
+acc += Math.sin(21514) + Math.cos(21515) * 77;
+acc += Math.sin(21515) + Math.cos(21516) * 78;
+acc += Math.sin(21516) + Math.cos(21517) * 79;
+acc += Math.sin(21517) + Math.cos(21518) * 80;
+acc += Math.sin(21518) + Math.cos(21519) * 81;
+acc += Math.sin(21519) + Math.cos(21520) * 82;
+acc += Math.sin(21520) + Math.cos(21521) * 83;
+acc += Math.sin(21521) + Math.cos(21522) * 84;
+acc += Math.sin(21522) + Math.cos(21523) * 85;
+acc += Math.sin(21523) + Math.cos(21524) * 86;
+acc += Math.sin(21524) + Math.cos(21525) * 87;
+acc += Math.sin(21525) + Math.cos(21526) * 88;
+acc += Math.sin(21526) + Math.cos(21527) * 89;
+acc += Math.sin(21527) + Math.cos(21528) * 90;
+acc += Math.sin(21528) + Math.cos(21529) * 91;
+acc += Math.sin(21529) + Math.cos(21530) * 92;
+acc += Math.sin(21530) + Math.cos(21531) * 93;
+acc += Math.sin(21531) + Math.cos(21532) * 94;
+acc += Math.sin(21532) + Math.cos(21533) * 95;
+acc += Math.sin(21533) + Math.cos(21534) * 96;
+acc += Math.sin(21534) + Math.cos(21535) * 0;
+acc += Math.sin(21535) + Math.cos(21536) * 1;
+acc += Math.sin(21536) + Math.cos(21537) * 2;
+acc += Math.sin(21537) + Math.cos(21538) * 3;
+acc += Math.sin(21538) + Math.cos(21539) * 4;
+acc += Math.sin(21539) + Math.cos(21540) * 5;
+acc += Math.sin(21540) + Math.cos(21541) * 6;
+acc += Math.sin(21541) + Math.cos(21542) * 7;
+acc += Math.sin(21542) + Math.cos(21543) * 8;
+acc += Math.sin(21543) + Math.cos(21544) * 9;
+acc += Math.sin(21544) + Math.cos(21545) * 10;
+acc += Math.sin(21545) + Math.cos(21546) * 11;
+acc += Math.sin(21546) + Math.cos(21547) * 12;
+acc += Math.sin(21547) + Math.cos(21548) * 13;
+acc += Math.sin(21548) + Math.cos(21549) * 14;
+acc += Math.sin(21549) + Math.cos(21550) * 15;
+acc += Math.sin(21550) + Math.cos(21551) * 16;
+acc += Math.sin(21551) + Math.cos(21552) * 17;
+acc += Math.sin(21552) + Math.cos(21553) * 18;
+acc += Math.sin(21553) + Math.cos(21554) * 19;
+acc += Math.sin(21554) + Math.cos(21555) * 20;
+acc += Math.sin(21555) + Math.cos(21556) * 21;
+acc += Math.sin(21556) + Math.cos(21557) * 22;
+acc += Math.sin(21557) + Math.cos(21558) * 23;
+acc += Math.sin(21558) + Math.cos(21559) * 24;
+acc += Math.sin(21559) + Math.cos(21560) * 25;
+acc += Math.sin(21560) + Math.cos(21561) * 26;
+acc += Math.sin(21561) + Math.cos(21562) * 27;
+acc += Math.sin(21562) + Math.cos(21563) * 28;
+acc += Math.sin(21563) + Math.cos(21564) * 29;
+acc += Math.sin(21564) + Math.cos(21565) * 30;
+acc += Math.sin(21565) + Math.cos(21566) * 31;
+acc += Math.sin(21566) + Math.cos(21567) * 32;
+acc += Math.sin(21567) + Math.cos(21568) * 33;
+acc += Math.sin(21568) + Math.cos(21569) * 34;
+acc += Math.sin(21569) + Math.cos(21570) * 35;
+acc += Math.sin(21570) + Math.cos(21571) * 36;
+acc += Math.sin(21571) + Math.cos(21572) * 37;
+acc += Math.sin(21572) + Math.cos(21573) * 38;
+acc += Math.sin(21573) + Math.cos(21574) * 39;
+acc += Math.sin(21574) + Math.cos(21575) * 40;
+acc += Math.sin(21575) + Math.cos(21576) * 41;
+acc += Math.sin(21576) + Math.cos(21577) * 42;
+acc += Math.sin(21577) + Math.cos(21578) * 43;
+acc += Math.sin(21578) + Math.cos(21579) * 44;
+acc += Math.sin(21579) + Math.cos(21580) * 45;
+acc += Math.sin(21580) + Math.cos(21581) * 46;
+acc += Math.sin(21581) + Math.cos(21582) * 47;
+acc += Math.sin(21582) + Math.cos(21583) * 48;
+acc += Math.sin(21583) + Math.cos(21584) * 49;
+acc += Math.sin(21584) + Math.cos(21585) * 50;
+acc += Math.sin(21585) + Math.cos(21586) * 51;
+acc += Math.sin(21586) + Math.cos(21587) * 52;
+acc += Math.sin(21587) + Math.cos(21588) * 53;
+acc += Math.sin(21588) + Math.cos(21589) * 54;
+acc += Math.sin(21589) + Math.cos(21590) * 55;
+acc += Math.sin(21590) + Math.cos(21591) * 56;
+acc += Math.sin(21591) + Math.cos(21592) * 57;
+acc += Math.sin(21592) + Math.cos(21593) * 58;
+acc += Math.sin(21593) + Math.cos(21594) * 59;
+acc += Math.sin(21594) + Math.cos(21595) * 60;
+acc += Math.sin(21595) + Math.cos(21596) * 61;
+acc += Math.sin(21596) + Math.cos(21597) * 62;
+acc += Math.sin(21597) + Math.cos(21598) * 63;
+acc += Math.sin(21598) + Math.cos(21599) * 64;
+acc += Math.sin(21599) + Math.cos(21600) * 65;
+acc += Math.sin(21600) + Math.cos(21601) * 66;
+acc += Math.sin(21601) + Math.cos(21602) * 67;
+acc += Math.sin(21602) + Math.cos(21603) * 68;
+acc += Math.sin(21603) + Math.cos(21604) * 69;
+acc += Math.sin(21604) + Math.cos(21605) * 70;
+acc += Math.sin(21605) + Math.cos(21606) * 71;
+acc += Math.sin(21606) + Math.cos(21607) * 72;
+acc += Math.sin(21607) + Math.cos(21608) * 73;
+acc += Math.sin(21608) + Math.cos(21609) * 74;
+acc += Math.sin(21609) + Math.cos(21610) * 75;
+acc += Math.sin(21610) + Math.cos(21611) * 76;
+acc += Math.sin(21611) + Math.cos(21612) * 77;
+acc += Math.sin(21612) + Math.cos(21613) * 78;
+acc += Math.sin(21613) + Math.cos(21614) * 79;
+acc += Math.sin(21614) + Math.cos(21615) * 80;
+acc += Math.sin(21615) + Math.cos(21616) * 81;
+acc += Math.sin(21616) + Math.cos(21617) * 82;
+acc += Math.sin(21617) + Math.cos(21618) * 83;
+acc += Math.sin(21618) + Math.cos(21619) * 84;
+acc += Math.sin(21619) + Math.cos(21620) * 85;
+acc += Math.sin(21620) + Math.cos(21621) * 86;
+acc += Math.sin(21621) + Math.cos(21622) * 87;
+acc += Math.sin(21622) + Math.cos(21623) * 88;
+acc += Math.sin(21623) + Math.cos(21624) * 89;
+acc += Math.sin(21624) + Math.cos(21625) * 90;
+acc += Math.sin(21625) + Math.cos(21626) * 91;
+acc += Math.sin(21626) + Math.cos(21627) * 92;
+acc += Math.sin(21627) + Math.cos(21628) * 93;
+acc += Math.sin(21628) + Math.cos(21629) * 94;
+acc += Math.sin(21629) + Math.cos(21630) * 95;
+acc += Math.sin(21630) + Math.cos(21631) * 96;
+acc += Math.sin(21631) + Math.cos(21632) * 0;
+acc += Math.sin(21632) + Math.cos(21633) * 1;
+acc += Math.sin(21633) + Math.cos(21634) * 2;
+acc += Math.sin(21634) + Math.cos(21635) * 3;
+acc += Math.sin(21635) + Math.cos(21636) * 4;
+acc += Math.sin(21636) + Math.cos(21637) * 5;
+acc += Math.sin(21637) + Math.cos(21638) * 6;
+acc += Math.sin(21638) + Math.cos(21639) * 7;
+acc += Math.sin(21639) + Math.cos(21640) * 8;
+acc += Math.sin(21640) + Math.cos(21641) * 9;
+acc += Math.sin(21641) + Math.cos(21642) * 10;
+acc += Math.sin(21642) + Math.cos(21643) * 11;
+acc += Math.sin(21643) + Math.cos(21644) * 12;
+acc += Math.sin(21644) + Math.cos(21645) * 13;
+acc += Math.sin(21645) + Math.cos(21646) * 14;
+acc += Math.sin(21646) + Math.cos(21647) * 15;
+acc += Math.sin(21647) + Math.cos(21648) * 16;
+acc += Math.sin(21648) + Math.cos(21649) * 17;
+acc += Math.sin(21649) + Math.cos(21650) * 18;
+acc += Math.sin(21650) + Math.cos(21651) * 19;
+acc += Math.sin(21651) + Math.cos(21652) * 20;
+acc += Math.sin(21652) + Math.cos(21653) * 21;
+acc += Math.sin(21653) + Math.cos(21654) * 22;
+acc += Math.sin(21654) + Math.cos(21655) * 23;
+acc += Math.sin(21655) + Math.cos(21656) * 24;
+acc += Math.sin(21656) + Math.cos(21657) * 25;
+acc += Math.sin(21657) + Math.cos(21658) * 26;
+acc += Math.sin(21658) + Math.cos(21659) * 27;
+acc += Math.sin(21659) + Math.cos(21660) * 28;
+acc += Math.sin(21660) + Math.cos(21661) * 29;
+acc += Math.sin(21661) + Math.cos(21662) * 30;
+acc += Math.sin(21662) + Math.cos(21663) * 31;
+acc += Math.sin(21663) + Math.cos(21664) * 32;
+acc += Math.sin(21664) + Math.cos(21665) * 33;
+acc += Math.sin(21665) + Math.cos(21666) * 34;
+acc += Math.sin(21666) + Math.cos(21667) * 35;
+acc += Math.sin(21667) + Math.cos(21668) * 36;
+acc += Math.sin(21668) + Math.cos(21669) * 37;
+acc += Math.sin(21669) + Math.cos(21670) * 38;
+acc += Math.sin(21670) + Math.cos(21671) * 39;
+acc += Math.sin(21671) + Math.cos(21672) * 40;
+acc += Math.sin(21672) + Math.cos(21673) * 41;
+acc += Math.sin(21673) + Math.cos(21674) * 42;
+acc += Math.sin(21674) + Math.cos(21675) * 43;
+acc += Math.sin(21675) + Math.cos(21676) * 44;
+acc += Math.sin(21676) + Math.cos(21677) * 45;
+acc += Math.sin(21677) + Math.cos(21678) * 46;
+acc += Math.sin(21678) + Math.cos(21679) * 47;
+acc += Math.sin(21679) + Math.cos(21680) * 48;
+acc += Math.sin(21680) + Math.cos(21681) * 49;
+acc += Math.sin(21681) + Math.cos(21682) * 50;
+acc += Math.sin(21682) + Math.cos(21683) * 51;
+acc += Math.sin(21683) + Math.cos(21684) * 52;
+acc += Math.sin(21684) + Math.cos(21685) * 53;
+acc += Math.sin(21685) + Math.cos(21686) * 54;
+acc += Math.sin(21686) + Math.cos(21687) * 55;
+acc += Math.sin(21687) + Math.cos(21688) * 56;
+acc += Math.sin(21688) + Math.cos(21689) * 57;
+acc += Math.sin(21689) + Math.cos(21690) * 58;
+acc += Math.sin(21690) + Math.cos(21691) * 59;
+acc += Math.sin(21691) + Math.cos(21692) * 60;
+acc += Math.sin(21692) + Math.cos(21693) * 61;
+acc += Math.sin(21693) + Math.cos(21694) * 62;
+acc += Math.sin(21694) + Math.cos(21695) * 63;
+acc += Math.sin(21695) + Math.cos(21696) * 64;
+acc += Math.sin(21696) + Math.cos(21697) * 65;
+acc += Math.sin(21697) + Math.cos(21698) * 66;
+acc += Math.sin(21698) + Math.cos(21699) * 67;
+acc += Math.sin(21699) + Math.cos(21700) * 68;
+acc += Math.sin(21700) + Math.cos(21701) * 69;
+acc += Math.sin(21701) + Math.cos(21702) * 70;
+acc += Math.sin(21702) + Math.cos(21703) * 71;
+acc += Math.sin(21703) + Math.cos(21704) * 72;
+acc += Math.sin(21704) + Math.cos(21705) * 73;
+acc += Math.sin(21705) + Math.cos(21706) * 74;
+acc += Math.sin(21706) + Math.cos(21707) * 75;
+acc += Math.sin(21707) + Math.cos(21708) * 76;
+acc += Math.sin(21708) + Math.cos(21709) * 77;
+acc += Math.sin(21709) + Math.cos(21710) * 78;
+acc += Math.sin(21710) + Math.cos(21711) * 79;
+acc += Math.sin(21711) + Math.cos(21712) * 80;
+acc += Math.sin(21712) + Math.cos(21713) * 81;
+acc += Math.sin(21713) + Math.cos(21714) * 82;
+acc += Math.sin(21714) + Math.cos(21715) * 83;
+acc += Math.sin(21715) + Math.cos(21716) * 84;
+acc += Math.sin(21716) + Math.cos(21717) * 85;
+acc += Math.sin(21717) + Math.cos(21718) * 86;
+acc += Math.sin(21718) + Math.cos(21719) * 87;
+acc += Math.sin(21719) + Math.cos(21720) * 88;
+acc += Math.sin(21720) + Math.cos(21721) * 89;
+acc += Math.sin(21721) + Math.cos(21722) * 90;
+acc += Math.sin(21722) + Math.cos(21723) * 91;
+acc += Math.sin(21723) + Math.cos(21724) * 92;
+acc += Math.sin(21724) + Math.cos(21725) * 93;
+acc += Math.sin(21725) + Math.cos(21726) * 94;
+acc += Math.sin(21726) + Math.cos(21727) * 95;
+acc += Math.sin(21727) + Math.cos(21728) * 96;
+acc += Math.sin(21728) + Math.cos(21729) * 0;
+acc += Math.sin(21729) + Math.cos(21730) * 1;
+acc += Math.sin(21730) + Math.cos(21731) * 2;
+acc += Math.sin(21731) + Math.cos(21732) * 3;
+acc += Math.sin(21732) + Math.cos(21733) * 4;
+acc += Math.sin(21733) + Math.cos(21734) * 5;
+acc += Math.sin(21734) + Math.cos(21735) * 6;
+acc += Math.sin(21735) + Math.cos(21736) * 7;
+acc += Math.sin(21736) + Math.cos(21737) * 8;
+acc += Math.sin(21737) + Math.cos(21738) * 9;
+acc += Math.sin(21738) + Math.cos(21739) * 10;
+acc += Math.sin(21739) + Math.cos(21740) * 11;
+acc += Math.sin(21740) + Math.cos(21741) * 12;
+acc += Math.sin(21741) + Math.cos(21742) * 13;
+acc += Math.sin(21742) + Math.cos(21743) * 14;
+acc += Math.sin(21743) + Math.cos(21744) * 15;
+acc += Math.sin(21744) + Math.cos(21745) * 16;
+acc += Math.sin(21745) + Math.cos(21746) * 17;
+acc += Math.sin(21746) + Math.cos(21747) * 18;
+acc += Math.sin(21747) + Math.cos(21748) * 19;
+acc += Math.sin(21748) + Math.cos(21749) * 20;
+acc += Math.sin(21749) + Math.cos(21750) * 21;
+acc += Math.sin(21750) + Math.cos(21751) * 22;
+acc += Math.sin(21751) + Math.cos(21752) * 23;
+acc += Math.sin(21752) + Math.cos(21753) * 24;
+acc += Math.sin(21753) + Math.cos(21754) * 25;
+acc += Math.sin(21754) + Math.cos(21755) * 26;
+acc += Math.sin(21755) + Math.cos(21756) * 27;
+acc += Math.sin(21756) + Math.cos(21757) * 28;
+acc += Math.sin(21757) + Math.cos(21758) * 29;
+acc += Math.sin(21758) + Math.cos(21759) * 30;
+acc += Math.sin(21759) + Math.cos(21760) * 31;
+acc += Math.sin(21760) + Math.cos(21761) * 32;
+acc += Math.sin(21761) + Math.cos(21762) * 33;
+acc += Math.sin(21762) + Math.cos(21763) * 34;
+acc += Math.sin(21763) + Math.cos(21764) * 35;
+acc += Math.sin(21764) + Math.cos(21765) * 36;
+acc += Math.sin(21765) + Math.cos(21766) * 37;
+acc += Math.sin(21766) + Math.cos(21767) * 38;
+acc += Math.sin(21767) + Math.cos(21768) * 39;
+acc += Math.sin(21768) + Math.cos(21769) * 40;
+acc += Math.sin(21769) + Math.cos(21770) * 41;
+acc += Math.sin(21770) + Math.cos(21771) * 42;
+acc += Math.sin(21771) + Math.cos(21772) * 43;
+acc += Math.sin(21772) + Math.cos(21773) * 44;
+acc += Math.sin(21773) + Math.cos(21774) * 45;
+acc += Math.sin(21774) + Math.cos(21775) * 46;
+acc += Math.sin(21775) + Math.cos(21776) * 47;
+acc += Math.sin(21776) + Math.cos(21777) * 48;
+acc += Math.sin(21777) + Math.cos(21778) * 49;
+acc += Math.sin(21778) + Math.cos(21779) * 50;
+acc += Math.sin(21779) + Math.cos(21780) * 51;
+acc += Math.sin(21780) + Math.cos(21781) * 52;
+acc += Math.sin(21781) + Math.cos(21782) * 53;
+acc += Math.sin(21782) + Math.cos(21783) * 54;
+acc += Math.sin(21783) + Math.cos(21784) * 55;
+acc += Math.sin(21784) + Math.cos(21785) * 56;
+acc += Math.sin(21785) + Math.cos(21786) * 57;
+acc += Math.sin(21786) + Math.cos(21787) * 58;
+acc += Math.sin(21787) + Math.cos(21788) * 59;
+acc += Math.sin(21788) + Math.cos(21789) * 60;
+acc += Math.sin(21789) + Math.cos(21790) * 61;
+acc += Math.sin(21790) + Math.cos(21791) * 62;
+acc += Math.sin(21791) + Math.cos(21792) * 63;
+acc += Math.sin(21792) + Math.cos(21793) * 64;
+acc += Math.sin(21793) + Math.cos(21794) * 65;
+acc += Math.sin(21794) + Math.cos(21795) * 66;
+acc += Math.sin(21795) + Math.cos(21796) * 67;
+acc += Math.sin(21796) + Math.cos(21797) * 68;
+acc += Math.sin(21797) + Math.cos(21798) * 69;
+acc += Math.sin(21798) + Math.cos(21799) * 70;
+acc += Math.sin(21799) + Math.cos(21800) * 71;
+acc += Math.sin(21800) + Math.cos(21801) * 72;
+acc += Math.sin(21801) + Math.cos(21802) * 73;
+acc += Math.sin(21802) + Math.cos(21803) * 74;
+acc += Math.sin(21803) + Math.cos(21804) * 75;
+acc += Math.sin(21804) + Math.cos(21805) * 76;
+acc += Math.sin(21805) + Math.cos(21806) * 77;
+acc += Math.sin(21806) + Math.cos(21807) * 78;
+acc += Math.sin(21807) + Math.cos(21808) * 79;
+acc += Math.sin(21808) + Math.cos(21809) * 80;
+acc += Math.sin(21809) + Math.cos(21810) * 81;
+acc += Math.sin(21810) + Math.cos(21811) * 82;
+acc += Math.sin(21811) + Math.cos(21812) * 83;
+acc += Math.sin(21812) + Math.cos(21813) * 84;
+acc += Math.sin(21813) + Math.cos(21814) * 85;
+acc += Math.sin(21814) + Math.cos(21815) * 86;
+acc += Math.sin(21815) + Math.cos(21816) * 87;
+acc += Math.sin(21816) + Math.cos(21817) * 88;
+acc += Math.sin(21817) + Math.cos(21818) * 89;
+acc += Math.sin(21818) + Math.cos(21819) * 90;
+acc += Math.sin(21819) + Math.cos(21820) * 91;
+acc += Math.sin(21820) + Math.cos(21821) * 92;
+acc += Math.sin(21821) + Math.cos(21822) * 93;
+acc += Math.sin(21822) + Math.cos(21823) * 94;
+acc += Math.sin(21823) + Math.cos(21824) * 95;
+acc += Math.sin(21824) + Math.cos(21825) * 96;
+acc += Math.sin(21825) + Math.cos(21826) * 0;
+acc += Math.sin(21826) + Math.cos(21827) * 1;
+acc += Math.sin(21827) + Math.cos(21828) * 2;
+acc += Math.sin(21828) + Math.cos(21829) * 3;
+acc += Math.sin(21829) + Math.cos(21830) * 4;
+acc += Math.sin(21830) + Math.cos(21831) * 5;
+acc += Math.sin(21831) + Math.cos(21832) * 6;
+acc += Math.sin(21832) + Math.cos(21833) * 7;
+acc += Math.sin(21833) + Math.cos(21834) * 8;
+acc += Math.sin(21834) + Math.cos(21835) * 9;
+acc += Math.sin(21835) + Math.cos(21836) * 10;
+acc += Math.sin(21836) + Math.cos(21837) * 11;
+acc += Math.sin(21837) + Math.cos(21838) * 12;
+acc += Math.sin(21838) + Math.cos(21839) * 13;
+acc += Math.sin(21839) + Math.cos(21840) * 14;
+acc += Math.sin(21840) + Math.cos(21841) * 15;
+acc += Math.sin(21841) + Math.cos(21842) * 16;
+acc += Math.sin(21842) + Math.cos(21843) * 17;
+acc += Math.sin(21843) + Math.cos(21844) * 18;
+acc += Math.sin(21844) + Math.cos(21845) * 19;
+acc += Math.sin(21845) + Math.cos(21846) * 20;
+acc += Math.sin(21846) + Math.cos(21847) * 21;
+acc += Math.sin(21847) + Math.cos(21848) * 22;
+acc += Math.sin(21848) + Math.cos(21849) * 23;
+acc += Math.sin(21849) + Math.cos(21850) * 24;
+acc += Math.sin(21850) + Math.cos(21851) * 25;
+acc += Math.sin(21851) + Math.cos(21852) * 26;
+acc += Math.sin(21852) + Math.cos(21853) * 27;
+acc += Math.sin(21853) + Math.cos(21854) * 28;
+acc += Math.sin(21854) + Math.cos(21855) * 29;
+acc += Math.sin(21855) + Math.cos(21856) * 30;
+acc += Math.sin(21856) + Math.cos(21857) * 31;
+acc += Math.sin(21857) + Math.cos(21858) * 32;
+acc += Math.sin(21858) + Math.cos(21859) * 33;
+acc += Math.sin(21859) + Math.cos(21860) * 34;
+acc += Math.sin(21860) + Math.cos(21861) * 35;
+acc += Math.sin(21861) + Math.cos(21862) * 36;
+acc += Math.sin(21862) + Math.cos(21863) * 37;
+acc += Math.sin(21863) + Math.cos(21864) * 38;
+acc += Math.sin(21864) + Math.cos(21865) * 39;
+acc += Math.sin(21865) + Math.cos(21866) * 40;
+acc += Math.sin(21866) + Math.cos(21867) * 41;
+acc += Math.sin(21867) + Math.cos(21868) * 42;
+acc += Math.sin(21868) + Math.cos(21869) * 43;
+acc += Math.sin(21869) + Math.cos(21870) * 44;
+acc += Math.sin(21870) + Math.cos(21871) * 45;
+acc += Math.sin(21871) + Math.cos(21872) * 46;
+acc += Math.sin(21872) + Math.cos(21873) * 47;
+acc += Math.sin(21873) + Math.cos(21874) * 48;
+acc += Math.sin(21874) + Math.cos(21875) * 49;
+acc += Math.sin(21875) + Math.cos(21876) * 50;
+acc += Math.sin(21876) + Math.cos(21877) * 51;
+acc += Math.sin(21877) + Math.cos(21878) * 52;
+acc += Math.sin(21878) + Math.cos(21879) * 53;
+acc += Math.sin(21879) + Math.cos(21880) * 54;
+acc += Math.sin(21880) + Math.cos(21881) * 55;
+acc += Math.sin(21881) + Math.cos(21882) * 56;
+acc += Math.sin(21882) + Math.cos(21883) * 57;
+acc += Math.sin(21883) + Math.cos(21884) * 58;
+acc += Math.sin(21884) + Math.cos(21885) * 59;
+acc += Math.sin(21885) + Math.cos(21886) * 60;
+acc += Math.sin(21886) + Math.cos(21887) * 61;
+acc += Math.sin(21887) + Math.cos(21888) * 62;
+acc += Math.sin(21888) + Math.cos(21889) * 63;
+acc += Math.sin(21889) + Math.cos(21890) * 64;
+acc += Math.sin(21890) + Math.cos(21891) * 65;
+acc += Math.sin(21891) + Math.cos(21892) * 66;
+acc += Math.sin(21892) + Math.cos(21893) * 67;
+acc += Math.sin(21893) + Math.cos(21894) * 68;
+acc += Math.sin(21894) + Math.cos(21895) * 69;
+acc += Math.sin(21895) + Math.cos(21896) * 70;
+acc += Math.sin(21896) + Math.cos(21897) * 71;
+acc += Math.sin(21897) + Math.cos(21898) * 72;
+acc += Math.sin(21898) + Math.cos(21899) * 73;
+acc += Math.sin(21899) + Math.cos(21900) * 74;
+acc += Math.sin(21900) + Math.cos(21901) * 75;
+acc += Math.sin(21901) + Math.cos(21902) * 76;
+acc += Math.sin(21902) + Math.cos(21903) * 77;
+acc += Math.sin(21903) + Math.cos(21904) * 78;
+acc += Math.sin(21904) + Math.cos(21905) * 79;
+acc += Math.sin(21905) + Math.cos(21906) * 80;
+acc += Math.sin(21906) + Math.cos(21907) * 81;
+acc += Math.sin(21907) + Math.cos(21908) * 82;
+acc += Math.sin(21908) + Math.cos(21909) * 83;
+acc += Math.sin(21909) + Math.cos(21910) * 84;
+acc += Math.sin(21910) + Math.cos(21911) * 85;
+acc += Math.sin(21911) + Math.cos(21912) * 86;
+acc += Math.sin(21912) + Math.cos(21913) * 87;
+acc += Math.sin(21913) + Math.cos(21914) * 88;
+acc += Math.sin(21914) + Math.cos(21915) * 89;
+acc += Math.sin(21915) + Math.cos(21916) * 90;
+acc += Math.sin(21916) + Math.cos(21917) * 91;
+acc += Math.sin(21917) + Math.cos(21918) * 92;
+acc += Math.sin(21918) + Math.cos(21919) * 93;
+acc += Math.sin(21919) + Math.cos(21920) * 94;
+acc += Math.sin(21920) + Math.cos(21921) * 95;
+acc += Math.sin(21921) + Math.cos(21922) * 96;
+acc += Math.sin(21922) + Math.cos(21923) * 0;
+acc += Math.sin(21923) + Math.cos(21924) * 1;
+acc += Math.sin(21924) + Math.cos(21925) * 2;
+acc += Math.sin(21925) + Math.cos(21926) * 3;
+acc += Math.sin(21926) + Math.cos(21927) * 4;
+acc += Math.sin(21927) + Math.cos(21928) * 5;
+acc += Math.sin(21928) + Math.cos(21929) * 6;
+acc += Math.sin(21929) + Math.cos(21930) * 7;
+acc += Math.sin(21930) + Math.cos(21931) * 8;
+acc += Math.sin(21931) + Math.cos(21932) * 9;
+acc += Math.sin(21932) + Math.cos(21933) * 10;
+acc += Math.sin(21933) + Math.cos(21934) * 11;
+acc += Math.sin(21934) + Math.cos(21935) * 12;
+acc += Math.sin(21935) + Math.cos(21936) * 13;
+acc += Math.sin(21936) + Math.cos(21937) * 14;
+acc += Math.sin(21937) + Math.cos(21938) * 15;
+acc += Math.sin(21938) + Math.cos(21939) * 16;
+acc += Math.sin(21939) + Math.cos(21940) * 17;
+acc += Math.sin(21940) + Math.cos(21941) * 18;
+acc += Math.sin(21941) + Math.cos(21942) * 19;
+acc += Math.sin(21942) + Math.cos(21943) * 20;
+acc += Math.sin(21943) + Math.cos(21944) * 21;
+acc += Math.sin(21944) + Math.cos(21945) * 22;
+acc += Math.sin(21945) + Math.cos(21946) * 23;
+acc += Math.sin(21946) + Math.cos(21947) * 24;
+acc += Math.sin(21947) + Math.cos(21948) * 25;
+acc += Math.sin(21948) + Math.cos(21949) * 26;
+acc += Math.sin(21949) + Math.cos(21950) * 27;
+acc += Math.sin(21950) + Math.cos(21951) * 28;
+acc += Math.sin(21951) + Math.cos(21952) * 29;
+acc += Math.sin(21952) + Math.cos(21953) * 30;
+acc += Math.sin(21953) + Math.cos(21954) * 31;
+acc += Math.sin(21954) + Math.cos(21955) * 32;
+acc += Math.sin(21955) + Math.cos(21956) * 33;
+acc += Math.sin(21956) + Math.cos(21957) * 34;
+acc += Math.sin(21957) + Math.cos(21958) * 35;
+acc += Math.sin(21958) + Math.cos(21959) * 36;
+acc += Math.sin(21959) + Math.cos(21960) * 37;
+acc += Math.sin(21960) + Math.cos(21961) * 38;
+acc += Math.sin(21961) + Math.cos(21962) * 39;
+acc += Math.sin(21962) + Math.cos(21963) * 40;
+acc += Math.sin(21963) + Math.cos(21964) * 41;
+acc += Math.sin(21964) + Math.cos(21965) * 42;
+acc += Math.sin(21965) + Math.cos(21966) * 43;
+acc += Math.sin(21966) + Math.cos(21967) * 44;
+acc += Math.sin(21967) + Math.cos(21968) * 45;
+acc += Math.sin(21968) + Math.cos(21969) * 46;
+acc += Math.sin(21969) + Math.cos(21970) * 47;
+acc += Math.sin(21970) + Math.cos(21971) * 48;
+acc += Math.sin(21971) + Math.cos(21972) * 49;
+acc += Math.sin(21972) + Math.cos(21973) * 50;
+acc += Math.sin(21973) + Math.cos(21974) * 51;
+acc += Math.sin(21974) + Math.cos(21975) * 52;
+acc += Math.sin(21975) + Math.cos(21976) * 53;
+acc += Math.sin(21976) + Math.cos(21977) * 54;
+acc += Math.sin(21977) + Math.cos(21978) * 55;
+acc += Math.sin(21978) + Math.cos(21979) * 56;
+acc += Math.sin(21979) + Math.cos(21980) * 57;
+acc += Math.sin(21980) + Math.cos(21981) * 58;
+acc += Math.sin(21981) + Math.cos(21982) * 59;
+acc += Math.sin(21982) + Math.cos(21983) * 60;
+acc += Math.sin(21983) + Math.cos(21984) * 61;
+acc += Math.sin(21984) + Math.cos(21985) * 62;
+acc += Math.sin(21985) + Math.cos(21986) * 63;
+acc += Math.sin(21986) + Math.cos(21987) * 64;
+acc += Math.sin(21987) + Math.cos(21988) * 65;
+acc += Math.sin(21988) + Math.cos(21989) * 66;
+acc += Math.sin(21989) + Math.cos(21990) * 67;
+acc += Math.sin(21990) + Math.cos(21991) * 68;
+acc += Math.sin(21991) + Math.cos(21992) * 69;
+acc += Math.sin(21992) + Math.cos(21993) * 70;
+acc += Math.sin(21993) + Math.cos(21994) * 71;
+acc += Math.sin(21994) + Math.cos(21995) * 72;
+acc += Math.sin(21995) + Math.cos(21996) * 73;
+acc += Math.sin(21996) + Math.cos(21997) * 74;
+acc += Math.sin(21997) + Math.cos(21998) * 75;
+acc += Math.sin(21998) + Math.cos(21999) * 76;
+acc += Math.sin(21999) + Math.cos(22000) * 77;
+acc += Math.sin(22000) + Math.cos(22001) * 78;
+acc += Math.sin(22001) + Math.cos(22002) * 79;
+acc += Math.sin(22002) + Math.cos(22003) * 80;
+acc += Math.sin(22003) + Math.cos(22004) * 81;
+acc += Math.sin(22004) + Math.cos(22005) * 82;
+acc += Math.sin(22005) + Math.cos(22006) * 83;
+acc += Math.sin(22006) + Math.cos(22007) * 84;
+acc += Math.sin(22007) + Math.cos(22008) * 85;
+acc += Math.sin(22008) + Math.cos(22009) * 86;
+acc += Math.sin(22009) + Math.cos(22010) * 87;
+acc += Math.sin(22010) + Math.cos(22011) * 88;
+acc += Math.sin(22011) + Math.cos(22012) * 89;
+acc += Math.sin(22012) + Math.cos(22013) * 90;
+acc += Math.sin(22013) + Math.cos(22014) * 91;
+acc += Math.sin(22014) + Math.cos(22015) * 92;
+acc += Math.sin(22015) + Math.cos(22016) * 93;
+acc += Math.sin(22016) + Math.cos(22017) * 94;
+acc += Math.sin(22017) + Math.cos(22018) * 95;
+acc += Math.sin(22018) + Math.cos(22019) * 96;
+acc += Math.sin(22019) + Math.cos(22020) * 0;
+acc += Math.sin(22020) + Math.cos(22021) * 1;
+acc += Math.sin(22021) + Math.cos(22022) * 2;
+acc += Math.sin(22022) + Math.cos(22023) * 3;
+acc += Math.sin(22023) + Math.cos(22024) * 4;
+acc += Math.sin(22024) + Math.cos(22025) * 5;
+acc += Math.sin(22025) + Math.cos(22026) * 6;
+acc += Math.sin(22026) + Math.cos(22027) * 7;
+acc += Math.sin(22027) + Math.cos(22028) * 8;
+acc += Math.sin(22028) + Math.cos(22029) * 9;
+acc += Math.sin(22029) + Math.cos(22030) * 10;
+acc += Math.sin(22030) + Math.cos(22031) * 11;
+acc += Math.sin(22031) + Math.cos(22032) * 12;
+acc += Math.sin(22032) + Math.cos(22033) * 13;
+acc += Math.sin(22033) + Math.cos(22034) * 14;
+acc += Math.sin(22034) + Math.cos(22035) * 15;
+acc += Math.sin(22035) + Math.cos(22036) * 16;
+acc += Math.sin(22036) + Math.cos(22037) * 17;
+acc += Math.sin(22037) + Math.cos(22038) * 18;
+acc += Math.sin(22038) + Math.cos(22039) * 19;
+acc += Math.sin(22039) + Math.cos(22040) * 20;
+acc += Math.sin(22040) + Math.cos(22041) * 21;
+acc += Math.sin(22041) + Math.cos(22042) * 22;
+acc += Math.sin(22042) + Math.cos(22043) * 23;
+acc += Math.sin(22043) + Math.cos(22044) * 24;
+acc += Math.sin(22044) + Math.cos(22045) * 25;
+acc += Math.sin(22045) + Math.cos(22046) * 26;
+acc += Math.sin(22046) + Math.cos(22047) * 27;
+acc += Math.sin(22047) + Math.cos(22048) * 28;
+acc += Math.sin(22048) + Math.cos(22049) * 29;
+acc += Math.sin(22049) + Math.cos(22050) * 30;
+acc += Math.sin(22050) + Math.cos(22051) * 31;
+acc += Math.sin(22051) + Math.cos(22052) * 32;
+acc += Math.sin(22052) + Math.cos(22053) * 33;
+acc += Math.sin(22053) + Math.cos(22054) * 34;
+acc += Math.sin(22054) + Math.cos(22055) * 35;
+acc += Math.sin(22055) + Math.cos(22056) * 36;
+acc += Math.sin(22056) + Math.cos(22057) * 37;
+acc += Math.sin(22057) + Math.cos(22058) * 38;
+acc += Math.sin(22058) + Math.cos(22059) * 39;
+acc += Math.sin(22059) + Math.cos(22060) * 40;
+acc += Math.sin(22060) + Math.cos(22061) * 41;
+acc += Math.sin(22061) + Math.cos(22062) * 42;
+acc += Math.sin(22062) + Math.cos(22063) * 43;
+acc += Math.sin(22063) + Math.cos(22064) * 44;
+acc += Math.sin(22064) + Math.cos(22065) * 45;
+acc += Math.sin(22065) + Math.cos(22066) * 46;
+acc += Math.sin(22066) + Math.cos(22067) * 47;
+acc += Math.sin(22067) + Math.cos(22068) * 48;
+acc += Math.sin(22068) + Math.cos(22069) * 49;
+acc += Math.sin(22069) + Math.cos(22070) * 50;
+acc += Math.sin(22070) + Math.cos(22071) * 51;
+acc += Math.sin(22071) + Math.cos(22072) * 52;
+acc += Math.sin(22072) + Math.cos(22073) * 53;
+acc += Math.sin(22073) + Math.cos(22074) * 54;
+acc += Math.sin(22074) + Math.cos(22075) * 55;
+acc += Math.sin(22075) + Math.cos(22076) * 56;
+acc += Math.sin(22076) + Math.cos(22077) * 57;
+acc += Math.sin(22077) + Math.cos(22078) * 58;
+acc += Math.sin(22078) + Math.cos(22079) * 59;
+acc += Math.sin(22079) + Math.cos(22080) * 60;
+acc += Math.sin(22080) + Math.cos(22081) * 61;
+acc += Math.sin(22081) + Math.cos(22082) * 62;
+acc += Math.sin(22082) + Math.cos(22083) * 63;
+acc += Math.sin(22083) + Math.cos(22084) * 64;
+acc += Math.sin(22084) + Math.cos(22085) * 65;
+acc += Math.sin(22085) + Math.cos(22086) * 66;
+acc += Math.sin(22086) + Math.cos(22087) * 67;
+acc += Math.sin(22087) + Math.cos(22088) * 68;
+acc += Math.sin(22088) + Math.cos(22089) * 69;
+acc += Math.sin(22089) + Math.cos(22090) * 70;
+acc += Math.sin(22090) + Math.cos(22091) * 71;
+acc += Math.sin(22091) + Math.cos(22092) * 72;
+acc += Math.sin(22092) + Math.cos(22093) * 73;
+acc += Math.sin(22093) + Math.cos(22094) * 74;
+acc += Math.sin(22094) + Math.cos(22095) * 75;
+acc += Math.sin(22095) + Math.cos(22096) * 76;
+acc += Math.sin(22096) + Math.cos(22097) * 77;
+acc += Math.sin(22097) + Math.cos(22098) * 78;
+acc += Math.sin(22098) + Math.cos(22099) * 79;
+acc += Math.sin(22099) + Math.cos(22100) * 80;
+acc += Math.sin(22100) + Math.cos(22101) * 81;
+acc += Math.sin(22101) + Math.cos(22102) * 82;
+acc += Math.sin(22102) + Math.cos(22103) * 83;
+acc += Math.sin(22103) + Math.cos(22104) * 84;
+acc += Math.sin(22104) + Math.cos(22105) * 85;
+acc += Math.sin(22105) + Math.cos(22106) * 86;
+acc += Math.sin(22106) + Math.cos(22107) * 87;
+acc += Math.sin(22107) + Math.cos(22108) * 88;
+acc += Math.sin(22108) + Math.cos(22109) * 89;
+acc += Math.sin(22109) + Math.cos(22110) * 90;
+acc += Math.sin(22110) + Math.cos(22111) * 91;
+acc += Math.sin(22111) + Math.cos(22112) * 92;
+acc += Math.sin(22112) + Math.cos(22113) * 93;
+acc += Math.sin(22113) + Math.cos(22114) * 94;
+acc += Math.sin(22114) + Math.cos(22115) * 95;
+acc += Math.sin(22115) + Math.cos(22116) * 96;
+acc += Math.sin(22116) + Math.cos(22117) * 0;
+acc += Math.sin(22117) + Math.cos(22118) * 1;
+acc += Math.sin(22118) + Math.cos(22119) * 2;
+acc += Math.sin(22119) + Math.cos(22120) * 3;
+acc += Math.sin(22120) + Math.cos(22121) * 4;
+acc += Math.sin(22121) + Math.cos(22122) * 5;
+acc += Math.sin(22122) + Math.cos(22123) * 6;
+acc += Math.sin(22123) + Math.cos(22124) * 7;
+acc += Math.sin(22124) + Math.cos(22125) * 8;
+acc += Math.sin(22125) + Math.cos(22126) * 9;
+acc += Math.sin(22126) + Math.cos(22127) * 10;
+acc += Math.sin(22127) + Math.cos(22128) * 11;
+acc += Math.sin(22128) + Math.cos(22129) * 12;
+acc += Math.sin(22129) + Math.cos(22130) * 13;
+acc += Math.sin(22130) + Math.cos(22131) * 14;
+acc += Math.sin(22131) + Math.cos(22132) * 15;
+acc += Math.sin(22132) + Math.cos(22133) * 16;
+acc += Math.sin(22133) + Math.cos(22134) * 17;
+acc += Math.sin(22134) + Math.cos(22135) * 18;
+acc += Math.sin(22135) + Math.cos(22136) * 19;
+acc += Math.sin(22136) + Math.cos(22137) * 20;
+acc += Math.sin(22137) + Math.cos(22138) * 21;
+acc += Math.sin(22138) + Math.cos(22139) * 22;
+acc += Math.sin(22139) + Math.cos(22140) * 23;
+acc += Math.sin(22140) + Math.cos(22141) * 24;
+acc += Math.sin(22141) + Math.cos(22142) * 25;
+acc += Math.sin(22142) + Math.cos(22143) * 26;
+acc += Math.sin(22143) + Math.cos(22144) * 27;
+acc += Math.sin(22144) + Math.cos(22145) * 28;
+acc += Math.sin(22145) + Math.cos(22146) * 29;
+acc += Math.sin(22146) + Math.cos(22147) * 30;
+acc += Math.sin(22147) + Math.cos(22148) * 31;
+acc += Math.sin(22148) + Math.cos(22149) * 32;
+acc += Math.sin(22149) + Math.cos(22150) * 33;
+acc += Math.sin(22150) + Math.cos(22151) * 34;
+acc += Math.sin(22151) + Math.cos(22152) * 35;
+acc += Math.sin(22152) + Math.cos(22153) * 36;
+acc += Math.sin(22153) + Math.cos(22154) * 37;
+acc += Math.sin(22154) + Math.cos(22155) * 38;
+acc += Math.sin(22155) + Math.cos(22156) * 39;
+acc += Math.sin(22156) + Math.cos(22157) * 40;
+acc += Math.sin(22157) + Math.cos(22158) * 41;
+acc += Math.sin(22158) + Math.cos(22159) * 42;
+acc += Math.sin(22159) + Math.cos(22160) * 43;
+acc += Math.sin(22160) + Math.cos(22161) * 44;
+acc += Math.sin(22161) + Math.cos(22162) * 45;
+acc += Math.sin(22162) + Math.cos(22163) * 46;
+acc += Math.sin(22163) + Math.cos(22164) * 47;
+acc += Math.sin(22164) + Math.cos(22165) * 48;
+acc += Math.sin(22165) + Math.cos(22166) * 49;
+acc += Math.sin(22166) + Math.cos(22167) * 50;
+acc += Math.sin(22167) + Math.cos(22168) * 51;
+acc += Math.sin(22168) + Math.cos(22169) * 52;
+acc += Math.sin(22169) + Math.cos(22170) * 53;
+acc += Math.sin(22170) + Math.cos(22171) * 54;
+acc += Math.sin(22171) + Math.cos(22172) * 55;
+acc += Math.sin(22172) + Math.cos(22173) * 56;
+acc += Math.sin(22173) + Math.cos(22174) * 57;
+acc += Math.sin(22174) + Math.cos(22175) * 58;
+acc += Math.sin(22175) + Math.cos(22176) * 59;
+acc += Math.sin(22176) + Math.cos(22177) * 60;
+acc += Math.sin(22177) + Math.cos(22178) * 61;
+acc += Math.sin(22178) + Math.cos(22179) * 62;
+acc += Math.sin(22179) + Math.cos(22180) * 63;
+acc += Math.sin(22180) + Math.cos(22181) * 64;
+acc += Math.sin(22181) + Math.cos(22182) * 65;
+acc += Math.sin(22182) + Math.cos(22183) * 66;
+acc += Math.sin(22183) + Math.cos(22184) * 67;
+acc += Math.sin(22184) + Math.cos(22185) * 68;
+acc += Math.sin(22185) + Math.cos(22186) * 69;
+acc += Math.sin(22186) + Math.cos(22187) * 70;
+acc += Math.sin(22187) + Math.cos(22188) * 71;
+acc += Math.sin(22188) + Math.cos(22189) * 72;
+acc += Math.sin(22189) + Math.cos(22190) * 73;
+acc += Math.sin(22190) + Math.cos(22191) * 74;
+acc += Math.sin(22191) + Math.cos(22192) * 75;
+acc += Math.sin(22192) + Math.cos(22193) * 76;
+acc += Math.sin(22193) + Math.cos(22194) * 77;
+acc += Math.sin(22194) + Math.cos(22195) * 78;
+acc += Math.sin(22195) + Math.cos(22196) * 79;
+acc += Math.sin(22196) + Math.cos(22197) * 80;
+acc += Math.sin(22197) + Math.cos(22198) * 81;
+acc += Math.sin(22198) + Math.cos(22199) * 82;
+acc += Math.sin(22199) + Math.cos(22200) * 83;
+acc += Math.sin(22200) + Math.cos(22201) * 84;
+acc += Math.sin(22201) + Math.cos(22202) * 85;
+acc += Math.sin(22202) + Math.cos(22203) * 86;
+acc += Math.sin(22203) + Math.cos(22204) * 87;
+acc += Math.sin(22204) + Math.cos(22205) * 88;
+acc += Math.sin(22205) + Math.cos(22206) * 89;
+acc += Math.sin(22206) + Math.cos(22207) * 90;
+acc += Math.sin(22207) + Math.cos(22208) * 91;
+acc += Math.sin(22208) + Math.cos(22209) * 92;
+acc += Math.sin(22209) + Math.cos(22210) * 93;
+acc += Math.sin(22210) + Math.cos(22211) * 94;
+acc += Math.sin(22211) + Math.cos(22212) * 95;
+acc += Math.sin(22212) + Math.cos(22213) * 96;
+acc += Math.sin(22213) + Math.cos(22214) * 0;
+acc += Math.sin(22214) + Math.cos(22215) * 1;
+acc += Math.sin(22215) + Math.cos(22216) * 2;
+acc += Math.sin(22216) + Math.cos(22217) * 3;
+acc += Math.sin(22217) + Math.cos(22218) * 4;
+acc += Math.sin(22218) + Math.cos(22219) * 5;
+acc += Math.sin(22219) + Math.cos(22220) * 6;
+acc += Math.sin(22220) + Math.cos(22221) * 7;
+acc += Math.sin(22221) + Math.cos(22222) * 8;
+acc += Math.sin(22222) + Math.cos(22223) * 9;
+acc += Math.sin(22223) + Math.cos(22224) * 10;
+acc += Math.sin(22224) + Math.cos(22225) * 11;
+acc += Math.sin(22225) + Math.cos(22226) * 12;
+acc += Math.sin(22226) + Math.cos(22227) * 13;
+acc += Math.sin(22227) + Math.cos(22228) * 14;
+acc += Math.sin(22228) + Math.cos(22229) * 15;
+acc += Math.sin(22229) + Math.cos(22230) * 16;
+acc += Math.sin(22230) + Math.cos(22231) * 17;
+acc += Math.sin(22231) + Math.cos(22232) * 18;
+acc += Math.sin(22232) + Math.cos(22233) * 19;
+acc += Math.sin(22233) + Math.cos(22234) * 20;
+acc += Math.sin(22234) + Math.cos(22235) * 21;
+acc += Math.sin(22235) + Math.cos(22236) * 22;
+acc += Math.sin(22236) + Math.cos(22237) * 23;
+acc += Math.sin(22237) + Math.cos(22238) * 24;
+acc += Math.sin(22238) + Math.cos(22239) * 25;
+acc += Math.sin(22239) + Math.cos(22240) * 26;
+acc += Math.sin(22240) + Math.cos(22241) * 27;
+acc += Math.sin(22241) + Math.cos(22242) * 28;
+acc += Math.sin(22242) + Math.cos(22243) * 29;
+acc += Math.sin(22243) + Math.cos(22244) * 30;
+acc += Math.sin(22244) + Math.cos(22245) * 31;
+acc += Math.sin(22245) + Math.cos(22246) * 32;
+acc += Math.sin(22246) + Math.cos(22247) * 33;
+acc += Math.sin(22247) + Math.cos(22248) * 34;
+acc += Math.sin(22248) + Math.cos(22249) * 35;
+acc += Math.sin(22249) + Math.cos(22250) * 36;
+acc += Math.sin(22250) + Math.cos(22251) * 37;
+acc += Math.sin(22251) + Math.cos(22252) * 38;
+acc += Math.sin(22252) + Math.cos(22253) * 39;
+acc += Math.sin(22253) + Math.cos(22254) * 40;
+acc += Math.sin(22254) + Math.cos(22255) * 41;
+acc += Math.sin(22255) + Math.cos(22256) * 42;
+acc += Math.sin(22256) + Math.cos(22257) * 43;
+acc += Math.sin(22257) + Math.cos(22258) * 44;
+acc += Math.sin(22258) + Math.cos(22259) * 45;
+acc += Math.sin(22259) + Math.cos(22260) * 46;
+acc += Math.sin(22260) + Math.cos(22261) * 47;
+acc += Math.sin(22261) + Math.cos(22262) * 48;
+acc += Math.sin(22262) + Math.cos(22263) * 49;
+acc += Math.sin(22263) + Math.cos(22264) * 50;
+acc += Math.sin(22264) + Math.cos(22265) * 51;
+acc += Math.sin(22265) + Math.cos(22266) * 52;
+acc += Math.sin(22266) + Math.cos(22267) * 53;
+acc += Math.sin(22267) + Math.cos(22268) * 54;
+acc += Math.sin(22268) + Math.cos(22269) * 55;
+acc += Math.sin(22269) + Math.cos(22270) * 56;
+acc += Math.sin(22270) + Math.cos(22271) * 57;
+acc += Math.sin(22271) + Math.cos(22272) * 58;
+acc += Math.sin(22272) + Math.cos(22273) * 59;
+acc += Math.sin(22273) + Math.cos(22274) * 60;
+acc += Math.sin(22274) + Math.cos(22275) * 61;
+acc += Math.sin(22275) + Math.cos(22276) * 62;
+acc += Math.sin(22276) + Math.cos(22277) * 63;
+acc += Math.sin(22277) + Math.cos(22278) * 64;
+acc += Math.sin(22278) + Math.cos(22279) * 65;
+acc += Math.sin(22279) + Math.cos(22280) * 66;
+acc += Math.sin(22280) + Math.cos(22281) * 67;
+acc += Math.sin(22281) + Math.cos(22282) * 68;
+acc += Math.sin(22282) + Math.cos(22283) * 69;
+acc += Math.sin(22283) + Math.cos(22284) * 70;
+acc += Math.sin(22284) + Math.cos(22285) * 71;
+acc += Math.sin(22285) + Math.cos(22286) * 72;
+acc += Math.sin(22286) + Math.cos(22287) * 73;
+acc += Math.sin(22287) + Math.cos(22288) * 74;
+acc += Math.sin(22288) + Math.cos(22289) * 75;
+acc += Math.sin(22289) + Math.cos(22290) * 76;
+acc += Math.sin(22290) + Math.cos(22291) * 77;
+acc += Math.sin(22291) + Math.cos(22292) * 78;
+acc += Math.sin(22292) + Math.cos(22293) * 79;
+acc += Math.sin(22293) + Math.cos(22294) * 80;
+acc += Math.sin(22294) + Math.cos(22295) * 81;
+acc += Math.sin(22295) + Math.cos(22296) * 82;
+acc += Math.sin(22296) + Math.cos(22297) * 83;
+acc += Math.sin(22297) + Math.cos(22298) * 84;
+acc += Math.sin(22298) + Math.cos(22299) * 85;
+acc += Math.sin(22299) + Math.cos(22300) * 86;
+acc += Math.sin(22300) + Math.cos(22301) * 87;
+acc += Math.sin(22301) + Math.cos(22302) * 88;
+acc += Math.sin(22302) + Math.cos(22303) * 89;
+acc += Math.sin(22303) + Math.cos(22304) * 90;
+acc += Math.sin(22304) + Math.cos(22305) * 91;
+acc += Math.sin(22305) + Math.cos(22306) * 92;
+acc += Math.sin(22306) + Math.cos(22307) * 93;
+acc += Math.sin(22307) + Math.cos(22308) * 94;
+acc += Math.sin(22308) + Math.cos(22309) * 95;
+acc += Math.sin(22309) + Math.cos(22310) * 96;
+acc += Math.sin(22310) + Math.cos(22311) * 0;
+acc += Math.sin(22311) + Math.cos(22312) * 1;
+acc += Math.sin(22312) + Math.cos(22313) * 2;
+acc += Math.sin(22313) + Math.cos(22314) * 3;
+acc += Math.sin(22314) + Math.cos(22315) * 4;
+acc += Math.sin(22315) + Math.cos(22316) * 5;
+acc += Math.sin(22316) + Math.cos(22317) * 6;
+acc += Math.sin(22317) + Math.cos(22318) * 7;
+acc += Math.sin(22318) + Math.cos(22319) * 8;
+acc += Math.sin(22319) + Math.cos(22320) * 9;
+acc += Math.sin(22320) + Math.cos(22321) * 10;
+acc += Math.sin(22321) + Math.cos(22322) * 11;
+acc += Math.sin(22322) + Math.cos(22323) * 12;
+acc += Math.sin(22323) + Math.cos(22324) * 13;
+acc += Math.sin(22324) + Math.cos(22325) * 14;
+acc += Math.sin(22325) + Math.cos(22326) * 15;
+acc += Math.sin(22326) + Math.cos(22327) * 16;
+acc += Math.sin(22327) + Math.cos(22328) * 17;
+acc += Math.sin(22328) + Math.cos(22329) * 18;
+acc += Math.sin(22329) + Math.cos(22330) * 19;
+acc += Math.sin(22330) + Math.cos(22331) * 20;
+acc += Math.sin(22331) + Math.cos(22332) * 21;
+acc += Math.sin(22332) + Math.cos(22333) * 22;
+acc += Math.sin(22333) + Math.cos(22334) * 23;
+acc += Math.sin(22334) + Math.cos(22335) * 24;
+acc += Math.sin(22335) + Math.cos(22336) * 25;
+acc += Math.sin(22336) + Math.cos(22337) * 26;
+acc += Math.sin(22337) + Math.cos(22338) * 27;
+acc += Math.sin(22338) + Math.cos(22339) * 28;
+acc += Math.sin(22339) + Math.cos(22340) * 29;
+acc += Math.sin(22340) + Math.cos(22341) * 30;
+acc += Math.sin(22341) + Math.cos(22342) * 31;
+acc += Math.sin(22342) + Math.cos(22343) * 32;
+acc += Math.sin(22343) + Math.cos(22344) * 33;
+acc += Math.sin(22344) + Math.cos(22345) * 34;
+acc += Math.sin(22345) + Math.cos(22346) * 35;
+acc += Math.sin(22346) + Math.cos(22347) * 36;
+acc += Math.sin(22347) + Math.cos(22348) * 37;
+acc += Math.sin(22348) + Math.cos(22349) * 38;
+acc += Math.sin(22349) + Math.cos(22350) * 39;
+acc += Math.sin(22350) + Math.cos(22351) * 40;
+acc += Math.sin(22351) + Math.cos(22352) * 41;
+acc += Math.sin(22352) + Math.cos(22353) * 42;
+acc += Math.sin(22353) + Math.cos(22354) * 43;
+acc += Math.sin(22354) + Math.cos(22355) * 44;
+acc += Math.sin(22355) + Math.cos(22356) * 45;
+acc += Math.sin(22356) + Math.cos(22357) * 46;
+acc += Math.sin(22357) + Math.cos(22358) * 47;
+acc += Math.sin(22358) + Math.cos(22359) * 48;
+acc += Math.sin(22359) + Math.cos(22360) * 49;
+acc += Math.sin(22360) + Math.cos(22361) * 50;
+acc += Math.sin(22361) + Math.cos(22362) * 51;
+acc += Math.sin(22362) + Math.cos(22363) * 52;
+acc += Math.sin(22363) + Math.cos(22364) * 53;
+acc += Math.sin(22364) + Math.cos(22365) * 54;
+acc += Math.sin(22365) + Math.cos(22366) * 55;
+acc += Math.sin(22366) + Math.cos(22367) * 56;
+acc += Math.sin(22367) + Math.cos(22368) * 57;
+acc += Math.sin(22368) + Math.cos(22369) * 58;
+acc += Math.sin(22369) + Math.cos(22370) * 59;
+acc += Math.sin(22370) + Math.cos(22371) * 60;
+acc += Math.sin(22371) + Math.cos(22372) * 61;
+acc += Math.sin(22372) + Math.cos(22373) * 62;
+acc += Math.sin(22373) + Math.cos(22374) * 63;
+acc += Math.sin(22374) + Math.cos(22375) * 64;
+acc += Math.sin(22375) + Math.cos(22376) * 65;
+acc += Math.sin(22376) + Math.cos(22377) * 66;
+acc += Math.sin(22377) + Math.cos(22378) * 67;
+acc += Math.sin(22378) + Math.cos(22379) * 68;
+acc += Math.sin(22379) + Math.cos(22380) * 69;
+acc += Math.sin(22380) + Math.cos(22381) * 70;
+acc += Math.sin(22381) + Math.cos(22382) * 71;
+acc += Math.sin(22382) + Math.cos(22383) * 72;
+acc += Math.sin(22383) + Math.cos(22384) * 73;
+acc += Math.sin(22384) + Math.cos(22385) * 74;
+acc += Math.sin(22385) + Math.cos(22386) * 75;
+acc += Math.sin(22386) + Math.cos(22387) * 76;
+acc += Math.sin(22387) + Math.cos(22388) * 77;
+acc += Math.sin(22388) + Math.cos(22389) * 78;
+acc += Math.sin(22389) + Math.cos(22390) * 79;
+acc += Math.sin(22390) + Math.cos(22391) * 80;
+acc += Math.sin(22391) + Math.cos(22392) * 81;
+acc += Math.sin(22392) + Math.cos(22393) * 82;
+acc += Math.sin(22393) + Math.cos(22394) * 83;
+acc += Math.sin(22394) + Math.cos(22395) * 84;
+acc += Math.sin(22395) + Math.cos(22396) * 85;
+acc += Math.sin(22396) + Math.cos(22397) * 86;
+acc += Math.sin(22397) + Math.cos(22398) * 87;
+acc += Math.sin(22398) + Math.cos(22399) * 88;
+acc += Math.sin(22399) + Math.cos(22400) * 89;
+acc += Math.sin(22400) + Math.cos(22401) * 90;
+acc += Math.sin(22401) + Math.cos(22402) * 91;
+acc += Math.sin(22402) + Math.cos(22403) * 92;
+acc += Math.sin(22403) + Math.cos(22404) * 93;
+acc += Math.sin(22404) + Math.cos(22405) * 94;
+acc += Math.sin(22405) + Math.cos(22406) * 95;
+acc += Math.sin(22406) + Math.cos(22407) * 96;
+acc += Math.sin(22407) + Math.cos(22408) * 0;
+acc += Math.sin(22408) + Math.cos(22409) * 1;
+acc += Math.sin(22409) + Math.cos(22410) * 2;
+acc += Math.sin(22410) + Math.cos(22411) * 3;
+acc += Math.sin(22411) + Math.cos(22412) * 4;
+acc += Math.sin(22412) + Math.cos(22413) * 5;
+acc += Math.sin(22413) + Math.cos(22414) * 6;
+acc += Math.sin(22414) + Math.cos(22415) * 7;
+acc += Math.sin(22415) + Math.cos(22416) * 8;
+acc += Math.sin(22416) + Math.cos(22417) * 9;
+acc += Math.sin(22417) + Math.cos(22418) * 10;
+acc += Math.sin(22418) + Math.cos(22419) * 11;
+acc += Math.sin(22419) + Math.cos(22420) * 12;
+acc += Math.sin(22420) + Math.cos(22421) * 13;
+acc += Math.sin(22421) + Math.cos(22422) * 14;
+acc += Math.sin(22422) + Math.cos(22423) * 15;
+acc += Math.sin(22423) + Math.cos(22424) * 16;
+acc += Math.sin(22424) + Math.cos(22425) * 17;
+acc += Math.sin(22425) + Math.cos(22426) * 18;
+acc += Math.sin(22426) + Math.cos(22427) * 19;
+acc += Math.sin(22427) + Math.cos(22428) * 20;
+acc += Math.sin(22428) + Math.cos(22429) * 21;
+acc += Math.sin(22429) + Math.cos(22430) * 22;
+acc += Math.sin(22430) + Math.cos(22431) * 23;
+acc += Math.sin(22431) + Math.cos(22432) * 24;
+acc += Math.sin(22432) + Math.cos(22433) * 25;
+acc += Math.sin(22433) + Math.cos(22434) * 26;
+acc += Math.sin(22434) + Math.cos(22435) * 27;
+acc += Math.sin(22435) + Math.cos(22436) * 28;
+acc += Math.sin(22436) + Math.cos(22437) * 29;
+acc += Math.sin(22437) + Math.cos(22438) * 30;
+acc += Math.sin(22438) + Math.cos(22439) * 31;
+acc += Math.sin(22439) + Math.cos(22440) * 32;
+acc += Math.sin(22440) + Math.cos(22441) * 33;
+acc += Math.sin(22441) + Math.cos(22442) * 34;
+acc += Math.sin(22442) + Math.cos(22443) * 35;
+acc += Math.sin(22443) + Math.cos(22444) * 36;
+acc += Math.sin(22444) + Math.cos(22445) * 37;
+acc += Math.sin(22445) + Math.cos(22446) * 38;
+acc += Math.sin(22446) + Math.cos(22447) * 39;
+acc += Math.sin(22447) + Math.cos(22448) * 40;
+acc += Math.sin(22448) + Math.cos(22449) * 41;
+acc += Math.sin(22449) + Math.cos(22450) * 42;
+acc += Math.sin(22450) + Math.cos(22451) * 43;
+acc += Math.sin(22451) + Math.cos(22452) * 44;
+acc += Math.sin(22452) + Math.cos(22453) * 45;
+acc += Math.sin(22453) + Math.cos(22454) * 46;
+acc += Math.sin(22454) + Math.cos(22455) * 47;
+acc += Math.sin(22455) + Math.cos(22456) * 48;
+acc += Math.sin(22456) + Math.cos(22457) * 49;
+acc += Math.sin(22457) + Math.cos(22458) * 50;
+acc += Math.sin(22458) + Math.cos(22459) * 51;
+acc += Math.sin(22459) + Math.cos(22460) * 52;
+acc += Math.sin(22460) + Math.cos(22461) * 53;
+acc += Math.sin(22461) + Math.cos(22462) * 54;
+acc += Math.sin(22462) + Math.cos(22463) * 55;
+acc += Math.sin(22463) + Math.cos(22464) * 56;
+acc += Math.sin(22464) + Math.cos(22465) * 57;
+acc += Math.sin(22465) + Math.cos(22466) * 58;
+acc += Math.sin(22466) + Math.cos(22467) * 59;
+acc += Math.sin(22467) + Math.cos(22468) * 60;
+acc += Math.sin(22468) + Math.cos(22469) * 61;
+acc += Math.sin(22469) + Math.cos(22470) * 62;
+acc += Math.sin(22470) + Math.cos(22471) * 63;
+acc += Math.sin(22471) + Math.cos(22472) * 64;
+acc += Math.sin(22472) + Math.cos(22473) * 65;
+acc += Math.sin(22473) + Math.cos(22474) * 66;
+acc += Math.sin(22474) + Math.cos(22475) * 67;
+acc += Math.sin(22475) + Math.cos(22476) * 68;
+acc += Math.sin(22476) + Math.cos(22477) * 69;
+acc += Math.sin(22477) + Math.cos(22478) * 70;
+acc += Math.sin(22478) + Math.cos(22479) * 71;
+acc += Math.sin(22479) + Math.cos(22480) * 72;
+acc += Math.sin(22480) + Math.cos(22481) * 73;
+acc += Math.sin(22481) + Math.cos(22482) * 74;
+acc += Math.sin(22482) + Math.cos(22483) * 75;
+acc += Math.sin(22483) + Math.cos(22484) * 76;
+acc += Math.sin(22484) + Math.cos(22485) * 77;
+acc += Math.sin(22485) + Math.cos(22486) * 78;
+acc += Math.sin(22486) + Math.cos(22487) * 79;
+acc += Math.sin(22487) + Math.cos(22488) * 80;
+acc += Math.sin(22488) + Math.cos(22489) * 81;
+acc += Math.sin(22489) + Math.cos(22490) * 82;
+acc += Math.sin(22490) + Math.cos(22491) * 83;
+acc += Math.sin(22491) + Math.cos(22492) * 84;
+acc += Math.sin(22492) + Math.cos(22493) * 85;
+acc += Math.sin(22493) + Math.cos(22494) * 86;
+acc += Math.sin(22494) + Math.cos(22495) * 87;
+acc += Math.sin(22495) + Math.cos(22496) * 88;
+acc += Math.sin(22496) + Math.cos(22497) * 89;
+acc += Math.sin(22497) + Math.cos(22498) * 90;
+acc += Math.sin(22498) + Math.cos(22499) * 91;
+acc += Math.sin(22499) + Math.cos(22500) * 92;
+acc += Math.sin(22500) + Math.cos(22501) * 93;
+acc += Math.sin(22501) + Math.cos(22502) * 94;
+acc += Math.sin(22502) + Math.cos(22503) * 95;
+acc += Math.sin(22503) + Math.cos(22504) * 96;
+acc += Math.sin(22504) + Math.cos(22505) * 0;
+acc += Math.sin(22505) + Math.cos(22506) * 1;
+acc += Math.sin(22506) + Math.cos(22507) * 2;
+acc += Math.sin(22507) + Math.cos(22508) * 3;
+acc += Math.sin(22508) + Math.cos(22509) * 4;
+acc += Math.sin(22509) + Math.cos(22510) * 5;
+acc += Math.sin(22510) + Math.cos(22511) * 6;
+acc += Math.sin(22511) + Math.cos(22512) * 7;
+acc += Math.sin(22512) + Math.cos(22513) * 8;
+acc += Math.sin(22513) + Math.cos(22514) * 9;
+acc += Math.sin(22514) + Math.cos(22515) * 10;
+acc += Math.sin(22515) + Math.cos(22516) * 11;
+acc += Math.sin(22516) + Math.cos(22517) * 12;
+acc += Math.sin(22517) + Math.cos(22518) * 13;
+acc += Math.sin(22518) + Math.cos(22519) * 14;
+acc += Math.sin(22519) + Math.cos(22520) * 15;
+acc += Math.sin(22520) + Math.cos(22521) * 16;
+acc += Math.sin(22521) + Math.cos(22522) * 17;
+acc += Math.sin(22522) + Math.cos(22523) * 18;
+acc += Math.sin(22523) + Math.cos(22524) * 19;
+acc += Math.sin(22524) + Math.cos(22525) * 20;
+acc += Math.sin(22525) + Math.cos(22526) * 21;
+acc += Math.sin(22526) + Math.cos(22527) * 22;
+acc += Math.sin(22527) + Math.cos(22528) * 23;
+acc += Math.sin(22528) + Math.cos(22529) * 24;
+acc += Math.sin(22529) + Math.cos(22530) * 25;
+acc += Math.sin(22530) + Math.cos(22531) * 26;
+acc += Math.sin(22531) + Math.cos(22532) * 27;
+acc += Math.sin(22532) + Math.cos(22533) * 28;
+acc += Math.sin(22533) + Math.cos(22534) * 29;
+acc += Math.sin(22534) + Math.cos(22535) * 30;
+acc += Math.sin(22535) + Math.cos(22536) * 31;
+acc += Math.sin(22536) + Math.cos(22537) * 32;
+acc += Math.sin(22537) + Math.cos(22538) * 33;
+acc += Math.sin(22538) + Math.cos(22539) * 34;
+acc += Math.sin(22539) + Math.cos(22540) * 35;
+acc += Math.sin(22540) + Math.cos(22541) * 36;
+acc += Math.sin(22541) + Math.cos(22542) * 37;
+acc += Math.sin(22542) + Math.cos(22543) * 38;
+acc += Math.sin(22543) + Math.cos(22544) * 39;
+acc += Math.sin(22544) + Math.cos(22545) * 40;
+acc += Math.sin(22545) + Math.cos(22546) * 41;
+acc += Math.sin(22546) + Math.cos(22547) * 42;
+acc += Math.sin(22547) + Math.cos(22548) * 43;
+acc += Math.sin(22548) + Math.cos(22549) * 44;
+acc += Math.sin(22549) + Math.cos(22550) * 45;
+acc += Math.sin(22550) + Math.cos(22551) * 46;
+acc += Math.sin(22551) + Math.cos(22552) * 47;
+acc += Math.sin(22552) + Math.cos(22553) * 48;
+acc += Math.sin(22553) + Math.cos(22554) * 49;
+acc += Math.sin(22554) + Math.cos(22555) * 50;
+acc += Math.sin(22555) + Math.cos(22556) * 51;
+acc += Math.sin(22556) + Math.cos(22557) * 52;
+acc += Math.sin(22557) + Math.cos(22558) * 53;
+acc += Math.sin(22558) + Math.cos(22559) * 54;
+acc += Math.sin(22559) + Math.cos(22560) * 55;
+acc += Math.sin(22560) + Math.cos(22561) * 56;
+acc += Math.sin(22561) + Math.cos(22562) * 57;
+acc += Math.sin(22562) + Math.cos(22563) * 58;
+acc += Math.sin(22563) + Math.cos(22564) * 59;
+acc += Math.sin(22564) + Math.cos(22565) * 60;
+acc += Math.sin(22565) + Math.cos(22566) * 61;
+acc += Math.sin(22566) + Math.cos(22567) * 62;
+acc += Math.sin(22567) + Math.cos(22568) * 63;
+acc += Math.sin(22568) + Math.cos(22569) * 64;
+acc += Math.sin(22569) + Math.cos(22570) * 65;
+acc += Math.sin(22570) + Math.cos(22571) * 66;
+acc += Math.sin(22571) + Math.cos(22572) * 67;
+acc += Math.sin(22572) + Math.cos(22573) * 68;
+acc += Math.sin(22573) + Math.cos(22574) * 69;
+acc += Math.sin(22574) + Math.cos(22575) * 70;
+acc += Math.sin(22575) + Math.cos(22576) * 71;
+acc += Math.sin(22576) + Math.cos(22577) * 72;
+acc += Math.sin(22577) + Math.cos(22578) * 73;
+acc += Math.sin(22578) + Math.cos(22579) * 74;
+acc += Math.sin(22579) + Math.cos(22580) * 75;
+acc += Math.sin(22580) + Math.cos(22581) * 76;
+acc += Math.sin(22581) + Math.cos(22582) * 77;
+acc += Math.sin(22582) + Math.cos(22583) * 78;
+acc += Math.sin(22583) + Math.cos(22584) * 79;
+acc += Math.sin(22584) + Math.cos(22585) * 80;
+acc += Math.sin(22585) + Math.cos(22586) * 81;
+acc += Math.sin(22586) + Math.cos(22587) * 82;
+acc += Math.sin(22587) + Math.cos(22588) * 83;
+acc += Math.sin(22588) + Math.cos(22589) * 84;
+acc += Math.sin(22589) + Math.cos(22590) * 85;
+acc += Math.sin(22590) + Math.cos(22591) * 86;
+acc += Math.sin(22591) + Math.cos(22592) * 87;
+acc += Math.sin(22592) + Math.cos(22593) * 88;
+acc += Math.sin(22593) + Math.cos(22594) * 89;
+acc += Math.sin(22594) + Math.cos(22595) * 90;
+acc += Math.sin(22595) + Math.cos(22596) * 91;
+acc += Math.sin(22596) + Math.cos(22597) * 92;
+acc += Math.sin(22597) + Math.cos(22598) * 93;
+acc += Math.sin(22598) + Math.cos(22599) * 94;
+acc += Math.sin(22599) + Math.cos(22600) * 95;
+acc += Math.sin(22600) + Math.cos(22601) * 96;
+acc += Math.sin(22601) + Math.cos(22602) * 0;
+acc += Math.sin(22602) + Math.cos(22603) * 1;
+acc += Math.sin(22603) + Math.cos(22604) * 2;
+acc += Math.sin(22604) + Math.cos(22605) * 3;
+acc += Math.sin(22605) + Math.cos(22606) * 4;
+acc += Math.sin(22606) + Math.cos(22607) * 5;
+acc += Math.sin(22607) + Math.cos(22608) * 6;
+acc += Math.sin(22608) + Math.cos(22609) * 7;
+acc += Math.sin(22609) + Math.cos(22610) * 8;
+acc += Math.sin(22610) + Math.cos(22611) * 9;
+acc += Math.sin(22611) + Math.cos(22612) * 10;
+acc += Math.sin(22612) + Math.cos(22613) * 11;
+acc += Math.sin(22613) + Math.cos(22614) * 12;
+acc += Math.sin(22614) + Math.cos(22615) * 13;
+acc += Math.sin(22615) + Math.cos(22616) * 14;
+acc += Math.sin(22616) + Math.cos(22617) * 15;
+acc += Math.sin(22617) + Math.cos(22618) * 16;
+acc += Math.sin(22618) + Math.cos(22619) * 17;
+acc += Math.sin(22619) + Math.cos(22620) * 18;
+acc += Math.sin(22620) + Math.cos(22621) * 19;
+acc += Math.sin(22621) + Math.cos(22622) * 20;
+acc += Math.sin(22622) + Math.cos(22623) * 21;
+acc += Math.sin(22623) + Math.cos(22624) * 22;
+acc += Math.sin(22624) + Math.cos(22625) * 23;
+acc += Math.sin(22625) + Math.cos(22626) * 24;
+acc += Math.sin(22626) + Math.cos(22627) * 25;
+acc += Math.sin(22627) + Math.cos(22628) * 26;
+acc += Math.sin(22628) + Math.cos(22629) * 27;
+acc += Math.sin(22629) + Math.cos(22630) * 28;
+acc += Math.sin(22630) + Math.cos(22631) * 29;
+acc += Math.sin(22631) + Math.cos(22632) * 30;
+acc += Math.sin(22632) + Math.cos(22633) * 31;
+acc += Math.sin(22633) + Math.cos(22634) * 32;
+acc += Math.sin(22634) + Math.cos(22635) * 33;
+acc += Math.sin(22635) + Math.cos(22636) * 34;
+acc += Math.sin(22636) + Math.cos(22637) * 35;
+acc += Math.sin(22637) + Math.cos(22638) * 36;
+acc += Math.sin(22638) + Math.cos(22639) * 37;
+acc += Math.sin(22639) + Math.cos(22640) * 38;
+acc += Math.sin(22640) + Math.cos(22641) * 39;
+acc += Math.sin(22641) + Math.cos(22642) * 40;
+acc += Math.sin(22642) + Math.cos(22643) * 41;
+acc += Math.sin(22643) + Math.cos(22644) * 42;
+acc += Math.sin(22644) + Math.cos(22645) * 43;
+acc += Math.sin(22645) + Math.cos(22646) * 44;
+acc += Math.sin(22646) + Math.cos(22647) * 45;
+acc += Math.sin(22647) + Math.cos(22648) * 46;
+acc += Math.sin(22648) + Math.cos(22649) * 47;
+acc += Math.sin(22649) + Math.cos(22650) * 48;
+acc += Math.sin(22650) + Math.cos(22651) * 49;
+acc += Math.sin(22651) + Math.cos(22652) * 50;
+acc += Math.sin(22652) + Math.cos(22653) * 51;
+acc += Math.sin(22653) + Math.cos(22654) * 52;
+acc += Math.sin(22654) + Math.cos(22655) * 53;
+acc += Math.sin(22655) + Math.cos(22656) * 54;
+acc += Math.sin(22656) + Math.cos(22657) * 55;
+acc += Math.sin(22657) + Math.cos(22658) * 56;
+acc += Math.sin(22658) + Math.cos(22659) * 57;
+acc += Math.sin(22659) + Math.cos(22660) * 58;
+acc += Math.sin(22660) + Math.cos(22661) * 59;
+acc += Math.sin(22661) + Math.cos(22662) * 60;
+acc += Math.sin(22662) + Math.cos(22663) * 61;
+acc += Math.sin(22663) + Math.cos(22664) * 62;
+acc += Math.sin(22664) + Math.cos(22665) * 63;
+acc += Math.sin(22665) + Math.cos(22666) * 64;
+acc += Math.sin(22666) + Math.cos(22667) * 65;
+acc += Math.sin(22667) + Math.cos(22668) * 66;
+acc += Math.sin(22668) + Math.cos(22669) * 67;
+acc += Math.sin(22669) + Math.cos(22670) * 68;
+acc += Math.sin(22670) + Math.cos(22671) * 69;
+acc += Math.sin(22671) + Math.cos(22672) * 70;
+acc += Math.sin(22672) + Math.cos(22673) * 71;
+acc += Math.sin(22673) + Math.cos(22674) * 72;
+acc += Math.sin(22674) + Math.cos(22675) * 73;
+acc += Math.sin(22675) + Math.cos(22676) * 74;
+acc += Math.sin(22676) + Math.cos(22677) * 75;
+acc += Math.sin(22677) + Math.cos(22678) * 76;
+acc += Math.sin(22678) + Math.cos(22679) * 77;
+acc += Math.sin(22679) + Math.cos(22680) * 78;
+acc += Math.sin(22680) + Math.cos(22681) * 79;
+acc += Math.sin(22681) + Math.cos(22682) * 80;
+acc += Math.sin(22682) + Math.cos(22683) * 81;
+acc += Math.sin(22683) + Math.cos(22684) * 82;
+acc += Math.sin(22684) + Math.cos(22685) * 83;
+acc += Math.sin(22685) + Math.cos(22686) * 84;
+acc += Math.sin(22686) + Math.cos(22687) * 85;
+acc += Math.sin(22687) + Math.cos(22688) * 86;
+acc += Math.sin(22688) + Math.cos(22689) * 87;
+acc += Math.sin(22689) + Math.cos(22690) * 88;
+acc += Math.sin(22690) + Math.cos(22691) * 89;
+acc += Math.sin(22691) + Math.cos(22692) * 90;
+acc += Math.sin(22692) + Math.cos(22693) * 91;
+acc += Math.sin(22693) + Math.cos(22694) * 92;
+acc += Math.sin(22694) + Math.cos(22695) * 93;
+acc += Math.sin(22695) + Math.cos(22696) * 94;
+acc += Math.sin(22696) + Math.cos(22697) * 95;
+acc += Math.sin(22697) + Math.cos(22698) * 96;
+acc += Math.sin(22698) + Math.cos(22699) * 0;
+acc += Math.sin(22699) + Math.cos(22700) * 1;
+acc += Math.sin(22700) + Math.cos(22701) * 2;
+acc += Math.sin(22701) + Math.cos(22702) * 3;
+acc += Math.sin(22702) + Math.cos(22703) * 4;
+acc += Math.sin(22703) + Math.cos(22704) * 5;
+acc += Math.sin(22704) + Math.cos(22705) * 6;
+acc += Math.sin(22705) + Math.cos(22706) * 7;
+acc += Math.sin(22706) + Math.cos(22707) * 8;
+acc += Math.sin(22707) + Math.cos(22708) * 9;
+acc += Math.sin(22708) + Math.cos(22709) * 10;
+acc += Math.sin(22709) + Math.cos(22710) * 11;
+acc += Math.sin(22710) + Math.cos(22711) * 12;
+acc += Math.sin(22711) + Math.cos(22712) * 13;
+acc += Math.sin(22712) + Math.cos(22713) * 14;
+acc += Math.sin(22713) + Math.cos(22714) * 15;
+acc += Math.sin(22714) + Math.cos(22715) * 16;
+acc += Math.sin(22715) + Math.cos(22716) * 17;
+acc += Math.sin(22716) + Math.cos(22717) * 18;
+acc += Math.sin(22717) + Math.cos(22718) * 19;
+acc += Math.sin(22718) + Math.cos(22719) * 20;
+acc += Math.sin(22719) + Math.cos(22720) * 21;
+acc += Math.sin(22720) + Math.cos(22721) * 22;
+acc += Math.sin(22721) + Math.cos(22722) * 23;
+acc += Math.sin(22722) + Math.cos(22723) * 24;
+acc += Math.sin(22723) + Math.cos(22724) * 25;
+acc += Math.sin(22724) + Math.cos(22725) * 26;
+acc += Math.sin(22725) + Math.cos(22726) * 27;
+acc += Math.sin(22726) + Math.cos(22727) * 28;
+acc += Math.sin(22727) + Math.cos(22728) * 29;
+acc += Math.sin(22728) + Math.cos(22729) * 30;
+acc += Math.sin(22729) + Math.cos(22730) * 31;
+acc += Math.sin(22730) + Math.cos(22731) * 32;
+acc += Math.sin(22731) + Math.cos(22732) * 33;
+acc += Math.sin(22732) + Math.cos(22733) * 34;
+acc += Math.sin(22733) + Math.cos(22734) * 35;
+acc += Math.sin(22734) + Math.cos(22735) * 36;
+acc += Math.sin(22735) + Math.cos(22736) * 37;
+acc += Math.sin(22736) + Math.cos(22737) * 38;
+acc += Math.sin(22737) + Math.cos(22738) * 39;
+acc += Math.sin(22738) + Math.cos(22739) * 40;
+acc += Math.sin(22739) + Math.cos(22740) * 41;
+acc += Math.sin(22740) + Math.cos(22741) * 42;
+acc += Math.sin(22741) + Math.cos(22742) * 43;
+acc += Math.sin(22742) + Math.cos(22743) * 44;
+acc += Math.sin(22743) + Math.cos(22744) * 45;
+acc += Math.sin(22744) + Math.cos(22745) * 46;
+acc += Math.sin(22745) + Math.cos(22746) * 47;
+acc += Math.sin(22746) + Math.cos(22747) * 48;
+acc += Math.sin(22747) + Math.cos(22748) * 49;
+acc += Math.sin(22748) + Math.cos(22749) * 50;
+acc += Math.sin(22749) + Math.cos(22750) * 51;
+acc += Math.sin(22750) + Math.cos(22751) * 52;
+acc += Math.sin(22751) + Math.cos(22752) * 53;
+acc += Math.sin(22752) + Math.cos(22753) * 54;
+acc += Math.sin(22753) + Math.cos(22754) * 55;
+acc += Math.sin(22754) + Math.cos(22755) * 56;
+acc += Math.sin(22755) + Math.cos(22756) * 57;
+acc += Math.sin(22756) + Math.cos(22757) * 58;
+acc += Math.sin(22757) + Math.cos(22758) * 59;
+acc += Math.sin(22758) + Math.cos(22759) * 60;
+acc += Math.sin(22759) + Math.cos(22760) * 61;
+acc += Math.sin(22760) + Math.cos(22761) * 62;
+acc += Math.sin(22761) + Math.cos(22762) * 63;
+acc += Math.sin(22762) + Math.cos(22763) * 64;
+acc += Math.sin(22763) + Math.cos(22764) * 65;
+acc += Math.sin(22764) + Math.cos(22765) * 66;
+acc += Math.sin(22765) + Math.cos(22766) * 67;
+acc += Math.sin(22766) + Math.cos(22767) * 68;
+acc += Math.sin(22767) + Math.cos(22768) * 69;
+acc += Math.sin(22768) + Math.cos(22769) * 70;
+acc += Math.sin(22769) + Math.cos(22770) * 71;
+acc += Math.sin(22770) + Math.cos(22771) * 72;
+acc += Math.sin(22771) + Math.cos(22772) * 73;
+acc += Math.sin(22772) + Math.cos(22773) * 74;
+acc += Math.sin(22773) + Math.cos(22774) * 75;
+acc += Math.sin(22774) + Math.cos(22775) * 76;
+acc += Math.sin(22775) + Math.cos(22776) * 77;
+acc += Math.sin(22776) + Math.cos(22777) * 78;
+acc += Math.sin(22777) + Math.cos(22778) * 79;
+acc += Math.sin(22778) + Math.cos(22779) * 80;
+acc += Math.sin(22779) + Math.cos(22780) * 81;
+acc += Math.sin(22780) + Math.cos(22781) * 82;
+acc += Math.sin(22781) + Math.cos(22782) * 83;
+acc += Math.sin(22782) + Math.cos(22783) * 84;
+acc += Math.sin(22783) + Math.cos(22784) * 85;
+acc += Math.sin(22784) + Math.cos(22785) * 86;
+acc += Math.sin(22785) + Math.cos(22786) * 87;
+acc += Math.sin(22786) + Math.cos(22787) * 88;
+acc += Math.sin(22787) + Math.cos(22788) * 89;
+acc += Math.sin(22788) + Math.cos(22789) * 90;
+acc += Math.sin(22789) + Math.cos(22790) * 91;
+acc += Math.sin(22790) + Math.cos(22791) * 92;
+acc += Math.sin(22791) + Math.cos(22792) * 93;
+acc += Math.sin(22792) + Math.cos(22793) * 94;
+acc += Math.sin(22793) + Math.cos(22794) * 95;
+acc += Math.sin(22794) + Math.cos(22795) * 96;
+acc += Math.sin(22795) + Math.cos(22796) * 0;
+acc += Math.sin(22796) + Math.cos(22797) * 1;
+acc += Math.sin(22797) + Math.cos(22798) * 2;
+acc += Math.sin(22798) + Math.cos(22799) * 3;
+acc += Math.sin(22799) + Math.cos(22800) * 4;
+acc += Math.sin(22800) + Math.cos(22801) * 5;
+acc += Math.sin(22801) + Math.cos(22802) * 6;
+acc += Math.sin(22802) + Math.cos(22803) * 7;
+acc += Math.sin(22803) + Math.cos(22804) * 8;
+acc += Math.sin(22804) + Math.cos(22805) * 9;
+acc += Math.sin(22805) + Math.cos(22806) * 10;
+acc += Math.sin(22806) + Math.cos(22807) * 11;
+acc += Math.sin(22807) + Math.cos(22808) * 12;
+acc += Math.sin(22808) + Math.cos(22809) * 13;
+acc += Math.sin(22809) + Math.cos(22810) * 14;
+acc += Math.sin(22810) + Math.cos(22811) * 15;
+acc += Math.sin(22811) + Math.cos(22812) * 16;
+acc += Math.sin(22812) + Math.cos(22813) * 17;
+acc += Math.sin(22813) + Math.cos(22814) * 18;
+acc += Math.sin(22814) + Math.cos(22815) * 19;
+acc += Math.sin(22815) + Math.cos(22816) * 20;
+acc += Math.sin(22816) + Math.cos(22817) * 21;
+acc += Math.sin(22817) + Math.cos(22818) * 22;
+acc += Math.sin(22818) + Math.cos(22819) * 23;
+acc += Math.sin(22819) + Math.cos(22820) * 24;
+acc += Math.sin(22820) + Math.cos(22821) * 25;
+acc += Math.sin(22821) + Math.cos(22822) * 26;
+acc += Math.sin(22822) + Math.cos(22823) * 27;
+acc += Math.sin(22823) + Math.cos(22824) * 28;
+acc += Math.sin(22824) + Math.cos(22825) * 29;
+acc += Math.sin(22825) + Math.cos(22826) * 30;
+acc += Math.sin(22826) + Math.cos(22827) * 31;
+acc += Math.sin(22827) + Math.cos(22828) * 32;
+acc += Math.sin(22828) + Math.cos(22829) * 33;
+acc += Math.sin(22829) + Math.cos(22830) * 34;
+acc += Math.sin(22830) + Math.cos(22831) * 35;
+acc += Math.sin(22831) + Math.cos(22832) * 36;
+acc += Math.sin(22832) + Math.cos(22833) * 37;
+acc += Math.sin(22833) + Math.cos(22834) * 38;
+acc += Math.sin(22834) + Math.cos(22835) * 39;
+acc += Math.sin(22835) + Math.cos(22836) * 40;
+acc += Math.sin(22836) + Math.cos(22837) * 41;
+acc += Math.sin(22837) + Math.cos(22838) * 42;
+acc += Math.sin(22838) + Math.cos(22839) * 43;
+acc += Math.sin(22839) + Math.cos(22840) * 44;
+acc += Math.sin(22840) + Math.cos(22841) * 45;
+acc += Math.sin(22841) + Math.cos(22842) * 46;
+acc += Math.sin(22842) + Math.cos(22843) * 47;
+acc += Math.sin(22843) + Math.cos(22844) * 48;
+acc += Math.sin(22844) + Math.cos(22845) * 49;
+acc += Math.sin(22845) + Math.cos(22846) * 50;
+acc += Math.sin(22846) + Math.cos(22847) * 51;
+acc += Math.sin(22847) + Math.cos(22848) * 52;
+acc += Math.sin(22848) + Math.cos(22849) * 53;
+acc += Math.sin(22849) + Math.cos(22850) * 54;
+acc += Math.sin(22850) + Math.cos(22851) * 55;
+acc += Math.sin(22851) + Math.cos(22852) * 56;
+acc += Math.sin(22852) + Math.cos(22853) * 57;
+acc += Math.sin(22853) + Math.cos(22854) * 58;
+acc += Math.sin(22854) + Math.cos(22855) * 59;
+acc += Math.sin(22855) + Math.cos(22856) * 60;
+acc += Math.sin(22856) + Math.cos(22857) * 61;
+acc += Math.sin(22857) + Math.cos(22858) * 62;
+acc += Math.sin(22858) + Math.cos(22859) * 63;
+acc += Math.sin(22859) + Math.cos(22860) * 64;
+acc += Math.sin(22860) + Math.cos(22861) * 65;
+acc += Math.sin(22861) + Math.cos(22862) * 66;
+acc += Math.sin(22862) + Math.cos(22863) * 67;
+acc += Math.sin(22863) + Math.cos(22864) * 68;
+acc += Math.sin(22864) + Math.cos(22865) * 69;
+acc += Math.sin(22865) + Math.cos(22866) * 70;
+acc += Math.sin(22866) + Math.cos(22867) * 71;
+acc += Math.sin(22867) + Math.cos(22868) * 72;
+acc += Math.sin(22868) + Math.cos(22869) * 73;
+acc += Math.sin(22869) + Math.cos(22870) * 74;
+acc += Math.sin(22870) + Math.cos(22871) * 75;
+acc += Math.sin(22871) + Math.cos(22872) * 76;
+acc += Math.sin(22872) + Math.cos(22873) * 77;
+acc += Math.sin(22873) + Math.cos(22874) * 78;
+acc += Math.sin(22874) + Math.cos(22875) * 79;
+acc += Math.sin(22875) + Math.cos(22876) * 80;
+acc += Math.sin(22876) + Math.cos(22877) * 81;
+acc += Math.sin(22877) + Math.cos(22878) * 82;
+acc += Math.sin(22878) + Math.cos(22879) * 83;
+acc += Math.sin(22879) + Math.cos(22880) * 84;
+acc += Math.sin(22880) + Math.cos(22881) * 85;
+acc += Math.sin(22881) + Math.cos(22882) * 86;
+acc += Math.sin(22882) + Math.cos(22883) * 87;
+acc += Math.sin(22883) + Math.cos(22884) * 88;
+acc += Math.sin(22884) + Math.cos(22885) * 89;
+acc += Math.sin(22885) + Math.cos(22886) * 90;
+acc += Math.sin(22886) + Math.cos(22887) * 91;
+acc += Math.sin(22887) + Math.cos(22888) * 92;
+acc += Math.sin(22888) + Math.cos(22889) * 93;
+acc += Math.sin(22889) + Math.cos(22890) * 94;
+acc += Math.sin(22890) + Math.cos(22891) * 95;
+acc += Math.sin(22891) + Math.cos(22892) * 96;
+acc += Math.sin(22892) + Math.cos(22893) * 0;
+acc += Math.sin(22893) + Math.cos(22894) * 1;
+acc += Math.sin(22894) + Math.cos(22895) * 2;
+acc += Math.sin(22895) + Math.cos(22896) * 3;
+acc += Math.sin(22896) + Math.cos(22897) * 4;
+acc += Math.sin(22897) + Math.cos(22898) * 5;
+acc += Math.sin(22898) + Math.cos(22899) * 6;
+acc += Math.sin(22899) + Math.cos(22900) * 7;
+acc += Math.sin(22900) + Math.cos(22901) * 8;
+acc += Math.sin(22901) + Math.cos(22902) * 9;
+acc += Math.sin(22902) + Math.cos(22903) * 10;
+acc += Math.sin(22903) + Math.cos(22904) * 11;
+acc += Math.sin(22904) + Math.cos(22905) * 12;
+acc += Math.sin(22905) + Math.cos(22906) * 13;
+acc += Math.sin(22906) + Math.cos(22907) * 14;
+acc += Math.sin(22907) + Math.cos(22908) * 15;
+acc += Math.sin(22908) + Math.cos(22909) * 16;
+acc += Math.sin(22909) + Math.cos(22910) * 17;
+acc += Math.sin(22910) + Math.cos(22911) * 18;
+acc += Math.sin(22911) + Math.cos(22912) * 19;
+acc += Math.sin(22912) + Math.cos(22913) * 20;
+acc += Math.sin(22913) + Math.cos(22914) * 21;
+acc += Math.sin(22914) + Math.cos(22915) * 22;
+acc += Math.sin(22915) + Math.cos(22916) * 23;
+acc += Math.sin(22916) + Math.cos(22917) * 24;
+acc += Math.sin(22917) + Math.cos(22918) * 25;
+acc += Math.sin(22918) + Math.cos(22919) * 26;
+acc += Math.sin(22919) + Math.cos(22920) * 27;
+acc += Math.sin(22920) + Math.cos(22921) * 28;
+acc += Math.sin(22921) + Math.cos(22922) * 29;
+acc += Math.sin(22922) + Math.cos(22923) * 30;
+acc += Math.sin(22923) + Math.cos(22924) * 31;
+acc += Math.sin(22924) + Math.cos(22925) * 32;
+acc += Math.sin(22925) + Math.cos(22926) * 33;
+acc += Math.sin(22926) + Math.cos(22927) * 34;
+acc += Math.sin(22927) + Math.cos(22928) * 35;
+acc += Math.sin(22928) + Math.cos(22929) * 36;
+acc += Math.sin(22929) + Math.cos(22930) * 37;
+acc += Math.sin(22930) + Math.cos(22931) * 38;
+acc += Math.sin(22931) + Math.cos(22932) * 39;
+acc += Math.sin(22932) + Math.cos(22933) * 40;
+acc += Math.sin(22933) + Math.cos(22934) * 41;
+acc += Math.sin(22934) + Math.cos(22935) * 42;
+acc += Math.sin(22935) + Math.cos(22936) * 43;
+acc += Math.sin(22936) + Math.cos(22937) * 44;
+acc += Math.sin(22937) + Math.cos(22938) * 45;
+acc += Math.sin(22938) + Math.cos(22939) * 46;
+acc += Math.sin(22939) + Math.cos(22940) * 47;
+acc += Math.sin(22940) + Math.cos(22941) * 48;
+acc += Math.sin(22941) + Math.cos(22942) * 49;
+acc += Math.sin(22942) + Math.cos(22943) * 50;
+acc += Math.sin(22943) + Math.cos(22944) * 51;
+acc += Math.sin(22944) + Math.cos(22945) * 52;
+acc += Math.sin(22945) + Math.cos(22946) * 53;
+acc += Math.sin(22946) + Math.cos(22947) * 54;
+acc += Math.sin(22947) + Math.cos(22948) * 55;
+acc += Math.sin(22948) + Math.cos(22949) * 56;
+acc += Math.sin(22949) + Math.cos(22950) * 57;
+acc += Math.sin(22950) + Math.cos(22951) * 58;
+acc += Math.sin(22951) + Math.cos(22952) * 59;
+acc += Math.sin(22952) + Math.cos(22953) * 60;
+acc += Math.sin(22953) + Math.cos(22954) * 61;
+acc += Math.sin(22954) + Math.cos(22955) * 62;
+acc += Math.sin(22955) + Math.cos(22956) * 63;
+acc += Math.sin(22956) + Math.cos(22957) * 64;
+acc += Math.sin(22957) + Math.cos(22958) * 65;
+acc += Math.sin(22958) + Math.cos(22959) * 66;
+acc += Math.sin(22959) + Math.cos(22960) * 67;
+acc += Math.sin(22960) + Math.cos(22961) * 68;
+acc += Math.sin(22961) + Math.cos(22962) * 69;
+acc += Math.sin(22962) + Math.cos(22963) * 70;
+acc += Math.sin(22963) + Math.cos(22964) * 71;
+acc += Math.sin(22964) + Math.cos(22965) * 72;
+acc += Math.sin(22965) + Math.cos(22966) * 73;
+acc += Math.sin(22966) + Math.cos(22967) * 74;
+acc += Math.sin(22967) + Math.cos(22968) * 75;
+acc += Math.sin(22968) + Math.cos(22969) * 76;
+acc += Math.sin(22969) + Math.cos(22970) * 77;
+acc += Math.sin(22970) + Math.cos(22971) * 78;
+acc += Math.sin(22971) + Math.cos(22972) * 79;
+acc += Math.sin(22972) + Math.cos(22973) * 80;
+acc += Math.sin(22973) + Math.cos(22974) * 81;
+acc += Math.sin(22974) + Math.cos(22975) * 82;
+acc += Math.sin(22975) + Math.cos(22976) * 83;
+acc += Math.sin(22976) + Math.cos(22977) * 84;
+acc += Math.sin(22977) + Math.cos(22978) * 85;
+acc += Math.sin(22978) + Math.cos(22979) * 86;
+acc += Math.sin(22979) + Math.cos(22980) * 87;
+acc += Math.sin(22980) + Math.cos(22981) * 88;
+acc += Math.sin(22981) + Math.cos(22982) * 89;
+acc += Math.sin(22982) + Math.cos(22983) * 90;
+acc += Math.sin(22983) + Math.cos(22984) * 91;
+acc += Math.sin(22984) + Math.cos(22985) * 92;
+acc += Math.sin(22985) + Math.cos(22986) * 93;
+acc += Math.sin(22986) + Math.cos(22987) * 94;
+acc += Math.sin(22987) + Math.cos(22988) * 95;
+acc += Math.sin(22988) + Math.cos(22989) * 96;
+acc += Math.sin(22989) + Math.cos(22990) * 0;
+acc += Math.sin(22990) + Math.cos(22991) * 1;
+acc += Math.sin(22991) + Math.cos(22992) * 2;
+acc += Math.sin(22992) + Math.cos(22993) * 3;
+acc += Math.sin(22993) + Math.cos(22994) * 4;
+acc += Math.sin(22994) + Math.cos(22995) * 5;
+acc += Math.sin(22995) + Math.cos(22996) * 6;
+acc += Math.sin(22996) + Math.cos(22997) * 7;
+acc += Math.sin(22997) + Math.cos(22998) * 8;
+acc += Math.sin(22998) + Math.cos(22999) * 9;
+acc += Math.sin(22999) + Math.cos(23000) * 10;
+acc += Math.sin(23000) + Math.cos(23001) * 11;
+acc += Math.sin(23001) + Math.cos(23002) * 12;
+acc += Math.sin(23002) + Math.cos(23003) * 13;
+acc += Math.sin(23003) + Math.cos(23004) * 14;
+acc += Math.sin(23004) + Math.cos(23005) * 15;
+acc += Math.sin(23005) + Math.cos(23006) * 16;
+acc += Math.sin(23006) + Math.cos(23007) * 17;
+acc += Math.sin(23007) + Math.cos(23008) * 18;
+acc += Math.sin(23008) + Math.cos(23009) * 19;
+acc += Math.sin(23009) + Math.cos(23010) * 20;
+acc += Math.sin(23010) + Math.cos(23011) * 21;
+acc += Math.sin(23011) + Math.cos(23012) * 22;
+acc += Math.sin(23012) + Math.cos(23013) * 23;
+acc += Math.sin(23013) + Math.cos(23014) * 24;
+acc += Math.sin(23014) + Math.cos(23015) * 25;
+acc += Math.sin(23015) + Math.cos(23016) * 26;
+acc += Math.sin(23016) + Math.cos(23017) * 27;
+acc += Math.sin(23017) + Math.cos(23018) * 28;
+acc += Math.sin(23018) + Math.cos(23019) * 29;
+acc += Math.sin(23019) + Math.cos(23020) * 30;
+acc += Math.sin(23020) + Math.cos(23021) * 31;
+acc += Math.sin(23021) + Math.cos(23022) * 32;
+acc += Math.sin(23022) + Math.cos(23023) * 33;
+acc += Math.sin(23023) + Math.cos(23024) * 34;
+acc += Math.sin(23024) + Math.cos(23025) * 35;
+acc += Math.sin(23025) + Math.cos(23026) * 36;
+acc += Math.sin(23026) + Math.cos(23027) * 37;
+acc += Math.sin(23027) + Math.cos(23028) * 38;
+acc += Math.sin(23028) + Math.cos(23029) * 39;
+acc += Math.sin(23029) + Math.cos(23030) * 40;
+acc += Math.sin(23030) + Math.cos(23031) * 41;
+acc += Math.sin(23031) + Math.cos(23032) * 42;
+acc += Math.sin(23032) + Math.cos(23033) * 43;
+acc += Math.sin(23033) + Math.cos(23034) * 44;
+acc += Math.sin(23034) + Math.cos(23035) * 45;
+acc += Math.sin(23035) + Math.cos(23036) * 46;
+acc += Math.sin(23036) + Math.cos(23037) * 47;
+acc += Math.sin(23037) + Math.cos(23038) * 48;
+acc += Math.sin(23038) + Math.cos(23039) * 49;
+acc += Math.sin(23039) + Math.cos(23040) * 50;
+acc += Math.sin(23040) + Math.cos(23041) * 51;
+acc += Math.sin(23041) + Math.cos(23042) * 52;
+acc += Math.sin(23042) + Math.cos(23043) * 53;
+acc += Math.sin(23043) + Math.cos(23044) * 54;
+acc += Math.sin(23044) + Math.cos(23045) * 55;
+acc += Math.sin(23045) + Math.cos(23046) * 56;
+acc += Math.sin(23046) + Math.cos(23047) * 57;
+acc += Math.sin(23047) + Math.cos(23048) * 58;
+acc += Math.sin(23048) + Math.cos(23049) * 59;
+acc += Math.sin(23049) + Math.cos(23050) * 60;
+acc += Math.sin(23050) + Math.cos(23051) * 61;
+acc += Math.sin(23051) + Math.cos(23052) * 62;
+acc += Math.sin(23052) + Math.cos(23053) * 63;
+acc += Math.sin(23053) + Math.cos(23054) * 64;
+acc += Math.sin(23054) + Math.cos(23055) * 65;
+acc += Math.sin(23055) + Math.cos(23056) * 66;
+acc += Math.sin(23056) + Math.cos(23057) * 67;
+acc += Math.sin(23057) + Math.cos(23058) * 68;
+acc += Math.sin(23058) + Math.cos(23059) * 69;
+acc += Math.sin(23059) + Math.cos(23060) * 70;
+acc += Math.sin(23060) + Math.cos(23061) * 71;
+acc += Math.sin(23061) + Math.cos(23062) * 72;
+acc += Math.sin(23062) + Math.cos(23063) * 73;
+acc += Math.sin(23063) + Math.cos(23064) * 74;
+acc += Math.sin(23064) + Math.cos(23065) * 75;
+acc += Math.sin(23065) + Math.cos(23066) * 76;
+acc += Math.sin(23066) + Math.cos(23067) * 77;
+acc += Math.sin(23067) + Math.cos(23068) * 78;
+acc += Math.sin(23068) + Math.cos(23069) * 79;
+acc += Math.sin(23069) + Math.cos(23070) * 80;
+acc += Math.sin(23070) + Math.cos(23071) * 81;
+acc += Math.sin(23071) + Math.cos(23072) * 82;
+acc += Math.sin(23072) + Math.cos(23073) * 83;
+acc += Math.sin(23073) + Math.cos(23074) * 84;
+acc += Math.sin(23074) + Math.cos(23075) * 85;
+acc += Math.sin(23075) + Math.cos(23076) * 86;
+acc += Math.sin(23076) + Math.cos(23077) * 87;
+acc += Math.sin(23077) + Math.cos(23078) * 88;
+acc += Math.sin(23078) + Math.cos(23079) * 89;
+acc += Math.sin(23079) + Math.cos(23080) * 90;
+acc += Math.sin(23080) + Math.cos(23081) * 91;
+acc += Math.sin(23081) + Math.cos(23082) * 92;
+acc += Math.sin(23082) + Math.cos(23083) * 93;
+acc += Math.sin(23083) + Math.cos(23084) * 94;
+acc += Math.sin(23084) + Math.cos(23085) * 95;
+acc += Math.sin(23085) + Math.cos(23086) * 96;
+acc += Math.sin(23086) + Math.cos(23087) * 0;
+acc += Math.sin(23087) + Math.cos(23088) * 1;
+acc += Math.sin(23088) + Math.cos(23089) * 2;
+acc += Math.sin(23089) + Math.cos(23090) * 3;
+acc += Math.sin(23090) + Math.cos(23091) * 4;
+acc += Math.sin(23091) + Math.cos(23092) * 5;
+acc += Math.sin(23092) + Math.cos(23093) * 6;
+acc += Math.sin(23093) + Math.cos(23094) * 7;
+acc += Math.sin(23094) + Math.cos(23095) * 8;
+acc += Math.sin(23095) + Math.cos(23096) * 9;
+acc += Math.sin(23096) + Math.cos(23097) * 10;
+acc += Math.sin(23097) + Math.cos(23098) * 11;
+acc += Math.sin(23098) + Math.cos(23099) * 12;
+acc += Math.sin(23099) + Math.cos(23100) * 13;
+acc += Math.sin(23100) + Math.cos(23101) * 14;
+acc += Math.sin(23101) + Math.cos(23102) * 15;
+acc += Math.sin(23102) + Math.cos(23103) * 16;
+acc += Math.sin(23103) + Math.cos(23104) * 17;
+acc += Math.sin(23104) + Math.cos(23105) * 18;
+acc += Math.sin(23105) + Math.cos(23106) * 19;
+acc += Math.sin(23106) + Math.cos(23107) * 20;
+acc += Math.sin(23107) + Math.cos(23108) * 21;
+acc += Math.sin(23108) + Math.cos(23109) * 22;
+acc += Math.sin(23109) + Math.cos(23110) * 23;
+acc += Math.sin(23110) + Math.cos(23111) * 24;
+acc += Math.sin(23111) + Math.cos(23112) * 25;
+acc += Math.sin(23112) + Math.cos(23113) * 26;
+acc += Math.sin(23113) + Math.cos(23114) * 27;
+acc += Math.sin(23114) + Math.cos(23115) * 28;
+acc += Math.sin(23115) + Math.cos(23116) * 29;
+acc += Math.sin(23116) + Math.cos(23117) * 30;
+acc += Math.sin(23117) + Math.cos(23118) * 31;
+acc += Math.sin(23118) + Math.cos(23119) * 32;
+acc += Math.sin(23119) + Math.cos(23120) * 33;
+acc += Math.sin(23120) + Math.cos(23121) * 34;
+acc += Math.sin(23121) + Math.cos(23122) * 35;
+acc += Math.sin(23122) + Math.cos(23123) * 36;
+acc += Math.sin(23123) + Math.cos(23124) * 37;
+acc += Math.sin(23124) + Math.cos(23125) * 38;
+acc += Math.sin(23125) + Math.cos(23126) * 39;
+acc += Math.sin(23126) + Math.cos(23127) * 40;
+acc += Math.sin(23127) + Math.cos(23128) * 41;
+acc += Math.sin(23128) + Math.cos(23129) * 42;
+acc += Math.sin(23129) + Math.cos(23130) * 43;
+acc += Math.sin(23130) + Math.cos(23131) * 44;
+acc += Math.sin(23131) + Math.cos(23132) * 45;
+acc += Math.sin(23132) + Math.cos(23133) * 46;
+acc += Math.sin(23133) + Math.cos(23134) * 47;
+acc += Math.sin(23134) + Math.cos(23135) * 48;
+acc += Math.sin(23135) + Math.cos(23136) * 49;
+acc += Math.sin(23136) + Math.cos(23137) * 50;
+acc += Math.sin(23137) + Math.cos(23138) * 51;
+acc += Math.sin(23138) + Math.cos(23139) * 52;
+acc += Math.sin(23139) + Math.cos(23140) * 53;
+acc += Math.sin(23140) + Math.cos(23141) * 54;
+acc += Math.sin(23141) + Math.cos(23142) * 55;
+acc += Math.sin(23142) + Math.cos(23143) * 56;
+acc += Math.sin(23143) + Math.cos(23144) * 57;
+acc += Math.sin(23144) + Math.cos(23145) * 58;
+acc += Math.sin(23145) + Math.cos(23146) * 59;
+acc += Math.sin(23146) + Math.cos(23147) * 60;
+acc += Math.sin(23147) + Math.cos(23148) * 61;
+acc += Math.sin(23148) + Math.cos(23149) * 62;
+acc += Math.sin(23149) + Math.cos(23150) * 63;
+acc += Math.sin(23150) + Math.cos(23151) * 64;
+acc += Math.sin(23151) + Math.cos(23152) * 65;
+acc += Math.sin(23152) + Math.cos(23153) * 66;
+acc += Math.sin(23153) + Math.cos(23154) * 67;
+acc += Math.sin(23154) + Math.cos(23155) * 68;
+acc += Math.sin(23155) + Math.cos(23156) * 69;
+acc += Math.sin(23156) + Math.cos(23157) * 70;
+acc += Math.sin(23157) + Math.cos(23158) * 71;
+acc += Math.sin(23158) + Math.cos(23159) * 72;
+acc += Math.sin(23159) + Math.cos(23160) * 73;
+acc += Math.sin(23160) + Math.cos(23161) * 74;
+acc += Math.sin(23161) + Math.cos(23162) * 75;
+acc += Math.sin(23162) + Math.cos(23163) * 76;
+acc += Math.sin(23163) + Math.cos(23164) * 77;
+acc += Math.sin(23164) + Math.cos(23165) * 78;
+acc += Math.sin(23165) + Math.cos(23166) * 79;
+acc += Math.sin(23166) + Math.cos(23167) * 80;
+acc += Math.sin(23167) + Math.cos(23168) * 81;
+acc += Math.sin(23168) + Math.cos(23169) * 82;
+acc += Math.sin(23169) + Math.cos(23170) * 83;
+acc += Math.sin(23170) + Math.cos(23171) * 84;
+acc += Math.sin(23171) + Math.cos(23172) * 85;
+acc += Math.sin(23172) + Math.cos(23173) * 86;
+acc += Math.sin(23173) + Math.cos(23174) * 87;
+acc += Math.sin(23174) + Math.cos(23175) * 88;
+acc += Math.sin(23175) + Math.cos(23176) * 89;
+acc += Math.sin(23176) + Math.cos(23177) * 90;
+acc += Math.sin(23177) + Math.cos(23178) * 91;
+acc += Math.sin(23178) + Math.cos(23179) * 92;
+acc += Math.sin(23179) + Math.cos(23180) * 93;
+acc += Math.sin(23180) + Math.cos(23181) * 94;
+acc += Math.sin(23181) + Math.cos(23182) * 95;
+acc += Math.sin(23182) + Math.cos(23183) * 96;
+acc += Math.sin(23183) + Math.cos(23184) * 0;
+acc += Math.sin(23184) + Math.cos(23185) * 1;
+acc += Math.sin(23185) + Math.cos(23186) * 2;
+acc += Math.sin(23186) + Math.cos(23187) * 3;
+acc += Math.sin(23187) + Math.cos(23188) * 4;
+acc += Math.sin(23188) + Math.cos(23189) * 5;
+acc += Math.sin(23189) + Math.cos(23190) * 6;
+acc += Math.sin(23190) + Math.cos(23191) * 7;
+acc += Math.sin(23191) + Math.cos(23192) * 8;
+acc += Math.sin(23192) + Math.cos(23193) * 9;
+acc += Math.sin(23193) + Math.cos(23194) * 10;
+acc += Math.sin(23194) + Math.cos(23195) * 11;
+acc += Math.sin(23195) + Math.cos(23196) * 12;
+acc += Math.sin(23196) + Math.cos(23197) * 13;
+acc += Math.sin(23197) + Math.cos(23198) * 14;
+acc += Math.sin(23198) + Math.cos(23199) * 15;
+acc += Math.sin(23199) + Math.cos(23200) * 16;
+acc += Math.sin(23200) + Math.cos(23201) * 17;
+acc += Math.sin(23201) + Math.cos(23202) * 18;
+acc += Math.sin(23202) + Math.cos(23203) * 19;
+acc += Math.sin(23203) + Math.cos(23204) * 20;
+acc += Math.sin(23204) + Math.cos(23205) * 21;
+acc += Math.sin(23205) + Math.cos(23206) * 22;
+acc += Math.sin(23206) + Math.cos(23207) * 23;
+acc += Math.sin(23207) + Math.cos(23208) * 24;
+acc += Math.sin(23208) + Math.cos(23209) * 25;
+acc += Math.sin(23209) + Math.cos(23210) * 26;
+acc += Math.sin(23210) + Math.cos(23211) * 27;
+acc += Math.sin(23211) + Math.cos(23212) * 28;
+acc += Math.sin(23212) + Math.cos(23213) * 29;
+acc += Math.sin(23213) + Math.cos(23214) * 30;
+acc += Math.sin(23214) + Math.cos(23215) * 31;
+acc += Math.sin(23215) + Math.cos(23216) * 32;
+acc += Math.sin(23216) + Math.cos(23217) * 33;
+acc += Math.sin(23217) + Math.cos(23218) * 34;
+acc += Math.sin(23218) + Math.cos(23219) * 35;
+acc += Math.sin(23219) + Math.cos(23220) * 36;
+acc += Math.sin(23220) + Math.cos(23221) * 37;
+acc += Math.sin(23221) + Math.cos(23222) * 38;
+acc += Math.sin(23222) + Math.cos(23223) * 39;
+acc += Math.sin(23223) + Math.cos(23224) * 40;
+acc += Math.sin(23224) + Math.cos(23225) * 41;
+acc += Math.sin(23225) + Math.cos(23226) * 42;
+acc += Math.sin(23226) + Math.cos(23227) * 43;
+acc += Math.sin(23227) + Math.cos(23228) * 44;
+acc += Math.sin(23228) + Math.cos(23229) * 45;
+acc += Math.sin(23229) + Math.cos(23230) * 46;
+acc += Math.sin(23230) + Math.cos(23231) * 47;
+acc += Math.sin(23231) + Math.cos(23232) * 48;
+acc += Math.sin(23232) + Math.cos(23233) * 49;
+acc += Math.sin(23233) + Math.cos(23234) * 50;
+acc += Math.sin(23234) + Math.cos(23235) * 51;
+acc += Math.sin(23235) + Math.cos(23236) * 52;
+acc += Math.sin(23236) + Math.cos(23237) * 53;
+acc += Math.sin(23237) + Math.cos(23238) * 54;
+acc += Math.sin(23238) + Math.cos(23239) * 55;
+acc += Math.sin(23239) + Math.cos(23240) * 56;
+acc += Math.sin(23240) + Math.cos(23241) * 57;
+acc += Math.sin(23241) + Math.cos(23242) * 58;
+acc += Math.sin(23242) + Math.cos(23243) * 59;
+acc += Math.sin(23243) + Math.cos(23244) * 60;
+acc += Math.sin(23244) + Math.cos(23245) * 61;
+acc += Math.sin(23245) + Math.cos(23246) * 62;
+acc += Math.sin(23246) + Math.cos(23247) * 63;
+acc += Math.sin(23247) + Math.cos(23248) * 64;
+acc += Math.sin(23248) + Math.cos(23249) * 65;
+acc += Math.sin(23249) + Math.cos(23250) * 66;
+acc += Math.sin(23250) + Math.cos(23251) * 67;
+acc += Math.sin(23251) + Math.cos(23252) * 68;
+acc += Math.sin(23252) + Math.cos(23253) * 69;
+acc += Math.sin(23253) + Math.cos(23254) * 70;
+acc += Math.sin(23254) + Math.cos(23255) * 71;
+acc += Math.sin(23255) + Math.cos(23256) * 72;
+acc += Math.sin(23256) + Math.cos(23257) * 73;
+acc += Math.sin(23257) + Math.cos(23258) * 74;
+acc += Math.sin(23258) + Math.cos(23259) * 75;
+acc += Math.sin(23259) + Math.cos(23260) * 76;
+acc += Math.sin(23260) + Math.cos(23261) * 77;
+acc += Math.sin(23261) + Math.cos(23262) * 78;
+acc += Math.sin(23262) + Math.cos(23263) * 79;
+acc += Math.sin(23263) + Math.cos(23264) * 80;
+acc += Math.sin(23264) + Math.cos(23265) * 81;
+acc += Math.sin(23265) + Math.cos(23266) * 82;
+acc += Math.sin(23266) + Math.cos(23267) * 83;
+acc += Math.sin(23267) + Math.cos(23268) * 84;
+acc += Math.sin(23268) + Math.cos(23269) * 85;
+acc += Math.sin(23269) + Math.cos(23270) * 86;
+acc += Math.sin(23270) + Math.cos(23271) * 87;
+acc += Math.sin(23271) + Math.cos(23272) * 88;
+acc += Math.sin(23272) + Math.cos(23273) * 89;
+acc += Math.sin(23273) + Math.cos(23274) * 90;
+acc += Math.sin(23274) + Math.cos(23275) * 91;
+acc += Math.sin(23275) + Math.cos(23276) * 92;
+acc += Math.sin(23276) + Math.cos(23277) * 93;
+acc += Math.sin(23277) + Math.cos(23278) * 94;
+acc += Math.sin(23278) + Math.cos(23279) * 95;
+acc += Math.sin(23279) + Math.cos(23280) * 96;
+acc += Math.sin(23280) + Math.cos(23281) * 0;
+acc += Math.sin(23281) + Math.cos(23282) * 1;
+acc += Math.sin(23282) + Math.cos(23283) * 2;
+acc += Math.sin(23283) + Math.cos(23284) * 3;
+acc += Math.sin(23284) + Math.cos(23285) * 4;
+acc += Math.sin(23285) + Math.cos(23286) * 5;
+acc += Math.sin(23286) + Math.cos(23287) * 6;
+acc += Math.sin(23287) + Math.cos(23288) * 7;
+acc += Math.sin(23288) + Math.cos(23289) * 8;
+acc += Math.sin(23289) + Math.cos(23290) * 9;
+acc += Math.sin(23290) + Math.cos(23291) * 10;
+acc += Math.sin(23291) + Math.cos(23292) * 11;
+acc += Math.sin(23292) + Math.cos(23293) * 12;
+acc += Math.sin(23293) + Math.cos(23294) * 13;
+acc += Math.sin(23294) + Math.cos(23295) * 14;
+acc += Math.sin(23295) + Math.cos(23296) * 15;
+acc += Math.sin(23296) + Math.cos(23297) * 16;
+acc += Math.sin(23297) + Math.cos(23298) * 17;
+acc += Math.sin(23298) + Math.cos(23299) * 18;
+acc += Math.sin(23299) + Math.cos(23300) * 19;
+acc += Math.sin(23300) + Math.cos(23301) * 20;
+acc += Math.sin(23301) + Math.cos(23302) * 21;
+acc += Math.sin(23302) + Math.cos(23303) * 22;
+acc += Math.sin(23303) + Math.cos(23304) * 23;
+acc += Math.sin(23304) + Math.cos(23305) * 24;
+acc += Math.sin(23305) + Math.cos(23306) * 25;
+acc += Math.sin(23306) + Math.cos(23307) * 26;
+acc += Math.sin(23307) + Math.cos(23308) * 27;
+acc += Math.sin(23308) + Math.cos(23309) * 28;
+acc += Math.sin(23309) + Math.cos(23310) * 29;
+acc += Math.sin(23310) + Math.cos(23311) * 30;
+acc += Math.sin(23311) + Math.cos(23312) * 31;
+acc += Math.sin(23312) + Math.cos(23313) * 32;
+acc += Math.sin(23313) + Math.cos(23314) * 33;
+acc += Math.sin(23314) + Math.cos(23315) * 34;
+acc += Math.sin(23315) + Math.cos(23316) * 35;
+acc += Math.sin(23316) + Math.cos(23317) * 36;
+acc += Math.sin(23317) + Math.cos(23318) * 37;
+acc += Math.sin(23318) + Math.cos(23319) * 38;
+acc += Math.sin(23319) + Math.cos(23320) * 39;
+acc += Math.sin(23320) + Math.cos(23321) * 40;
+acc += Math.sin(23321) + Math.cos(23322) * 41;
+acc += Math.sin(23322) + Math.cos(23323) * 42;
+acc += Math.sin(23323) + Math.cos(23324) * 43;
+acc += Math.sin(23324) + Math.cos(23325) * 44;
+acc += Math.sin(23325) + Math.cos(23326) * 45;
+acc += Math.sin(23326) + Math.cos(23327) * 46;
+acc += Math.sin(23327) + Math.cos(23328) * 47;
+acc += Math.sin(23328) + Math.cos(23329) * 48;
+acc += Math.sin(23329) + Math.cos(23330) * 49;
+acc += Math.sin(23330) + Math.cos(23331) * 50;
+acc += Math.sin(23331) + Math.cos(23332) * 51;
+acc += Math.sin(23332) + Math.cos(23333) * 52;
+acc += Math.sin(23333) + Math.cos(23334) * 53;
+acc += Math.sin(23334) + Math.cos(23335) * 54;
+acc += Math.sin(23335) + Math.cos(23336) * 55;
+acc += Math.sin(23336) + Math.cos(23337) * 56;
+acc += Math.sin(23337) + Math.cos(23338) * 57;
+acc += Math.sin(23338) + Math.cos(23339) * 58;
+acc += Math.sin(23339) + Math.cos(23340) * 59;
+acc += Math.sin(23340) + Math.cos(23341) * 60;
+acc += Math.sin(23341) + Math.cos(23342) * 61;
+acc += Math.sin(23342) + Math.cos(23343) * 62;
+acc += Math.sin(23343) + Math.cos(23344) * 63;
+acc += Math.sin(23344) + Math.cos(23345) * 64;
+acc += Math.sin(23345) + Math.cos(23346) * 65;
+acc += Math.sin(23346) + Math.cos(23347) * 66;
+acc += Math.sin(23347) + Math.cos(23348) * 67;
+acc += Math.sin(23348) + Math.cos(23349) * 68;
+acc += Math.sin(23349) + Math.cos(23350) * 69;
+acc += Math.sin(23350) + Math.cos(23351) * 70;
+acc += Math.sin(23351) + Math.cos(23352) * 71;
+acc += Math.sin(23352) + Math.cos(23353) * 72;
+acc += Math.sin(23353) + Math.cos(23354) * 73;
+acc += Math.sin(23354) + Math.cos(23355) * 74;
+acc += Math.sin(23355) + Math.cos(23356) * 75;
+acc += Math.sin(23356) + Math.cos(23357) * 76;
+acc += Math.sin(23357) + Math.cos(23358) * 77;
+acc += Math.sin(23358) + Math.cos(23359) * 78;
+acc += Math.sin(23359) + Math.cos(23360) * 79;
+acc += Math.sin(23360) + Math.cos(23361) * 80;
+acc += Math.sin(23361) + Math.cos(23362) * 81;
+acc += Math.sin(23362) + Math.cos(23363) * 82;
+acc += Math.sin(23363) + Math.cos(23364) * 83;
+acc += Math.sin(23364) + Math.cos(23365) * 84;
+acc += Math.sin(23365) + Math.cos(23366) * 85;
+acc += Math.sin(23366) + Math.cos(23367) * 86;
+acc += Math.sin(23367) + Math.cos(23368) * 87;
+acc += Math.sin(23368) + Math.cos(23369) * 88;
+acc += Math.sin(23369) + Math.cos(23370) * 89;
+acc += Math.sin(23370) + Math.cos(23371) * 90;
+acc += Math.sin(23371) + Math.cos(23372) * 91;
+acc += Math.sin(23372) + Math.cos(23373) * 92;
+acc += Math.sin(23373) + Math.cos(23374) * 93;
+acc += Math.sin(23374) + Math.cos(23375) * 94;
+acc += Math.sin(23375) + Math.cos(23376) * 95;
+acc += Math.sin(23376) + Math.cos(23377) * 96;
+acc += Math.sin(23377) + Math.cos(23378) * 0;
+acc += Math.sin(23378) + Math.cos(23379) * 1;
+acc += Math.sin(23379) + Math.cos(23380) * 2;
+acc += Math.sin(23380) + Math.cos(23381) * 3;
+acc += Math.sin(23381) + Math.cos(23382) * 4;
+acc += Math.sin(23382) + Math.cos(23383) * 5;
+acc += Math.sin(23383) + Math.cos(23384) * 6;
+acc += Math.sin(23384) + Math.cos(23385) * 7;
+acc += Math.sin(23385) + Math.cos(23386) * 8;
+acc += Math.sin(23386) + Math.cos(23387) * 9;
+acc += Math.sin(23387) + Math.cos(23388) * 10;
+acc += Math.sin(23388) + Math.cos(23389) * 11;
+acc += Math.sin(23389) + Math.cos(23390) * 12;
+acc += Math.sin(23390) + Math.cos(23391) * 13;
+acc += Math.sin(23391) + Math.cos(23392) * 14;
+acc += Math.sin(23392) + Math.cos(23393) * 15;
+acc += Math.sin(23393) + Math.cos(23394) * 16;
+acc += Math.sin(23394) + Math.cos(23395) * 17;
+acc += Math.sin(23395) + Math.cos(23396) * 18;
+acc += Math.sin(23396) + Math.cos(23397) * 19;
+acc += Math.sin(23397) + Math.cos(23398) * 20;
+acc += Math.sin(23398) + Math.cos(23399) * 21;
+acc += Math.sin(23399) + Math.cos(23400) * 22;
+acc += Math.sin(23400) + Math.cos(23401) * 23;
+acc += Math.sin(23401) + Math.cos(23402) * 24;
+acc += Math.sin(23402) + Math.cos(23403) * 25;
+acc += Math.sin(23403) + Math.cos(23404) * 26;
+acc += Math.sin(23404) + Math.cos(23405) * 27;
+acc += Math.sin(23405) + Math.cos(23406) * 28;
+acc += Math.sin(23406) + Math.cos(23407) * 29;
+acc += Math.sin(23407) + Math.cos(23408) * 30;
+acc += Math.sin(23408) + Math.cos(23409) * 31;
+acc += Math.sin(23409) + Math.cos(23410) * 32;
+acc += Math.sin(23410) + Math.cos(23411) * 33;
+acc += Math.sin(23411) + Math.cos(23412) * 34;
+acc += Math.sin(23412) + Math.cos(23413) * 35;
+acc += Math.sin(23413) + Math.cos(23414) * 36;
+acc += Math.sin(23414) + Math.cos(23415) * 37;
+acc += Math.sin(23415) + Math.cos(23416) * 38;
+acc += Math.sin(23416) + Math.cos(23417) * 39;
+acc += Math.sin(23417) + Math.cos(23418) * 40;
+acc += Math.sin(23418) + Math.cos(23419) * 41;
+acc += Math.sin(23419) + Math.cos(23420) * 42;
+acc += Math.sin(23420) + Math.cos(23421) * 43;
+acc += Math.sin(23421) + Math.cos(23422) * 44;
+acc += Math.sin(23422) + Math.cos(23423) * 45;
+acc += Math.sin(23423) + Math.cos(23424) * 46;
+acc += Math.sin(23424) + Math.cos(23425) * 47;
+acc += Math.sin(23425) + Math.cos(23426) * 48;
+acc += Math.sin(23426) + Math.cos(23427) * 49;
+acc += Math.sin(23427) + Math.cos(23428) * 50;
+acc += Math.sin(23428) + Math.cos(23429) * 51;
+acc += Math.sin(23429) + Math.cos(23430) * 52;
+acc += Math.sin(23430) + Math.cos(23431) * 53;
+acc += Math.sin(23431) + Math.cos(23432) * 54;
+acc += Math.sin(23432) + Math.cos(23433) * 55;
+acc += Math.sin(23433) + Math.cos(23434) * 56;
+acc += Math.sin(23434) + Math.cos(23435) * 57;
+acc += Math.sin(23435) + Math.cos(23436) * 58;
+acc += Math.sin(23436) + Math.cos(23437) * 59;
+acc += Math.sin(23437) + Math.cos(23438) * 60;
+acc += Math.sin(23438) + Math.cos(23439) * 61;
+acc += Math.sin(23439) + Math.cos(23440) * 62;
+acc += Math.sin(23440) + Math.cos(23441) * 63;
+acc += Math.sin(23441) + Math.cos(23442) * 64;
+acc += Math.sin(23442) + Math.cos(23443) * 65;
+acc += Math.sin(23443) + Math.cos(23444) * 66;
+acc += Math.sin(23444) + Math.cos(23445) * 67;
+acc += Math.sin(23445) + Math.cos(23446) * 68;
+acc += Math.sin(23446) + Math.cos(23447) * 69;
+acc += Math.sin(23447) + Math.cos(23448) * 70;
+acc += Math.sin(23448) + Math.cos(23449) * 71;
+acc += Math.sin(23449) + Math.cos(23450) * 72;
+acc += Math.sin(23450) + Math.cos(23451) * 73;
+acc += Math.sin(23451) + Math.cos(23452) * 74;
+acc += Math.sin(23452) + Math.cos(23453) * 75;
+acc += Math.sin(23453) + Math.cos(23454) * 76;
+acc += Math.sin(23454) + Math.cos(23455) * 77;
+acc += Math.sin(23455) + Math.cos(23456) * 78;
+acc += Math.sin(23456) + Math.cos(23457) * 79;
+acc += Math.sin(23457) + Math.cos(23458) * 80;
+acc += Math.sin(23458) + Math.cos(23459) * 81;
+acc += Math.sin(23459) + Math.cos(23460) * 82;
+acc += Math.sin(23460) + Math.cos(23461) * 83;
+acc += Math.sin(23461) + Math.cos(23462) * 84;
+acc += Math.sin(23462) + Math.cos(23463) * 85;
+acc += Math.sin(23463) + Math.cos(23464) * 86;
+acc += Math.sin(23464) + Math.cos(23465) * 87;
+acc += Math.sin(23465) + Math.cos(23466) * 88;
+acc += Math.sin(23466) + Math.cos(23467) * 89;
+acc += Math.sin(23467) + Math.cos(23468) * 90;
+acc += Math.sin(23468) + Math.cos(23469) * 91;
+acc += Math.sin(23469) + Math.cos(23470) * 92;
+acc += Math.sin(23470) + Math.cos(23471) * 93;
+acc += Math.sin(23471) + Math.cos(23472) * 94;
+acc += Math.sin(23472) + Math.cos(23473) * 95;
+acc += Math.sin(23473) + Math.cos(23474) * 96;
+acc += Math.sin(23474) + Math.cos(23475) * 0;
+acc += Math.sin(23475) + Math.cos(23476) * 1;
+acc += Math.sin(23476) + Math.cos(23477) * 2;
+acc += Math.sin(23477) + Math.cos(23478) * 3;
+acc += Math.sin(23478) + Math.cos(23479) * 4;
+acc += Math.sin(23479) + Math.cos(23480) * 5;
+acc += Math.sin(23480) + Math.cos(23481) * 6;
+acc += Math.sin(23481) + Math.cos(23482) * 7;
+acc += Math.sin(23482) + Math.cos(23483) * 8;
+acc += Math.sin(23483) + Math.cos(23484) * 9;
+acc += Math.sin(23484) + Math.cos(23485) * 10;
+acc += Math.sin(23485) + Math.cos(23486) * 11;
+acc += Math.sin(23486) + Math.cos(23487) * 12;
+acc += Math.sin(23487) + Math.cos(23488) * 13;
+acc += Math.sin(23488) + Math.cos(23489) * 14;
+acc += Math.sin(23489) + Math.cos(23490) * 15;
+acc += Math.sin(23490) + Math.cos(23491) * 16;
+acc += Math.sin(23491) + Math.cos(23492) * 17;
+acc += Math.sin(23492) + Math.cos(23493) * 18;
+acc += Math.sin(23493) + Math.cos(23494) * 19;
+acc += Math.sin(23494) + Math.cos(23495) * 20;
+acc += Math.sin(23495) + Math.cos(23496) * 21;
+acc += Math.sin(23496) + Math.cos(23497) * 22;
+acc += Math.sin(23497) + Math.cos(23498) * 23;
+acc += Math.sin(23498) + Math.cos(23499) * 24;
+acc += Math.sin(23499) + Math.cos(23500) * 25;
+acc += Math.sin(23500) + Math.cos(23501) * 26;
+acc += Math.sin(23501) + Math.cos(23502) * 27;
+acc += Math.sin(23502) + Math.cos(23503) * 28;
+acc += Math.sin(23503) + Math.cos(23504) * 29;
+acc += Math.sin(23504) + Math.cos(23505) * 30;
+acc += Math.sin(23505) + Math.cos(23506) * 31;
+acc += Math.sin(23506) + Math.cos(23507) * 32;
+acc += Math.sin(23507) + Math.cos(23508) * 33;
+acc += Math.sin(23508) + Math.cos(23509) * 34;
+acc += Math.sin(23509) + Math.cos(23510) * 35;
+acc += Math.sin(23510) + Math.cos(23511) * 36;
+acc += Math.sin(23511) + Math.cos(23512) * 37;
+acc += Math.sin(23512) + Math.cos(23513) * 38;
+acc += Math.sin(23513) + Math.cos(23514) * 39;
+acc += Math.sin(23514) + Math.cos(23515) * 40;
+acc += Math.sin(23515) + Math.cos(23516) * 41;
+acc += Math.sin(23516) + Math.cos(23517) * 42;
+acc += Math.sin(23517) + Math.cos(23518) * 43;
+acc += Math.sin(23518) + Math.cos(23519) * 44;
+acc += Math.sin(23519) + Math.cos(23520) * 45;
+acc += Math.sin(23520) + Math.cos(23521) * 46;
+acc += Math.sin(23521) + Math.cos(23522) * 47;
+acc += Math.sin(23522) + Math.cos(23523) * 48;
+acc += Math.sin(23523) + Math.cos(23524) * 49;
+acc += Math.sin(23524) + Math.cos(23525) * 50;
+acc += Math.sin(23525) + Math.cos(23526) * 51;
+acc += Math.sin(23526) + Math.cos(23527) * 52;
+acc += Math.sin(23527) + Math.cos(23528) * 53;
+acc += Math.sin(23528) + Math.cos(23529) * 54;
+acc += Math.sin(23529) + Math.cos(23530) * 55;
+acc += Math.sin(23530) + Math.cos(23531) * 56;
+acc += Math.sin(23531) + Math.cos(23532) * 57;
+acc += Math.sin(23532) + Math.cos(23533) * 58;
+acc += Math.sin(23533) + Math.cos(23534) * 59;
+acc += Math.sin(23534) + Math.cos(23535) * 60;
+acc += Math.sin(23535) + Math.cos(23536) * 61;
+acc += Math.sin(23536) + Math.cos(23537) * 62;
+acc += Math.sin(23537) + Math.cos(23538) * 63;
+acc += Math.sin(23538) + Math.cos(23539) * 64;
+acc += Math.sin(23539) + Math.cos(23540) * 65;
+acc += Math.sin(23540) + Math.cos(23541) * 66;
+acc += Math.sin(23541) + Math.cos(23542) * 67;
+acc += Math.sin(23542) + Math.cos(23543) * 68;
+acc += Math.sin(23543) + Math.cos(23544) * 69;
+acc += Math.sin(23544) + Math.cos(23545) * 70;
+acc += Math.sin(23545) + Math.cos(23546) * 71;
+acc += Math.sin(23546) + Math.cos(23547) * 72;
+acc += Math.sin(23547) + Math.cos(23548) * 73;
+acc += Math.sin(23548) + Math.cos(23549) * 74;
+acc += Math.sin(23549) + Math.cos(23550) * 75;
+acc += Math.sin(23550) + Math.cos(23551) * 76;
+acc += Math.sin(23551) + Math.cos(23552) * 77;
+acc += Math.sin(23552) + Math.cos(23553) * 78;
+acc += Math.sin(23553) + Math.cos(23554) * 79;
+acc += Math.sin(23554) + Math.cos(23555) * 80;
+acc += Math.sin(23555) + Math.cos(23556) * 81;
+acc += Math.sin(23556) + Math.cos(23557) * 82;
+acc += Math.sin(23557) + Math.cos(23558) * 83;
+acc += Math.sin(23558) + Math.cos(23559) * 84;
+acc += Math.sin(23559) + Math.cos(23560) * 85;
+acc += Math.sin(23560) + Math.cos(23561) * 86;
+acc += Math.sin(23561) + Math.cos(23562) * 87;
+acc += Math.sin(23562) + Math.cos(23563) * 88;
+acc += Math.sin(23563) + Math.cos(23564) * 89;
+acc += Math.sin(23564) + Math.cos(23565) * 90;
+acc += Math.sin(23565) + Math.cos(23566) * 91;
+acc += Math.sin(23566) + Math.cos(23567) * 92;
+acc += Math.sin(23567) + Math.cos(23568) * 93;
+acc += Math.sin(23568) + Math.cos(23569) * 94;
+acc += Math.sin(23569) + Math.cos(23570) * 95;
+acc += Math.sin(23570) + Math.cos(23571) * 96;
+acc += Math.sin(23571) + Math.cos(23572) * 0;
+acc += Math.sin(23572) + Math.cos(23573) * 1;
+acc += Math.sin(23573) + Math.cos(23574) * 2;
+acc += Math.sin(23574) + Math.cos(23575) * 3;
+acc += Math.sin(23575) + Math.cos(23576) * 4;
+acc += Math.sin(23576) + Math.cos(23577) * 5;
+acc += Math.sin(23577) + Math.cos(23578) * 6;
+acc += Math.sin(23578) + Math.cos(23579) * 7;
+acc += Math.sin(23579) + Math.cos(23580) * 8;
+acc += Math.sin(23580) + Math.cos(23581) * 9;
+acc += Math.sin(23581) + Math.cos(23582) * 10;
+acc += Math.sin(23582) + Math.cos(23583) * 11;
+acc += Math.sin(23583) + Math.cos(23584) * 12;
+acc += Math.sin(23584) + Math.cos(23585) * 13;
+acc += Math.sin(23585) + Math.cos(23586) * 14;
+acc += Math.sin(23586) + Math.cos(23587) * 15;
+acc += Math.sin(23587) + Math.cos(23588) * 16;
+acc += Math.sin(23588) + Math.cos(23589) * 17;
+acc += Math.sin(23589) + Math.cos(23590) * 18;
+acc += Math.sin(23590) + Math.cos(23591) * 19;
+acc += Math.sin(23591) + Math.cos(23592) * 20;
+acc += Math.sin(23592) + Math.cos(23593) * 21;
+acc += Math.sin(23593) + Math.cos(23594) * 22;
+acc += Math.sin(23594) + Math.cos(23595) * 23;
+acc += Math.sin(23595) + Math.cos(23596) * 24;
+acc += Math.sin(23596) + Math.cos(23597) * 25;
+acc += Math.sin(23597) + Math.cos(23598) * 26;
+acc += Math.sin(23598) + Math.cos(23599) * 27;
+acc += Math.sin(23599) + Math.cos(23600) * 28;
+acc += Math.sin(23600) + Math.cos(23601) * 29;
+acc += Math.sin(23601) + Math.cos(23602) * 30;
+acc += Math.sin(23602) + Math.cos(23603) * 31;
+acc += Math.sin(23603) + Math.cos(23604) * 32;
+acc += Math.sin(23604) + Math.cos(23605) * 33;
+acc += Math.sin(23605) + Math.cos(23606) * 34;
+acc += Math.sin(23606) + Math.cos(23607) * 35;
+acc += Math.sin(23607) + Math.cos(23608) * 36;
+acc += Math.sin(23608) + Math.cos(23609) * 37;
+acc += Math.sin(23609) + Math.cos(23610) * 38;
+acc += Math.sin(23610) + Math.cos(23611) * 39;
+acc += Math.sin(23611) + Math.cos(23612) * 40;
+acc += Math.sin(23612) + Math.cos(23613) * 41;
+acc += Math.sin(23613) + Math.cos(23614) * 42;
+acc += Math.sin(23614) + Math.cos(23615) * 43;
+acc += Math.sin(23615) + Math.cos(23616) * 44;
+acc += Math.sin(23616) + Math.cos(23617) * 45;
+acc += Math.sin(23617) + Math.cos(23618) * 46;
+acc += Math.sin(23618) + Math.cos(23619) * 47;
+acc += Math.sin(23619) + Math.cos(23620) * 48;
+acc += Math.sin(23620) + Math.cos(23621) * 49;
+acc += Math.sin(23621) + Math.cos(23622) * 50;
+acc += Math.sin(23622) + Math.cos(23623) * 51;
+acc += Math.sin(23623) + Math.cos(23624) * 52;
+acc += Math.sin(23624) + Math.cos(23625) * 53;
+acc += Math.sin(23625) + Math.cos(23626) * 54;
+acc += Math.sin(23626) + Math.cos(23627) * 55;
+acc += Math.sin(23627) + Math.cos(23628) * 56;
+acc += Math.sin(23628) + Math.cos(23629) * 57;
+acc += Math.sin(23629) + Math.cos(23630) * 58;
+acc += Math.sin(23630) + Math.cos(23631) * 59;
+acc += Math.sin(23631) + Math.cos(23632) * 60;
+acc += Math.sin(23632) + Math.cos(23633) * 61;
+acc += Math.sin(23633) + Math.cos(23634) * 62;
+acc += Math.sin(23634) + Math.cos(23635) * 63;
+acc += Math.sin(23635) + Math.cos(23636) * 64;
+acc += Math.sin(23636) + Math.cos(23637) * 65;
+acc += Math.sin(23637) + Math.cos(23638) * 66;
+acc += Math.sin(23638) + Math.cos(23639) * 67;
+acc += Math.sin(23639) + Math.cos(23640) * 68;
+acc += Math.sin(23640) + Math.cos(23641) * 69;
+acc += Math.sin(23641) + Math.cos(23642) * 70;
+acc += Math.sin(23642) + Math.cos(23643) * 71;
+acc += Math.sin(23643) + Math.cos(23644) * 72;
+acc += Math.sin(23644) + Math.cos(23645) * 73;
+acc += Math.sin(23645) + Math.cos(23646) * 74;
+acc += Math.sin(23646) + Math.cos(23647) * 75;
+acc += Math.sin(23647) + Math.cos(23648) * 76;
+acc += Math.sin(23648) + Math.cos(23649) * 77;
+acc += Math.sin(23649) + Math.cos(23650) * 78;
+acc += Math.sin(23650) + Math.cos(23651) * 79;
+acc += Math.sin(23651) + Math.cos(23652) * 80;
+acc += Math.sin(23652) + Math.cos(23653) * 81;
+acc += Math.sin(23653) + Math.cos(23654) * 82;
+acc += Math.sin(23654) + Math.cos(23655) * 83;
+acc += Math.sin(23655) + Math.cos(23656) * 84;
+acc += Math.sin(23656) + Math.cos(23657) * 85;
+acc += Math.sin(23657) + Math.cos(23658) * 86;
+acc += Math.sin(23658) + Math.cos(23659) * 87;
+acc += Math.sin(23659) + Math.cos(23660) * 88;
+acc += Math.sin(23660) + Math.cos(23661) * 89;
+acc += Math.sin(23661) + Math.cos(23662) * 90;
+acc += Math.sin(23662) + Math.cos(23663) * 91;
+acc += Math.sin(23663) + Math.cos(23664) * 92;
+acc += Math.sin(23664) + Math.cos(23665) * 93;
+acc += Math.sin(23665) + Math.cos(23666) * 94;
+acc += Math.sin(23666) + Math.cos(23667) * 95;
+acc += Math.sin(23667) + Math.cos(23668) * 96;
+acc += Math.sin(23668) + Math.cos(23669) * 0;
+acc += Math.sin(23669) + Math.cos(23670) * 1;
+acc += Math.sin(23670) + Math.cos(23671) * 2;
+acc += Math.sin(23671) + Math.cos(23672) * 3;
+acc += Math.sin(23672) + Math.cos(23673) * 4;
+acc += Math.sin(23673) + Math.cos(23674) * 5;
+acc += Math.sin(23674) + Math.cos(23675) * 6;
+acc += Math.sin(23675) + Math.cos(23676) * 7;
+acc += Math.sin(23676) + Math.cos(23677) * 8;
+acc += Math.sin(23677) + Math.cos(23678) * 9;
+acc += Math.sin(23678) + Math.cos(23679) * 10;
+acc += Math.sin(23679) + Math.cos(23680) * 11;
+acc += Math.sin(23680) + Math.cos(23681) * 12;
+acc += Math.sin(23681) + Math.cos(23682) * 13;
+acc += Math.sin(23682) + Math.cos(23683) * 14;
+acc += Math.sin(23683) + Math.cos(23684) * 15;
+acc += Math.sin(23684) + Math.cos(23685) * 16;
+acc += Math.sin(23685) + Math.cos(23686) * 17;
+acc += Math.sin(23686) + Math.cos(23687) * 18;
+acc += Math.sin(23687) + Math.cos(23688) * 19;
+acc += Math.sin(23688) + Math.cos(23689) * 20;
+acc += Math.sin(23689) + Math.cos(23690) * 21;
+acc += Math.sin(23690) + Math.cos(23691) * 22;
+acc += Math.sin(23691) + Math.cos(23692) * 23;
+acc += Math.sin(23692) + Math.cos(23693) * 24;
+acc += Math.sin(23693) + Math.cos(23694) * 25;
+acc += Math.sin(23694) + Math.cos(23695) * 26;
+acc += Math.sin(23695) + Math.cos(23696) * 27;
+acc += Math.sin(23696) + Math.cos(23697) * 28;
+acc += Math.sin(23697) + Math.cos(23698) * 29;
+acc += Math.sin(23698) + Math.cos(23699) * 30;
+acc += Math.sin(23699) + Math.cos(23700) * 31;
+acc += Math.sin(23700) + Math.cos(23701) * 32;
+acc += Math.sin(23701) + Math.cos(23702) * 33;
+acc += Math.sin(23702) + Math.cos(23703) * 34;
+acc += Math.sin(23703) + Math.cos(23704) * 35;
+acc += Math.sin(23704) + Math.cos(23705) * 36;
+acc += Math.sin(23705) + Math.cos(23706) * 37;
+acc += Math.sin(23706) + Math.cos(23707) * 38;
+acc += Math.sin(23707) + Math.cos(23708) * 39;
+acc += Math.sin(23708) + Math.cos(23709) * 40;
+acc += Math.sin(23709) + Math.cos(23710) * 41;
+acc += Math.sin(23710) + Math.cos(23711) * 42;
+acc += Math.sin(23711) + Math.cos(23712) * 43;
+acc += Math.sin(23712) + Math.cos(23713) * 44;
+acc += Math.sin(23713) + Math.cos(23714) * 45;
+acc += Math.sin(23714) + Math.cos(23715) * 46;
+acc += Math.sin(23715) + Math.cos(23716) * 47;
+acc += Math.sin(23716) + Math.cos(23717) * 48;
+acc += Math.sin(23717) + Math.cos(23718) * 49;
+acc += Math.sin(23718) + Math.cos(23719) * 50;
+acc += Math.sin(23719) + Math.cos(23720) * 51;
+acc += Math.sin(23720) + Math.cos(23721) * 52;
+acc += Math.sin(23721) + Math.cos(23722) * 53;
+acc += Math.sin(23722) + Math.cos(23723) * 54;
+acc += Math.sin(23723) + Math.cos(23724) * 55;
+acc += Math.sin(23724) + Math.cos(23725) * 56;
+acc += Math.sin(23725) + Math.cos(23726) * 57;
+acc += Math.sin(23726) + Math.cos(23727) * 58;
+acc += Math.sin(23727) + Math.cos(23728) * 59;
+acc += Math.sin(23728) + Math.cos(23729) * 60;
+acc += Math.sin(23729) + Math.cos(23730) * 61;
+acc += Math.sin(23730) + Math.cos(23731) * 62;
+acc += Math.sin(23731) + Math.cos(23732) * 63;
+acc += Math.sin(23732) + Math.cos(23733) * 64;
+acc += Math.sin(23733) + Math.cos(23734) * 65;
+acc += Math.sin(23734) + Math.cos(23735) * 66;
+acc += Math.sin(23735) + Math.cos(23736) * 67;
+acc += Math.sin(23736) + Math.cos(23737) * 68;
+acc += Math.sin(23737) + Math.cos(23738) * 69;
+acc += Math.sin(23738) + Math.cos(23739) * 70;
+acc += Math.sin(23739) + Math.cos(23740) * 71;
+acc += Math.sin(23740) + Math.cos(23741) * 72;
+acc += Math.sin(23741) + Math.cos(23742) * 73;
+acc += Math.sin(23742) + Math.cos(23743) * 74;
+acc += Math.sin(23743) + Math.cos(23744) * 75;
+acc += Math.sin(23744) + Math.cos(23745) * 76;
+acc += Math.sin(23745) + Math.cos(23746) * 77;
+acc += Math.sin(23746) + Math.cos(23747) * 78;
+acc += Math.sin(23747) + Math.cos(23748) * 79;
+acc += Math.sin(23748) + Math.cos(23749) * 80;
+acc += Math.sin(23749) + Math.cos(23750) * 81;
+acc += Math.sin(23750) + Math.cos(23751) * 82;
+acc += Math.sin(23751) + Math.cos(23752) * 83;
+acc += Math.sin(23752) + Math.cos(23753) * 84;
+acc += Math.sin(23753) + Math.cos(23754) * 85;
+acc += Math.sin(23754) + Math.cos(23755) * 86;
+acc += Math.sin(23755) + Math.cos(23756) * 87;
+acc += Math.sin(23756) + Math.cos(23757) * 88;
+acc += Math.sin(23757) + Math.cos(23758) * 89;
+acc += Math.sin(23758) + Math.cos(23759) * 90;
+acc += Math.sin(23759) + Math.cos(23760) * 91;
+acc += Math.sin(23760) + Math.cos(23761) * 92;
+acc += Math.sin(23761) + Math.cos(23762) * 93;
+acc += Math.sin(23762) + Math.cos(23763) * 94;
+acc += Math.sin(23763) + Math.cos(23764) * 95;
+acc += Math.sin(23764) + Math.cos(23765) * 96;
+acc += Math.sin(23765) + Math.cos(23766) * 0;
+acc += Math.sin(23766) + Math.cos(23767) * 1;
+acc += Math.sin(23767) + Math.cos(23768) * 2;
+acc += Math.sin(23768) + Math.cos(23769) * 3;
+acc += Math.sin(23769) + Math.cos(23770) * 4;
+acc += Math.sin(23770) + Math.cos(23771) * 5;
+acc += Math.sin(23771) + Math.cos(23772) * 6;
+acc += Math.sin(23772) + Math.cos(23773) * 7;
+acc += Math.sin(23773) + Math.cos(23774) * 8;
+acc += Math.sin(23774) + Math.cos(23775) * 9;
+acc += Math.sin(23775) + Math.cos(23776) * 10;
+acc += Math.sin(23776) + Math.cos(23777) * 11;
+acc += Math.sin(23777) + Math.cos(23778) * 12;
+acc += Math.sin(23778) + Math.cos(23779) * 13;
+acc += Math.sin(23779) + Math.cos(23780) * 14;
+acc += Math.sin(23780) + Math.cos(23781) * 15;
+acc += Math.sin(23781) + Math.cos(23782) * 16;
+acc += Math.sin(23782) + Math.cos(23783) * 17;
+acc += Math.sin(23783) + Math.cos(23784) * 18;
+acc += Math.sin(23784) + Math.cos(23785) * 19;
+acc += Math.sin(23785) + Math.cos(23786) * 20;
+acc += Math.sin(23786) + Math.cos(23787) * 21;
+acc += Math.sin(23787) + Math.cos(23788) * 22;
+acc += Math.sin(23788) + Math.cos(23789) * 23;
+acc += Math.sin(23789) + Math.cos(23790) * 24;
+acc += Math.sin(23790) + Math.cos(23791) * 25;
+acc += Math.sin(23791) + Math.cos(23792) * 26;
+acc += Math.sin(23792) + Math.cos(23793) * 27;
+acc += Math.sin(23793) + Math.cos(23794) * 28;
+acc += Math.sin(23794) + Math.cos(23795) * 29;
+acc += Math.sin(23795) + Math.cos(23796) * 30;
+acc += Math.sin(23796) + Math.cos(23797) * 31;
+acc += Math.sin(23797) + Math.cos(23798) * 32;
+acc += Math.sin(23798) + Math.cos(23799) * 33;
+acc += Math.sin(23799) + Math.cos(23800) * 34;
+acc += Math.sin(23800) + Math.cos(23801) * 35;
+acc += Math.sin(23801) + Math.cos(23802) * 36;
+acc += Math.sin(23802) + Math.cos(23803) * 37;
+acc += Math.sin(23803) + Math.cos(23804) * 38;
+acc += Math.sin(23804) + Math.cos(23805) * 39;
+acc += Math.sin(23805) + Math.cos(23806) * 40;
+acc += Math.sin(23806) + Math.cos(23807) * 41;
+acc += Math.sin(23807) + Math.cos(23808) * 42;
+acc += Math.sin(23808) + Math.cos(23809) * 43;
+acc += Math.sin(23809) + Math.cos(23810) * 44;
+acc += Math.sin(23810) + Math.cos(23811) * 45;
+acc += Math.sin(23811) + Math.cos(23812) * 46;
+acc += Math.sin(23812) + Math.cos(23813) * 47;
+acc += Math.sin(23813) + Math.cos(23814) * 48;
+acc += Math.sin(23814) + Math.cos(23815) * 49;
+acc += Math.sin(23815) + Math.cos(23816) * 50;
+acc += Math.sin(23816) + Math.cos(23817) * 51;
+acc += Math.sin(23817) + Math.cos(23818) * 52;
+acc += Math.sin(23818) + Math.cos(23819) * 53;
+acc += Math.sin(23819) + Math.cos(23820) * 54;
+acc += Math.sin(23820) + Math.cos(23821) * 55;
+acc += Math.sin(23821) + Math.cos(23822) * 56;
+acc += Math.sin(23822) + Math.cos(23823) * 57;
+acc += Math.sin(23823) + Math.cos(23824) * 58;
+acc += Math.sin(23824) + Math.cos(23825) * 59;
+acc += Math.sin(23825) + Math.cos(23826) * 60;
+acc += Math.sin(23826) + Math.cos(23827) * 61;
+acc += Math.sin(23827) + Math.cos(23828) * 62;
+acc += Math.sin(23828) + Math.cos(23829) * 63;
+acc += Math.sin(23829) + Math.cos(23830) * 64;
+acc += Math.sin(23830) + Math.cos(23831) * 65;
+acc += Math.sin(23831) + Math.cos(23832) * 66;
+acc += Math.sin(23832) + Math.cos(23833) * 67;
+acc += Math.sin(23833) + Math.cos(23834) * 68;
+acc += Math.sin(23834) + Math.cos(23835) * 69;
+acc += Math.sin(23835) + Math.cos(23836) * 70;
+acc += Math.sin(23836) + Math.cos(23837) * 71;
+acc += Math.sin(23837) + Math.cos(23838) * 72;
+acc += Math.sin(23838) + Math.cos(23839) * 73;
+acc += Math.sin(23839) + Math.cos(23840) * 74;
+acc += Math.sin(23840) + Math.cos(23841) * 75;
+acc += Math.sin(23841) + Math.cos(23842) * 76;
+acc += Math.sin(23842) + Math.cos(23843) * 77;
+acc += Math.sin(23843) + Math.cos(23844) * 78;
+acc += Math.sin(23844) + Math.cos(23845) * 79;
+acc += Math.sin(23845) + Math.cos(23846) * 80;
+acc += Math.sin(23846) + Math.cos(23847) * 81;
+acc += Math.sin(23847) + Math.cos(23848) * 82;
+acc += Math.sin(23848) + Math.cos(23849) * 83;
+acc += Math.sin(23849) + Math.cos(23850) * 84;
+acc += Math.sin(23850) + Math.cos(23851) * 85;
+acc += Math.sin(23851) + Math.cos(23852) * 86;
+acc += Math.sin(23852) + Math.cos(23853) * 87;
+acc += Math.sin(23853) + Math.cos(23854) * 88;
+acc += Math.sin(23854) + Math.cos(23855) * 89;
+acc += Math.sin(23855) + Math.cos(23856) * 90;
+acc += Math.sin(23856) + Math.cos(23857) * 91;
+acc += Math.sin(23857) + Math.cos(23858) * 92;
+acc += Math.sin(23858) + Math.cos(23859) * 93;
+acc += Math.sin(23859) + Math.cos(23860) * 94;
+acc += Math.sin(23860) + Math.cos(23861) * 95;
+acc += Math.sin(23861) + Math.cos(23862) * 96;
+acc += Math.sin(23862) + Math.cos(23863) * 0;
+acc += Math.sin(23863) + Math.cos(23864) * 1;
+acc += Math.sin(23864) + Math.cos(23865) * 2;
+acc += Math.sin(23865) + Math.cos(23866) * 3;
+acc += Math.sin(23866) + Math.cos(23867) * 4;
+acc += Math.sin(23867) + Math.cos(23868) * 5;
+acc += Math.sin(23868) + Math.cos(23869) * 6;
+acc += Math.sin(23869) + Math.cos(23870) * 7;
+acc += Math.sin(23870) + Math.cos(23871) * 8;
+acc += Math.sin(23871) + Math.cos(23872) * 9;
+acc += Math.sin(23872) + Math.cos(23873) * 10;
+acc += Math.sin(23873) + Math.cos(23874) * 11;
+acc += Math.sin(23874) + Math.cos(23875) * 12;
+acc += Math.sin(23875) + Math.cos(23876) * 13;
+acc += Math.sin(23876) + Math.cos(23877) * 14;
+acc += Math.sin(23877) + Math.cos(23878) * 15;
+acc += Math.sin(23878) + Math.cos(23879) * 16;
+acc += Math.sin(23879) + Math.cos(23880) * 17;
+acc += Math.sin(23880) + Math.cos(23881) * 18;
+acc += Math.sin(23881) + Math.cos(23882) * 19;
+acc += Math.sin(23882) + Math.cos(23883) * 20;
+acc += Math.sin(23883) + Math.cos(23884) * 21;
+acc += Math.sin(23884) + Math.cos(23885) * 22;
+acc += Math.sin(23885) + Math.cos(23886) * 23;
+acc += Math.sin(23886) + Math.cos(23887) * 24;
+acc += Math.sin(23887) + Math.cos(23888) * 25;
+acc += Math.sin(23888) + Math.cos(23889) * 26;
+acc += Math.sin(23889) + Math.cos(23890) * 27;
+acc += Math.sin(23890) + Math.cos(23891) * 28;
+acc += Math.sin(23891) + Math.cos(23892) * 29;
+acc += Math.sin(23892) + Math.cos(23893) * 30;
+acc += Math.sin(23893) + Math.cos(23894) * 31;
+acc += Math.sin(23894) + Math.cos(23895) * 32;
+acc += Math.sin(23895) + Math.cos(23896) * 33;
+acc += Math.sin(23896) + Math.cos(23897) * 34;
+acc += Math.sin(23897) + Math.cos(23898) * 35;
+acc += Math.sin(23898) + Math.cos(23899) * 36;
+acc += Math.sin(23899) + Math.cos(23900) * 37;
+acc += Math.sin(23900) + Math.cos(23901) * 38;
+acc += Math.sin(23901) + Math.cos(23902) * 39;
+acc += Math.sin(23902) + Math.cos(23903) * 40;
+acc += Math.sin(23903) + Math.cos(23904) * 41;
+acc += Math.sin(23904) + Math.cos(23905) * 42;
+acc += Math.sin(23905) + Math.cos(23906) * 43;
+acc += Math.sin(23906) + Math.cos(23907) * 44;
+acc += Math.sin(23907) + Math.cos(23908) * 45;
+acc += Math.sin(23908) + Math.cos(23909) * 46;
+acc += Math.sin(23909) + Math.cos(23910) * 47;
+acc += Math.sin(23910) + Math.cos(23911) * 48;
+acc += Math.sin(23911) + Math.cos(23912) * 49;
+acc += Math.sin(23912) + Math.cos(23913) * 50;
+acc += Math.sin(23913) + Math.cos(23914) * 51;
+acc += Math.sin(23914) + Math.cos(23915) * 52;
+acc += Math.sin(23915) + Math.cos(23916) * 53;
+acc += Math.sin(23916) + Math.cos(23917) * 54;
+acc += Math.sin(23917) + Math.cos(23918) * 55;
+acc += Math.sin(23918) + Math.cos(23919) * 56;
+acc += Math.sin(23919) + Math.cos(23920) * 57;
+acc += Math.sin(23920) + Math.cos(23921) * 58;
+acc += Math.sin(23921) + Math.cos(23922) * 59;
+acc += Math.sin(23922) + Math.cos(23923) * 60;
+acc += Math.sin(23923) + Math.cos(23924) * 61;
+acc += Math.sin(23924) + Math.cos(23925) * 62;
+acc += Math.sin(23925) + Math.cos(23926) * 63;
+acc += Math.sin(23926) + Math.cos(23927) * 64;
+acc += Math.sin(23927) + Math.cos(23928) * 65;
+acc += Math.sin(23928) + Math.cos(23929) * 66;
+acc += Math.sin(23929) + Math.cos(23930) * 67;
+acc += Math.sin(23930) + Math.cos(23931) * 68;
+acc += Math.sin(23931) + Math.cos(23932) * 69;
+acc += Math.sin(23932) + Math.cos(23933) * 70;
+acc += Math.sin(23933) + Math.cos(23934) * 71;
+acc += Math.sin(23934) + Math.cos(23935) * 72;
+acc += Math.sin(23935) + Math.cos(23936) * 73;
+acc += Math.sin(23936) + Math.cos(23937) * 74;
+acc += Math.sin(23937) + Math.cos(23938) * 75;
+acc += Math.sin(23938) + Math.cos(23939) * 76;
+acc += Math.sin(23939) + Math.cos(23940) * 77;
+acc += Math.sin(23940) + Math.cos(23941) * 78;
+acc += Math.sin(23941) + Math.cos(23942) * 79;
+acc += Math.sin(23942) + Math.cos(23943) * 80;
+acc += Math.sin(23943) + Math.cos(23944) * 81;
+acc += Math.sin(23944) + Math.cos(23945) * 82;
+acc += Math.sin(23945) + Math.cos(23946) * 83;
+acc += Math.sin(23946) + Math.cos(23947) * 84;
+acc += Math.sin(23947) + Math.cos(23948) * 85;
+acc += Math.sin(23948) + Math.cos(23949) * 86;
+acc += Math.sin(23949) + Math.cos(23950) * 87;
+acc += Math.sin(23950) + Math.cos(23951) * 88;
+acc += Math.sin(23951) + Math.cos(23952) * 89;
+acc += Math.sin(23952) + Math.cos(23953) * 90;
+acc += Math.sin(23953) + Math.cos(23954) * 91;
+acc += Math.sin(23954) + Math.cos(23955) * 92;
+acc += Math.sin(23955) + Math.cos(23956) * 93;
+acc += Math.sin(23956) + Math.cos(23957) * 94;
+acc += Math.sin(23957) + Math.cos(23958) * 95;
+acc += Math.sin(23958) + Math.cos(23959) * 96;
+acc += Math.sin(23959) + Math.cos(23960) * 0;
+acc += Math.sin(23960) + Math.cos(23961) * 1;
+acc += Math.sin(23961) + Math.cos(23962) * 2;
+acc += Math.sin(23962) + Math.cos(23963) * 3;
+acc += Math.sin(23963) + Math.cos(23964) * 4;
+acc += Math.sin(23964) + Math.cos(23965) * 5;
+acc += Math.sin(23965) + Math.cos(23966) * 6;
+acc += Math.sin(23966) + Math.cos(23967) * 7;
+acc += Math.sin(23967) + Math.cos(23968) * 8;
+acc += Math.sin(23968) + Math.cos(23969) * 9;
+acc += Math.sin(23969) + Math.cos(23970) * 10;
+acc += Math.sin(23970) + Math.cos(23971) * 11;
+acc += Math.sin(23971) + Math.cos(23972) * 12;
+acc += Math.sin(23972) + Math.cos(23973) * 13;
+acc += Math.sin(23973) + Math.cos(23974) * 14;
+acc += Math.sin(23974) + Math.cos(23975) * 15;
+acc += Math.sin(23975) + Math.cos(23976) * 16;
+acc += Math.sin(23976) + Math.cos(23977) * 17;
+acc += Math.sin(23977) + Math.cos(23978) * 18;
+acc += Math.sin(23978) + Math.cos(23979) * 19;
+acc += Math.sin(23979) + Math.cos(23980) * 20;
+acc += Math.sin(23980) + Math.cos(23981) * 21;
+acc += Math.sin(23981) + Math.cos(23982) * 22;
+acc += Math.sin(23982) + Math.cos(23983) * 23;
+acc += Math.sin(23983) + Math.cos(23984) * 24;
+acc += Math.sin(23984) + Math.cos(23985) * 25;
+acc += Math.sin(23985) + Math.cos(23986) * 26;
+acc += Math.sin(23986) + Math.cos(23987) * 27;
+acc += Math.sin(23987) + Math.cos(23988) * 28;
+acc += Math.sin(23988) + Math.cos(23989) * 29;
+acc += Math.sin(23989) + Math.cos(23990) * 30;
+acc += Math.sin(23990) + Math.cos(23991) * 31;
+acc += Math.sin(23991) + Math.cos(23992) * 32;
+acc += Math.sin(23992) + Math.cos(23993) * 33;
+acc += Math.sin(23993) + Math.cos(23994) * 34;
+acc += Math.sin(23994) + Math.cos(23995) * 35;
+acc += Math.sin(23995) + Math.cos(23996) * 36;
+acc += Math.sin(23996) + Math.cos(23997) * 37;
+acc += Math.sin(23997) + Math.cos(23998) * 38;
+acc += Math.sin(23998) + Math.cos(23999) * 39;
+acc += Math.sin(23999) + Math.cos(24000) * 40;
+acc += Math.sin(24000) + Math.cos(24001) * 41;
+acc += Math.sin(24001) + Math.cos(24002) * 42;
+acc += Math.sin(24002) + Math.cos(24003) * 43;
+acc += Math.sin(24003) + Math.cos(24004) * 44;
+acc += Math.sin(24004) + Math.cos(24005) * 45;
+acc += Math.sin(24005) + Math.cos(24006) * 46;
+acc += Math.sin(24006) + Math.cos(24007) * 47;
+acc += Math.sin(24007) + Math.cos(24008) * 48;
+acc += Math.sin(24008) + Math.cos(24009) * 49;
+acc += Math.sin(24009) + Math.cos(24010) * 50;
+acc += Math.sin(24010) + Math.cos(24011) * 51;
+acc += Math.sin(24011) + Math.cos(24012) * 52;
+acc += Math.sin(24012) + Math.cos(24013) * 53;
+acc += Math.sin(24013) + Math.cos(24014) * 54;
+acc += Math.sin(24014) + Math.cos(24015) * 55;
+acc += Math.sin(24015) + Math.cos(24016) * 56;
+acc += Math.sin(24016) + Math.cos(24017) * 57;
+acc += Math.sin(24017) + Math.cos(24018) * 58;
+acc += Math.sin(24018) + Math.cos(24019) * 59;
+acc += Math.sin(24019) + Math.cos(24020) * 60;
+acc += Math.sin(24020) + Math.cos(24021) * 61;
+acc += Math.sin(24021) + Math.cos(24022) * 62;
+acc += Math.sin(24022) + Math.cos(24023) * 63;
+acc += Math.sin(24023) + Math.cos(24024) * 64;
+acc += Math.sin(24024) + Math.cos(24025) * 65;
+acc += Math.sin(24025) + Math.cos(24026) * 66;
+acc += Math.sin(24026) + Math.cos(24027) * 67;
+acc += Math.sin(24027) + Math.cos(24028) * 68;
+acc += Math.sin(24028) + Math.cos(24029) * 69;
+acc += Math.sin(24029) + Math.cos(24030) * 70;
+acc += Math.sin(24030) + Math.cos(24031) * 71;
+acc += Math.sin(24031) + Math.cos(24032) * 72;
+acc += Math.sin(24032) + Math.cos(24033) * 73;
+acc += Math.sin(24033) + Math.cos(24034) * 74;
+acc += Math.sin(24034) + Math.cos(24035) * 75;
+acc += Math.sin(24035) + Math.cos(24036) * 76;
+acc += Math.sin(24036) + Math.cos(24037) * 77;
+acc += Math.sin(24037) + Math.cos(24038) * 78;
+acc += Math.sin(24038) + Math.cos(24039) * 79;
+acc += Math.sin(24039) + Math.cos(24040) * 80;
+acc += Math.sin(24040) + Math.cos(24041) * 81;
+acc += Math.sin(24041) + Math.cos(24042) * 82;
+acc += Math.sin(24042) + Math.cos(24043) * 83;
+acc += Math.sin(24043) + Math.cos(24044) * 84;
+acc += Math.sin(24044) + Math.cos(24045) * 85;
+acc += Math.sin(24045) + Math.cos(24046) * 86;
+acc += Math.sin(24046) + Math.cos(24047) * 87;
+acc += Math.sin(24047) + Math.cos(24048) * 88;
+acc += Math.sin(24048) + Math.cos(24049) * 89;
+acc += Math.sin(24049) + Math.cos(24050) * 90;
+acc += Math.sin(24050) + Math.cos(24051) * 91;
+acc += Math.sin(24051) + Math.cos(24052) * 92;
+acc += Math.sin(24052) + Math.cos(24053) * 93;
+acc += Math.sin(24053) + Math.cos(24054) * 94;
+acc += Math.sin(24054) + Math.cos(24055) * 95;
+acc += Math.sin(24055) + Math.cos(24056) * 96;
+acc += Math.sin(24056) + Math.cos(24057) * 0;
+acc += Math.sin(24057) + Math.cos(24058) * 1;
+acc += Math.sin(24058) + Math.cos(24059) * 2;
+acc += Math.sin(24059) + Math.cos(24060) * 3;
+acc += Math.sin(24060) + Math.cos(24061) * 4;
+acc += Math.sin(24061) + Math.cos(24062) * 5;
+acc += Math.sin(24062) + Math.cos(24063) * 6;
+acc += Math.sin(24063) + Math.cos(24064) * 7;
+acc += Math.sin(24064) + Math.cos(24065) * 8;
+acc += Math.sin(24065) + Math.cos(24066) * 9;
+acc += Math.sin(24066) + Math.cos(24067) * 10;
+acc += Math.sin(24067) + Math.cos(24068) * 11;
+acc += Math.sin(24068) + Math.cos(24069) * 12;
+acc += Math.sin(24069) + Math.cos(24070) * 13;
+acc += Math.sin(24070) + Math.cos(24071) * 14;
+acc += Math.sin(24071) + Math.cos(24072) * 15;
+acc += Math.sin(24072) + Math.cos(24073) * 16;
+acc += Math.sin(24073) + Math.cos(24074) * 17;
+acc += Math.sin(24074) + Math.cos(24075) * 18;
+acc += Math.sin(24075) + Math.cos(24076) * 19;
+acc += Math.sin(24076) + Math.cos(24077) * 20;
+acc += Math.sin(24077) + Math.cos(24078) * 21;
+acc += Math.sin(24078) + Math.cos(24079) * 22;
+acc += Math.sin(24079) + Math.cos(24080) * 23;
+acc += Math.sin(24080) + Math.cos(24081) * 24;
+acc += Math.sin(24081) + Math.cos(24082) * 25;
+acc += Math.sin(24082) + Math.cos(24083) * 26;
+acc += Math.sin(24083) + Math.cos(24084) * 27;
+acc += Math.sin(24084) + Math.cos(24085) * 28;
+acc += Math.sin(24085) + Math.cos(24086) * 29;
+acc += Math.sin(24086) + Math.cos(24087) * 30;
+acc += Math.sin(24087) + Math.cos(24088) * 31;
+acc += Math.sin(24088) + Math.cos(24089) * 32;
+acc += Math.sin(24089) + Math.cos(24090) * 33;
+acc += Math.sin(24090) + Math.cos(24091) * 34;
+acc += Math.sin(24091) + Math.cos(24092) * 35;
+acc += Math.sin(24092) + Math.cos(24093) * 36;
+acc += Math.sin(24093) + Math.cos(24094) * 37;
+acc += Math.sin(24094) + Math.cos(24095) * 38;
+acc += Math.sin(24095) + Math.cos(24096) * 39;
+acc += Math.sin(24096) + Math.cos(24097) * 40;
+acc += Math.sin(24097) + Math.cos(24098) * 41;
+acc += Math.sin(24098) + Math.cos(24099) * 42;
+acc += Math.sin(24099) + Math.cos(24100) * 43;
+acc += Math.sin(24100) + Math.cos(24101) * 44;
+acc += Math.sin(24101) + Math.cos(24102) * 45;
+acc += Math.sin(24102) + Math.cos(24103) * 46;
+acc += Math.sin(24103) + Math.cos(24104) * 47;
+acc += Math.sin(24104) + Math.cos(24105) * 48;
+acc += Math.sin(24105) + Math.cos(24106) * 49;
+acc += Math.sin(24106) + Math.cos(24107) * 50;
+acc += Math.sin(24107) + Math.cos(24108) * 51;
+acc += Math.sin(24108) + Math.cos(24109) * 52;
+acc += Math.sin(24109) + Math.cos(24110) * 53;
+acc += Math.sin(24110) + Math.cos(24111) * 54;
+acc += Math.sin(24111) + Math.cos(24112) * 55;
+acc += Math.sin(24112) + Math.cos(24113) * 56;
+acc += Math.sin(24113) + Math.cos(24114) * 57;
+acc += Math.sin(24114) + Math.cos(24115) * 58;
+acc += Math.sin(24115) + Math.cos(24116) * 59;
+acc += Math.sin(24116) + Math.cos(24117) * 60;
+acc += Math.sin(24117) + Math.cos(24118) * 61;
+acc += Math.sin(24118) + Math.cos(24119) * 62;
+acc += Math.sin(24119) + Math.cos(24120) * 63;
+acc += Math.sin(24120) + Math.cos(24121) * 64;
+acc += Math.sin(24121) + Math.cos(24122) * 65;
+acc += Math.sin(24122) + Math.cos(24123) * 66;
+acc += Math.sin(24123) + Math.cos(24124) * 67;
+acc += Math.sin(24124) + Math.cos(24125) * 68;
+acc += Math.sin(24125) + Math.cos(24126) * 69;
+acc += Math.sin(24126) + Math.cos(24127) * 70;
+acc += Math.sin(24127) + Math.cos(24128) * 71;
+acc += Math.sin(24128) + Math.cos(24129) * 72;
+acc += Math.sin(24129) + Math.cos(24130) * 73;
+acc += Math.sin(24130) + Math.cos(24131) * 74;
+acc += Math.sin(24131) + Math.cos(24132) * 75;
+acc += Math.sin(24132) + Math.cos(24133) * 76;
+acc += Math.sin(24133) + Math.cos(24134) * 77;
+acc += Math.sin(24134) + Math.cos(24135) * 78;
+acc += Math.sin(24135) + Math.cos(24136) * 79;
+acc += Math.sin(24136) + Math.cos(24137) * 80;
+acc += Math.sin(24137) + Math.cos(24138) * 81;
+acc += Math.sin(24138) + Math.cos(24139) * 82;
+acc += Math.sin(24139) + Math.cos(24140) * 83;
+acc += Math.sin(24140) + Math.cos(24141) * 84;
+acc += Math.sin(24141) + Math.cos(24142) * 85;
+acc += Math.sin(24142) + Math.cos(24143) * 86;
+acc += Math.sin(24143) + Math.cos(24144) * 87;
+acc += Math.sin(24144) + Math.cos(24145) * 88;
+acc += Math.sin(24145) + Math.cos(24146) * 89;
+acc += Math.sin(24146) + Math.cos(24147) * 90;
+acc += Math.sin(24147) + Math.cos(24148) * 91;
+acc += Math.sin(24148) + Math.cos(24149) * 92;
+acc += Math.sin(24149) + Math.cos(24150) * 93;
+acc += Math.sin(24150) + Math.cos(24151) * 94;
+acc += Math.sin(24151) + Math.cos(24152) * 95;
+acc += Math.sin(24152) + Math.cos(24153) * 96;
+acc += Math.sin(24153) + Math.cos(24154) * 0;
+acc += Math.sin(24154) + Math.cos(24155) * 1;
+acc += Math.sin(24155) + Math.cos(24156) * 2;
+acc += Math.sin(24156) + Math.cos(24157) * 3;
+acc += Math.sin(24157) + Math.cos(24158) * 4;
+acc += Math.sin(24158) + Math.cos(24159) * 5;
+acc += Math.sin(24159) + Math.cos(24160) * 6;
+acc += Math.sin(24160) + Math.cos(24161) * 7;
+acc += Math.sin(24161) + Math.cos(24162) * 8;
+acc += Math.sin(24162) + Math.cos(24163) * 9;
+acc += Math.sin(24163) + Math.cos(24164) * 10;
+acc += Math.sin(24164) + Math.cos(24165) * 11;
+acc += Math.sin(24165) + Math.cos(24166) * 12;
+acc += Math.sin(24166) + Math.cos(24167) * 13;
+acc += Math.sin(24167) + Math.cos(24168) * 14;
+acc += Math.sin(24168) + Math.cos(24169) * 15;
+acc += Math.sin(24169) + Math.cos(24170) * 16;
+acc += Math.sin(24170) + Math.cos(24171) * 17;
+acc += Math.sin(24171) + Math.cos(24172) * 18;
+acc += Math.sin(24172) + Math.cos(24173) * 19;
+acc += Math.sin(24173) + Math.cos(24174) * 20;
+acc += Math.sin(24174) + Math.cos(24175) * 21;
+acc += Math.sin(24175) + Math.cos(24176) * 22;
+acc += Math.sin(24176) + Math.cos(24177) * 23;
+acc += Math.sin(24177) + Math.cos(24178) * 24;
+acc += Math.sin(24178) + Math.cos(24179) * 25;
+acc += Math.sin(24179) + Math.cos(24180) * 26;
+acc += Math.sin(24180) + Math.cos(24181) * 27;
+acc += Math.sin(24181) + Math.cos(24182) * 28;
+acc += Math.sin(24182) + Math.cos(24183) * 29;
+acc += Math.sin(24183) + Math.cos(24184) * 30;
+acc += Math.sin(24184) + Math.cos(24185) * 31;
+acc += Math.sin(24185) + Math.cos(24186) * 32;
+acc += Math.sin(24186) + Math.cos(24187) * 33;
+acc += Math.sin(24187) + Math.cos(24188) * 34;
+acc += Math.sin(24188) + Math.cos(24189) * 35;
+acc += Math.sin(24189) + Math.cos(24190) * 36;
+acc += Math.sin(24190) + Math.cos(24191) * 37;
+acc += Math.sin(24191) + Math.cos(24192) * 38;
+acc += Math.sin(24192) + Math.cos(24193) * 39;
+acc += Math.sin(24193) + Math.cos(24194) * 40;
+acc += Math.sin(24194) + Math.cos(24195) * 41;
+acc += Math.sin(24195) + Math.cos(24196) * 42;
+acc += Math.sin(24196) + Math.cos(24197) * 43;
+acc += Math.sin(24197) + Math.cos(24198) * 44;
+acc += Math.sin(24198) + Math.cos(24199) * 45;
+acc += Math.sin(24199) + Math.cos(24200) * 46;
+acc += Math.sin(24200) + Math.cos(24201) * 47;
+acc += Math.sin(24201) + Math.cos(24202) * 48;
+acc += Math.sin(24202) + Math.cos(24203) * 49;
+acc += Math.sin(24203) + Math.cos(24204) * 50;
+acc += Math.sin(24204) + Math.cos(24205) * 51;
+acc += Math.sin(24205) + Math.cos(24206) * 52;
+acc += Math.sin(24206) + Math.cos(24207) * 53;
+acc += Math.sin(24207) + Math.cos(24208) * 54;
+acc += Math.sin(24208) + Math.cos(24209) * 55;
+acc += Math.sin(24209) + Math.cos(24210) * 56;
+acc += Math.sin(24210) + Math.cos(24211) * 57;
+acc += Math.sin(24211) + Math.cos(24212) * 58;
+acc += Math.sin(24212) + Math.cos(24213) * 59;
+acc += Math.sin(24213) + Math.cos(24214) * 60;
+acc += Math.sin(24214) + Math.cos(24215) * 61;
+acc += Math.sin(24215) + Math.cos(24216) * 62;
+acc += Math.sin(24216) + Math.cos(24217) * 63;
+acc += Math.sin(24217) + Math.cos(24218) * 64;
+acc += Math.sin(24218) + Math.cos(24219) * 65;
+acc += Math.sin(24219) + Math.cos(24220) * 66;
+acc += Math.sin(24220) + Math.cos(24221) * 67;
+acc += Math.sin(24221) + Math.cos(24222) * 68;
+acc += Math.sin(24222) + Math.cos(24223) * 69;
+acc += Math.sin(24223) + Math.cos(24224) * 70;
+acc += Math.sin(24224) + Math.cos(24225) * 71;
+acc += Math.sin(24225) + Math.cos(24226) * 72;
+acc += Math.sin(24226) + Math.cos(24227) * 73;
+acc += Math.sin(24227) + Math.cos(24228) * 74;
+acc += Math.sin(24228) + Math.cos(24229) * 75;
+acc += Math.sin(24229) + Math.cos(24230) * 76;
+acc += Math.sin(24230) + Math.cos(24231) * 77;
+acc += Math.sin(24231) + Math.cos(24232) * 78;
+acc += Math.sin(24232) + Math.cos(24233) * 79;
+acc += Math.sin(24233) + Math.cos(24234) * 80;
+acc += Math.sin(24234) + Math.cos(24235) * 81;
+acc += Math.sin(24235) + Math.cos(24236) * 82;
+acc += Math.sin(24236) + Math.cos(24237) * 83;
+acc += Math.sin(24237) + Math.cos(24238) * 84;
+acc += Math.sin(24238) + Math.cos(24239) * 85;
+acc += Math.sin(24239) + Math.cos(24240) * 86;
+acc += Math.sin(24240) + Math.cos(24241) * 87;
+acc += Math.sin(24241) + Math.cos(24242) * 88;
+acc += Math.sin(24242) + Math.cos(24243) * 89;
+acc += Math.sin(24243) + Math.cos(24244) * 90;
+acc += Math.sin(24244) + Math.cos(24245) * 91;
+acc += Math.sin(24245) + Math.cos(24246) * 92;
+acc += Math.sin(24246) + Math.cos(24247) * 93;
+acc += Math.sin(24247) + Math.cos(24248) * 94;
+acc += Math.sin(24248) + Math.cos(24249) * 95;
+acc += Math.sin(24249) + Math.cos(24250) * 96;
+acc += Math.sin(24250) + Math.cos(24251) * 0;
+acc += Math.sin(24251) + Math.cos(24252) * 1;
+acc += Math.sin(24252) + Math.cos(24253) * 2;
+acc += Math.sin(24253) + Math.cos(24254) * 3;
+acc += Math.sin(24254) + Math.cos(24255) * 4;
+acc += Math.sin(24255) + Math.cos(24256) * 5;
+acc += Math.sin(24256) + Math.cos(24257) * 6;
+acc += Math.sin(24257) + Math.cos(24258) * 7;
+acc += Math.sin(24258) + Math.cos(24259) * 8;
+acc += Math.sin(24259) + Math.cos(24260) * 9;
+acc += Math.sin(24260) + Math.cos(24261) * 10;
+acc += Math.sin(24261) + Math.cos(24262) * 11;
+acc += Math.sin(24262) + Math.cos(24263) * 12;
+acc += Math.sin(24263) + Math.cos(24264) * 13;
+acc += Math.sin(24264) + Math.cos(24265) * 14;
+acc += Math.sin(24265) + Math.cos(24266) * 15;
+acc += Math.sin(24266) + Math.cos(24267) * 16;
+acc += Math.sin(24267) + Math.cos(24268) * 17;
+acc += Math.sin(24268) + Math.cos(24269) * 18;
+acc += Math.sin(24269) + Math.cos(24270) * 19;
+acc += Math.sin(24270) + Math.cos(24271) * 20;
+acc += Math.sin(24271) + Math.cos(24272) * 21;
+acc += Math.sin(24272) + Math.cos(24273) * 22;
+acc += Math.sin(24273) + Math.cos(24274) * 23;
+acc += Math.sin(24274) + Math.cos(24275) * 24;
+acc += Math.sin(24275) + Math.cos(24276) * 25;
+acc += Math.sin(24276) + Math.cos(24277) * 26;
+acc += Math.sin(24277) + Math.cos(24278) * 27;
+acc += Math.sin(24278) + Math.cos(24279) * 28;
+acc += Math.sin(24279) + Math.cos(24280) * 29;
+acc += Math.sin(24280) + Math.cos(24281) * 30;
+acc += Math.sin(24281) + Math.cos(24282) * 31;
+acc += Math.sin(24282) + Math.cos(24283) * 32;
+acc += Math.sin(24283) + Math.cos(24284) * 33;
+acc += Math.sin(24284) + Math.cos(24285) * 34;
+acc += Math.sin(24285) + Math.cos(24286) * 35;
+acc += Math.sin(24286) + Math.cos(24287) * 36;
+acc += Math.sin(24287) + Math.cos(24288) * 37;
+acc += Math.sin(24288) + Math.cos(24289) * 38;
+acc += Math.sin(24289) + Math.cos(24290) * 39;
+acc += Math.sin(24290) + Math.cos(24291) * 40;
+acc += Math.sin(24291) + Math.cos(24292) * 41;
+acc += Math.sin(24292) + Math.cos(24293) * 42;
+acc += Math.sin(24293) + Math.cos(24294) * 43;
+acc += Math.sin(24294) + Math.cos(24295) * 44;
+acc += Math.sin(24295) + Math.cos(24296) * 45;
+acc += Math.sin(24296) + Math.cos(24297) * 46;
+acc += Math.sin(24297) + Math.cos(24298) * 47;
+acc += Math.sin(24298) + Math.cos(24299) * 48;
+acc += Math.sin(24299) + Math.cos(24300) * 49;
+acc += Math.sin(24300) + Math.cos(24301) * 50;
+acc += Math.sin(24301) + Math.cos(24302) * 51;
+acc += Math.sin(24302) + Math.cos(24303) * 52;
+acc += Math.sin(24303) + Math.cos(24304) * 53;
+acc += Math.sin(24304) + Math.cos(24305) * 54;
+acc += Math.sin(24305) + Math.cos(24306) * 55;
+acc += Math.sin(24306) + Math.cos(24307) * 56;
+acc += Math.sin(24307) + Math.cos(24308) * 57;
+acc += Math.sin(24308) + Math.cos(24309) * 58;
+acc += Math.sin(24309) + Math.cos(24310) * 59;
+acc += Math.sin(24310) + Math.cos(24311) * 60;
+acc += Math.sin(24311) + Math.cos(24312) * 61;
+acc += Math.sin(24312) + Math.cos(24313) * 62;
+acc += Math.sin(24313) + Math.cos(24314) * 63;
+acc += Math.sin(24314) + Math.cos(24315) * 64;
+acc += Math.sin(24315) + Math.cos(24316) * 65;
+acc += Math.sin(24316) + Math.cos(24317) * 66;
+acc += Math.sin(24317) + Math.cos(24318) * 67;
+acc += Math.sin(24318) + Math.cos(24319) * 68;
+acc += Math.sin(24319) + Math.cos(24320) * 69;
+acc += Math.sin(24320) + Math.cos(24321) * 70;
+acc += Math.sin(24321) + Math.cos(24322) * 71;
+acc += Math.sin(24322) + Math.cos(24323) * 72;
+acc += Math.sin(24323) + Math.cos(24324) * 73;
+acc += Math.sin(24324) + Math.cos(24325) * 74;
+acc += Math.sin(24325) + Math.cos(24326) * 75;
+acc += Math.sin(24326) + Math.cos(24327) * 76;
+acc += Math.sin(24327) + Math.cos(24328) * 77;
+acc += Math.sin(24328) + Math.cos(24329) * 78;
+acc += Math.sin(24329) + Math.cos(24330) * 79;
+acc += Math.sin(24330) + Math.cos(24331) * 80;
+acc += Math.sin(24331) + Math.cos(24332) * 81;
+acc += Math.sin(24332) + Math.cos(24333) * 82;
+acc += Math.sin(24333) + Math.cos(24334) * 83;
+acc += Math.sin(24334) + Math.cos(24335) * 84;
+acc += Math.sin(24335) + Math.cos(24336) * 85;
+acc += Math.sin(24336) + Math.cos(24337) * 86;
+acc += Math.sin(24337) + Math.cos(24338) * 87;
+acc += Math.sin(24338) + Math.cos(24339) * 88;
+acc += Math.sin(24339) + Math.cos(24340) * 89;
+acc += Math.sin(24340) + Math.cos(24341) * 90;
+acc += Math.sin(24341) + Math.cos(24342) * 91;
+acc += Math.sin(24342) + Math.cos(24343) * 92;
+acc += Math.sin(24343) + Math.cos(24344) * 93;
+acc += Math.sin(24344) + Math.cos(24345) * 94;
+acc += Math.sin(24345) + Math.cos(24346) * 95;
+acc += Math.sin(24346) + Math.cos(24347) * 96;
+acc += Math.sin(24347) + Math.cos(24348) * 0;
+acc += Math.sin(24348) + Math.cos(24349) * 1;
+acc += Math.sin(24349) + Math.cos(24350) * 2;
+acc += Math.sin(24350) + Math.cos(24351) * 3;
+acc += Math.sin(24351) + Math.cos(24352) * 4;
+acc += Math.sin(24352) + Math.cos(24353) * 5;
+acc += Math.sin(24353) + Math.cos(24354) * 6;
+acc += Math.sin(24354) + Math.cos(24355) * 7;
+acc += Math.sin(24355) + Math.cos(24356) * 8;
+acc += Math.sin(24356) + Math.cos(24357) * 9;
+acc += Math.sin(24357) + Math.cos(24358) * 10;
+acc += Math.sin(24358) + Math.cos(24359) * 11;
+acc += Math.sin(24359) + Math.cos(24360) * 12;
+acc += Math.sin(24360) + Math.cos(24361) * 13;
+acc += Math.sin(24361) + Math.cos(24362) * 14;
+acc += Math.sin(24362) + Math.cos(24363) * 15;
+acc += Math.sin(24363) + Math.cos(24364) * 16;
+acc += Math.sin(24364) + Math.cos(24365) * 17;
+acc += Math.sin(24365) + Math.cos(24366) * 18;
+acc += Math.sin(24366) + Math.cos(24367) * 19;
+acc += Math.sin(24367) + Math.cos(24368) * 20;
+acc += Math.sin(24368) + Math.cos(24369) * 21;
+acc += Math.sin(24369) + Math.cos(24370) * 22;
+acc += Math.sin(24370) + Math.cos(24371) * 23;
+acc += Math.sin(24371) + Math.cos(24372) * 24;
+acc += Math.sin(24372) + Math.cos(24373) * 25;
+acc += Math.sin(24373) + Math.cos(24374) * 26;
+acc += Math.sin(24374) + Math.cos(24375) * 27;
+acc += Math.sin(24375) + Math.cos(24376) * 28;
+acc += Math.sin(24376) + Math.cos(24377) * 29;
+acc += Math.sin(24377) + Math.cos(24378) * 30;
+acc += Math.sin(24378) + Math.cos(24379) * 31;
+acc += Math.sin(24379) + Math.cos(24380) * 32;
+acc += Math.sin(24380) + Math.cos(24381) * 33;
+acc += Math.sin(24381) + Math.cos(24382) * 34;
+acc += Math.sin(24382) + Math.cos(24383) * 35;
+acc += Math.sin(24383) + Math.cos(24384) * 36;
+acc += Math.sin(24384) + Math.cos(24385) * 37;
+acc += Math.sin(24385) + Math.cos(24386) * 38;
+acc += Math.sin(24386) + Math.cos(24387) * 39;
+acc += Math.sin(24387) + Math.cos(24388) * 40;
+acc += Math.sin(24388) + Math.cos(24389) * 41;
+acc += Math.sin(24389) + Math.cos(24390) * 42;
+acc += Math.sin(24390) + Math.cos(24391) * 43;
+acc += Math.sin(24391) + Math.cos(24392) * 44;
+acc += Math.sin(24392) + Math.cos(24393) * 45;
+acc += Math.sin(24393) + Math.cos(24394) * 46;
+acc += Math.sin(24394) + Math.cos(24395) * 47;
+acc += Math.sin(24395) + Math.cos(24396) * 48;
+acc += Math.sin(24396) + Math.cos(24397) * 49;
+acc += Math.sin(24397) + Math.cos(24398) * 50;
+acc += Math.sin(24398) + Math.cos(24399) * 51;
+acc += Math.sin(24399) + Math.cos(24400) * 52;
+acc += Math.sin(24400) + Math.cos(24401) * 53;
+acc += Math.sin(24401) + Math.cos(24402) * 54;
+acc += Math.sin(24402) + Math.cos(24403) * 55;
+acc += Math.sin(24403) + Math.cos(24404) * 56;
+acc += Math.sin(24404) + Math.cos(24405) * 57;
+acc += Math.sin(24405) + Math.cos(24406) * 58;
+acc += Math.sin(24406) + Math.cos(24407) * 59;
+acc += Math.sin(24407) + Math.cos(24408) * 60;
+acc += Math.sin(24408) + Math.cos(24409) * 61;
+acc += Math.sin(24409) + Math.cos(24410) * 62;
+acc += Math.sin(24410) + Math.cos(24411) * 63;
+acc += Math.sin(24411) + Math.cos(24412) * 64;
+acc += Math.sin(24412) + Math.cos(24413) * 65;
+acc += Math.sin(24413) + Math.cos(24414) * 66;
+acc += Math.sin(24414) + Math.cos(24415) * 67;
+acc += Math.sin(24415) + Math.cos(24416) * 68;
+acc += Math.sin(24416) + Math.cos(24417) * 69;
+acc += Math.sin(24417) + Math.cos(24418) * 70;
+acc += Math.sin(24418) + Math.cos(24419) * 71;
+acc += Math.sin(24419) + Math.cos(24420) * 72;
+acc += Math.sin(24420) + Math.cos(24421) * 73;
+acc += Math.sin(24421) + Math.cos(24422) * 74;
+acc += Math.sin(24422) + Math.cos(24423) * 75;
+acc += Math.sin(24423) + Math.cos(24424) * 76;
+acc += Math.sin(24424) + Math.cos(24425) * 77;
+acc += Math.sin(24425) + Math.cos(24426) * 78;
+acc += Math.sin(24426) + Math.cos(24427) * 79;
+acc += Math.sin(24427) + Math.cos(24428) * 80;
+acc += Math.sin(24428) + Math.cos(24429) * 81;
+acc += Math.sin(24429) + Math.cos(24430) * 82;
+acc += Math.sin(24430) + Math.cos(24431) * 83;
+acc += Math.sin(24431) + Math.cos(24432) * 84;
+acc += Math.sin(24432) + Math.cos(24433) * 85;
+acc += Math.sin(24433) + Math.cos(24434) * 86;
+acc += Math.sin(24434) + Math.cos(24435) * 87;
+acc += Math.sin(24435) + Math.cos(24436) * 88;
+acc += Math.sin(24436) + Math.cos(24437) * 89;
+acc += Math.sin(24437) + Math.cos(24438) * 90;
+acc += Math.sin(24438) + Math.cos(24439) * 91;
+acc += Math.sin(24439) + Math.cos(24440) * 92;
+acc += Math.sin(24440) + Math.cos(24441) * 93;
+acc += Math.sin(24441) + Math.cos(24442) * 94;
+acc += Math.sin(24442) + Math.cos(24443) * 95;
+acc += Math.sin(24443) + Math.cos(24444) * 96;
+acc += Math.sin(24444) + Math.cos(24445) * 0;
+acc += Math.sin(24445) + Math.cos(24446) * 1;
+acc += Math.sin(24446) + Math.cos(24447) * 2;
+acc += Math.sin(24447) + Math.cos(24448) * 3;
+acc += Math.sin(24448) + Math.cos(24449) * 4;
+acc += Math.sin(24449) + Math.cos(24450) * 5;
+acc += Math.sin(24450) + Math.cos(24451) * 6;
+acc += Math.sin(24451) + Math.cos(24452) * 7;
+acc += Math.sin(24452) + Math.cos(24453) * 8;
+acc += Math.sin(24453) + Math.cos(24454) * 9;
+acc += Math.sin(24454) + Math.cos(24455) * 10;
+acc += Math.sin(24455) + Math.cos(24456) * 11;
+acc += Math.sin(24456) + Math.cos(24457) * 12;
+acc += Math.sin(24457) + Math.cos(24458) * 13;
+acc += Math.sin(24458) + Math.cos(24459) * 14;
+acc += Math.sin(24459) + Math.cos(24460) * 15;
+acc += Math.sin(24460) + Math.cos(24461) * 16;
+acc += Math.sin(24461) + Math.cos(24462) * 17;
+acc += Math.sin(24462) + Math.cos(24463) * 18;
+acc += Math.sin(24463) + Math.cos(24464) * 19;
+acc += Math.sin(24464) + Math.cos(24465) * 20;
+acc += Math.sin(24465) + Math.cos(24466) * 21;
+acc += Math.sin(24466) + Math.cos(24467) * 22;
+acc += Math.sin(24467) + Math.cos(24468) * 23;
+acc += Math.sin(24468) + Math.cos(24469) * 24;
+acc += Math.sin(24469) + Math.cos(24470) * 25;
+acc += Math.sin(24470) + Math.cos(24471) * 26;
+acc += Math.sin(24471) + Math.cos(24472) * 27;
+acc += Math.sin(24472) + Math.cos(24473) * 28;
+acc += Math.sin(24473) + Math.cos(24474) * 29;
+acc += Math.sin(24474) + Math.cos(24475) * 30;
+acc += Math.sin(24475) + Math.cos(24476) * 31;
+acc += Math.sin(24476) + Math.cos(24477) * 32;
+acc += Math.sin(24477) + Math.cos(24478) * 33;
+acc += Math.sin(24478) + Math.cos(24479) * 34;
+acc += Math.sin(24479) + Math.cos(24480) * 35;
+acc += Math.sin(24480) + Math.cos(24481) * 36;
+acc += Math.sin(24481) + Math.cos(24482) * 37;
+acc += Math.sin(24482) + Math.cos(24483) * 38;
+acc += Math.sin(24483) + Math.cos(24484) * 39;
+acc += Math.sin(24484) + Math.cos(24485) * 40;
+acc += Math.sin(24485) + Math.cos(24486) * 41;
+acc += Math.sin(24486) + Math.cos(24487) * 42;
+acc += Math.sin(24487) + Math.cos(24488) * 43;
+acc += Math.sin(24488) + Math.cos(24489) * 44;
+acc += Math.sin(24489) + Math.cos(24490) * 45;
+acc += Math.sin(24490) + Math.cos(24491) * 46;
+acc += Math.sin(24491) + Math.cos(24492) * 47;
+acc += Math.sin(24492) + Math.cos(24493) * 48;
+acc += Math.sin(24493) + Math.cos(24494) * 49;
+acc += Math.sin(24494) + Math.cos(24495) * 50;
+acc += Math.sin(24495) + Math.cos(24496) * 51;
+acc += Math.sin(24496) + Math.cos(24497) * 52;
+acc += Math.sin(24497) + Math.cos(24498) * 53;
+acc += Math.sin(24498) + Math.cos(24499) * 54;
+acc += Math.sin(24499) + Math.cos(24500) * 55;
+acc += Math.sin(24500) + Math.cos(24501) * 56;
+acc += Math.sin(24501) + Math.cos(24502) * 57;
+acc += Math.sin(24502) + Math.cos(24503) * 58;
+acc += Math.sin(24503) + Math.cos(24504) * 59;
+acc += Math.sin(24504) + Math.cos(24505) * 60;
+acc += Math.sin(24505) + Math.cos(24506) * 61;
+acc += Math.sin(24506) + Math.cos(24507) * 62;
+acc += Math.sin(24507) + Math.cos(24508) * 63;
+acc += Math.sin(24508) + Math.cos(24509) * 64;
+acc += Math.sin(24509) + Math.cos(24510) * 65;
+acc += Math.sin(24510) + Math.cos(24511) * 66;
+acc += Math.sin(24511) + Math.cos(24512) * 67;
+acc += Math.sin(24512) + Math.cos(24513) * 68;
+acc += Math.sin(24513) + Math.cos(24514) * 69;
+acc += Math.sin(24514) + Math.cos(24515) * 70;
+acc += Math.sin(24515) + Math.cos(24516) * 71;
+acc += Math.sin(24516) + Math.cos(24517) * 72;
+acc += Math.sin(24517) + Math.cos(24518) * 73;
+acc += Math.sin(24518) + Math.cos(24519) * 74;
+acc += Math.sin(24519) + Math.cos(24520) * 75;
+acc += Math.sin(24520) + Math.cos(24521) * 76;
+acc += Math.sin(24521) + Math.cos(24522) * 77;
+acc += Math.sin(24522) + Math.cos(24523) * 78;
+acc += Math.sin(24523) + Math.cos(24524) * 79;
+acc += Math.sin(24524) + Math.cos(24525) * 80;
+acc += Math.sin(24525) + Math.cos(24526) * 81;
+acc += Math.sin(24526) + Math.cos(24527) * 82;
+acc += Math.sin(24527) + Math.cos(24528) * 83;
+acc += Math.sin(24528) + Math.cos(24529) * 84;
+acc += Math.sin(24529) + Math.cos(24530) * 85;
+acc += Math.sin(24530) + Math.cos(24531) * 86;
+acc += Math.sin(24531) + Math.cos(24532) * 87;
+acc += Math.sin(24532) + Math.cos(24533) * 88;
+acc += Math.sin(24533) + Math.cos(24534) * 89;
+acc += Math.sin(24534) + Math.cos(24535) * 90;
+acc += Math.sin(24535) + Math.cos(24536) * 91;
+acc += Math.sin(24536) + Math.cos(24537) * 92;
+acc += Math.sin(24537) + Math.cos(24538) * 93;
+acc += Math.sin(24538) + Math.cos(24539) * 94;
+acc += Math.sin(24539) + Math.cos(24540) * 95;
+acc += Math.sin(24540) + Math.cos(24541) * 96;
+acc += Math.sin(24541) + Math.cos(24542) * 0;
+acc += Math.sin(24542) + Math.cos(24543) * 1;
+acc += Math.sin(24543) + Math.cos(24544) * 2;
+acc += Math.sin(24544) + Math.cos(24545) * 3;
+acc += Math.sin(24545) + Math.cos(24546) * 4;
+acc += Math.sin(24546) + Math.cos(24547) * 5;
+acc += Math.sin(24547) + Math.cos(24548) * 6;
+acc += Math.sin(24548) + Math.cos(24549) * 7;
+acc += Math.sin(24549) + Math.cos(24550) * 8;
+acc += Math.sin(24550) + Math.cos(24551) * 9;
+acc += Math.sin(24551) + Math.cos(24552) * 10;
+acc += Math.sin(24552) + Math.cos(24553) * 11;
+acc += Math.sin(24553) + Math.cos(24554) * 12;
+acc += Math.sin(24554) + Math.cos(24555) * 13;
+acc += Math.sin(24555) + Math.cos(24556) * 14;
+acc += Math.sin(24556) + Math.cos(24557) * 15;
+acc += Math.sin(24557) + Math.cos(24558) * 16;
+acc += Math.sin(24558) + Math.cos(24559) * 17;
+acc += Math.sin(24559) + Math.cos(24560) * 18;
+acc += Math.sin(24560) + Math.cos(24561) * 19;
+acc += Math.sin(24561) + Math.cos(24562) * 20;
+acc += Math.sin(24562) + Math.cos(24563) * 21;
+acc += Math.sin(24563) + Math.cos(24564) * 22;
+acc += Math.sin(24564) + Math.cos(24565) * 23;
+acc += Math.sin(24565) + Math.cos(24566) * 24;
+acc += Math.sin(24566) + Math.cos(24567) * 25;
+acc += Math.sin(24567) + Math.cos(24568) * 26;
+acc += Math.sin(24568) + Math.cos(24569) * 27;
+acc += Math.sin(24569) + Math.cos(24570) * 28;
+acc += Math.sin(24570) + Math.cos(24571) * 29;
+acc += Math.sin(24571) + Math.cos(24572) * 30;
+acc += Math.sin(24572) + Math.cos(24573) * 31;
+acc += Math.sin(24573) + Math.cos(24574) * 32;
+acc += Math.sin(24574) + Math.cos(24575) * 33;
+acc += Math.sin(24575) + Math.cos(24576) * 34;
+acc += Math.sin(24576) + Math.cos(24577) * 35;
+acc += Math.sin(24577) + Math.cos(24578) * 36;
+acc += Math.sin(24578) + Math.cos(24579) * 37;
+acc += Math.sin(24579) + Math.cos(24580) * 38;
+acc += Math.sin(24580) + Math.cos(24581) * 39;
+acc += Math.sin(24581) + Math.cos(24582) * 40;
+acc += Math.sin(24582) + Math.cos(24583) * 41;
+acc += Math.sin(24583) + Math.cos(24584) * 42;
+acc += Math.sin(24584) + Math.cos(24585) * 43;
+acc += Math.sin(24585) + Math.cos(24586) * 44;
+acc += Math.sin(24586) + Math.cos(24587) * 45;
+acc += Math.sin(24587) + Math.cos(24588) * 46;
+acc += Math.sin(24588) + Math.cos(24589) * 47;
+acc += Math.sin(24589) + Math.cos(24590) * 48;
+acc += Math.sin(24590) + Math.cos(24591) * 49;
+acc += Math.sin(24591) + Math.cos(24592) * 50;
+acc += Math.sin(24592) + Math.cos(24593) * 51;
+acc += Math.sin(24593) + Math.cos(24594) * 52;
+acc += Math.sin(24594) + Math.cos(24595) * 53;
+acc += Math.sin(24595) + Math.cos(24596) * 54;
+acc += Math.sin(24596) + Math.cos(24597) * 55;
+acc += Math.sin(24597) + Math.cos(24598) * 56;
+acc += Math.sin(24598) + Math.cos(24599) * 57;
+acc += Math.sin(24599) + Math.cos(24600) * 58;
+acc += Math.sin(24600) + Math.cos(24601) * 59;
+acc += Math.sin(24601) + Math.cos(24602) * 60;
+acc += Math.sin(24602) + Math.cos(24603) * 61;
+acc += Math.sin(24603) + Math.cos(24604) * 62;
+acc += Math.sin(24604) + Math.cos(24605) * 63;
+acc += Math.sin(24605) + Math.cos(24606) * 64;
+acc += Math.sin(24606) + Math.cos(24607) * 65;
+acc += Math.sin(24607) + Math.cos(24608) * 66;
+acc += Math.sin(24608) + Math.cos(24609) * 67;
+acc += Math.sin(24609) + Math.cos(24610) * 68;
+acc += Math.sin(24610) + Math.cos(24611) * 69;
+acc += Math.sin(24611) + Math.cos(24612) * 70;
+acc += Math.sin(24612) + Math.cos(24613) * 71;
+acc += Math.sin(24613) + Math.cos(24614) * 72;
+acc += Math.sin(24614) + Math.cos(24615) * 73;
+acc += Math.sin(24615) + Math.cos(24616) * 74;
+acc += Math.sin(24616) + Math.cos(24617) * 75;
+acc += Math.sin(24617) + Math.cos(24618) * 76;
+acc += Math.sin(24618) + Math.cos(24619) * 77;
+acc += Math.sin(24619) + Math.cos(24620) * 78;
+acc += Math.sin(24620) + Math.cos(24621) * 79;
+acc += Math.sin(24621) + Math.cos(24622) * 80;
+acc += Math.sin(24622) + Math.cos(24623) * 81;
+acc += Math.sin(24623) + Math.cos(24624) * 82;
+acc += Math.sin(24624) + Math.cos(24625) * 83;
+acc += Math.sin(24625) + Math.cos(24626) * 84;
+acc += Math.sin(24626) + Math.cos(24627) * 85;
+acc += Math.sin(24627) + Math.cos(24628) * 86;
+acc += Math.sin(24628) + Math.cos(24629) * 87;
+acc += Math.sin(24629) + Math.cos(24630) * 88;
+acc += Math.sin(24630) + Math.cos(24631) * 89;
+acc += Math.sin(24631) + Math.cos(24632) * 90;
+acc += Math.sin(24632) + Math.cos(24633) * 91;
+acc += Math.sin(24633) + Math.cos(24634) * 92;
+acc += Math.sin(24634) + Math.cos(24635) * 93;
+acc += Math.sin(24635) + Math.cos(24636) * 94;
+acc += Math.sin(24636) + Math.cos(24637) * 95;
+acc += Math.sin(24637) + Math.cos(24638) * 96;
+acc += Math.sin(24638) + Math.cos(24639) * 0;
+acc += Math.sin(24639) + Math.cos(24640) * 1;
+acc += Math.sin(24640) + Math.cos(24641) * 2;
+acc += Math.sin(24641) + Math.cos(24642) * 3;
+acc += Math.sin(24642) + Math.cos(24643) * 4;
+acc += Math.sin(24643) + Math.cos(24644) * 5;
+acc += Math.sin(24644) + Math.cos(24645) * 6;
+acc += Math.sin(24645) + Math.cos(24646) * 7;
+acc += Math.sin(24646) + Math.cos(24647) * 8;
+acc += Math.sin(24647) + Math.cos(24648) * 9;
+acc += Math.sin(24648) + Math.cos(24649) * 10;
+acc += Math.sin(24649) + Math.cos(24650) * 11;
+acc += Math.sin(24650) + Math.cos(24651) * 12;
+acc += Math.sin(24651) + Math.cos(24652) * 13;
+acc += Math.sin(24652) + Math.cos(24653) * 14;
+acc += Math.sin(24653) + Math.cos(24654) * 15;
+acc += Math.sin(24654) + Math.cos(24655) * 16;
+acc += Math.sin(24655) + Math.cos(24656) * 17;
+acc += Math.sin(24656) + Math.cos(24657) * 18;
+acc += Math.sin(24657) + Math.cos(24658) * 19;
+acc += Math.sin(24658) + Math.cos(24659) * 20;
+acc += Math.sin(24659) + Math.cos(24660) * 21;
+acc += Math.sin(24660) + Math.cos(24661) * 22;
+acc += Math.sin(24661) + Math.cos(24662) * 23;
+acc += Math.sin(24662) + Math.cos(24663) * 24;
+acc += Math.sin(24663) + Math.cos(24664) * 25;
+acc += Math.sin(24664) + Math.cos(24665) * 26;
+acc += Math.sin(24665) + Math.cos(24666) * 27;
+acc += Math.sin(24666) + Math.cos(24667) * 28;
+acc += Math.sin(24667) + Math.cos(24668) * 29;
+acc += Math.sin(24668) + Math.cos(24669) * 30;
+acc += Math.sin(24669) + Math.cos(24670) * 31;
+acc += Math.sin(24670) + Math.cos(24671) * 32;
+acc += Math.sin(24671) + Math.cos(24672) * 33;
+acc += Math.sin(24672) + Math.cos(24673) * 34;
+acc += Math.sin(24673) + Math.cos(24674) * 35;
+acc += Math.sin(24674) + Math.cos(24675) * 36;
+acc += Math.sin(24675) + Math.cos(24676) * 37;
+acc += Math.sin(24676) + Math.cos(24677) * 38;
+acc += Math.sin(24677) + Math.cos(24678) * 39;
+acc += Math.sin(24678) + Math.cos(24679) * 40;
+acc += Math.sin(24679) + Math.cos(24680) * 41;
+acc += Math.sin(24680) + Math.cos(24681) * 42;
+acc += Math.sin(24681) + Math.cos(24682) * 43;
+acc += Math.sin(24682) + Math.cos(24683) * 44;
+acc += Math.sin(24683) + Math.cos(24684) * 45;
+acc += Math.sin(24684) + Math.cos(24685) * 46;
+acc += Math.sin(24685) + Math.cos(24686) * 47;
+acc += Math.sin(24686) + Math.cos(24687) * 48;
+acc += Math.sin(24687) + Math.cos(24688) * 49;
+acc += Math.sin(24688) + Math.cos(24689) * 50;
+acc += Math.sin(24689) + Math.cos(24690) * 51;
+acc += Math.sin(24690) + Math.cos(24691) * 52;
+acc += Math.sin(24691) + Math.cos(24692) * 53;
+acc += Math.sin(24692) + Math.cos(24693) * 54;
+acc += Math.sin(24693) + Math.cos(24694) * 55;
+acc += Math.sin(24694) + Math.cos(24695) * 56;
+acc += Math.sin(24695) + Math.cos(24696) * 57;
+acc += Math.sin(24696) + Math.cos(24697) * 58;
+acc += Math.sin(24697) + Math.cos(24698) * 59;
+acc += Math.sin(24698) + Math.cos(24699) * 60;
+acc += Math.sin(24699) + Math.cos(24700) * 61;
+acc += Math.sin(24700) + Math.cos(24701) * 62;
+acc += Math.sin(24701) + Math.cos(24702) * 63;
+acc += Math.sin(24702) + Math.cos(24703) * 64;
+acc += Math.sin(24703) + Math.cos(24704) * 65;
+acc += Math.sin(24704) + Math.cos(24705) * 66;
+acc += Math.sin(24705) + Math.cos(24706) * 67;
+acc += Math.sin(24706) + Math.cos(24707) * 68;
+acc += Math.sin(24707) + Math.cos(24708) * 69;
+acc += Math.sin(24708) + Math.cos(24709) * 70;
+acc += Math.sin(24709) + Math.cos(24710) * 71;
+acc += Math.sin(24710) + Math.cos(24711) * 72;
+acc += Math.sin(24711) + Math.cos(24712) * 73;
+acc += Math.sin(24712) + Math.cos(24713) * 74;
+acc += Math.sin(24713) + Math.cos(24714) * 75;
+acc += Math.sin(24714) + Math.cos(24715) * 76;
+acc += Math.sin(24715) + Math.cos(24716) * 77;
+acc += Math.sin(24716) + Math.cos(24717) * 78;
+acc += Math.sin(24717) + Math.cos(24718) * 79;
+acc += Math.sin(24718) + Math.cos(24719) * 80;
+acc += Math.sin(24719) + Math.cos(24720) * 81;
+acc += Math.sin(24720) + Math.cos(24721) * 82;
+acc += Math.sin(24721) + Math.cos(24722) * 83;
+acc += Math.sin(24722) + Math.cos(24723) * 84;
+acc += Math.sin(24723) + Math.cos(24724) * 85;
+acc += Math.sin(24724) + Math.cos(24725) * 86;
+acc += Math.sin(24725) + Math.cos(24726) * 87;
+acc += Math.sin(24726) + Math.cos(24727) * 88;
+acc += Math.sin(24727) + Math.cos(24728) * 89;
+acc += Math.sin(24728) + Math.cos(24729) * 90;
+acc += Math.sin(24729) + Math.cos(24730) * 91;
+acc += Math.sin(24730) + Math.cos(24731) * 92;
+acc += Math.sin(24731) + Math.cos(24732) * 93;
+acc += Math.sin(24732) + Math.cos(24733) * 94;
+acc += Math.sin(24733) + Math.cos(24734) * 95;
+acc += Math.sin(24734) + Math.cos(24735) * 96;
+acc += Math.sin(24735) + Math.cos(24736) * 0;
+acc += Math.sin(24736) + Math.cos(24737) * 1;
+acc += Math.sin(24737) + Math.cos(24738) * 2;
+acc += Math.sin(24738) + Math.cos(24739) * 3;
+acc += Math.sin(24739) + Math.cos(24740) * 4;
+acc += Math.sin(24740) + Math.cos(24741) * 5;
+acc += Math.sin(24741) + Math.cos(24742) * 6;
+acc += Math.sin(24742) + Math.cos(24743) * 7;
+acc += Math.sin(24743) + Math.cos(24744) * 8;
+acc += Math.sin(24744) + Math.cos(24745) * 9;
+acc += Math.sin(24745) + Math.cos(24746) * 10;
+acc += Math.sin(24746) + Math.cos(24747) * 11;
+acc += Math.sin(24747) + Math.cos(24748) * 12;
+acc += Math.sin(24748) + Math.cos(24749) * 13;
+acc += Math.sin(24749) + Math.cos(24750) * 14;
+acc += Math.sin(24750) + Math.cos(24751) * 15;
+acc += Math.sin(24751) + Math.cos(24752) * 16;
+acc += Math.sin(24752) + Math.cos(24753) * 17;
+acc += Math.sin(24753) + Math.cos(24754) * 18;
+acc += Math.sin(24754) + Math.cos(24755) * 19;
+acc += Math.sin(24755) + Math.cos(24756) * 20;
+acc += Math.sin(24756) + Math.cos(24757) * 21;
+acc += Math.sin(24757) + Math.cos(24758) * 22;
+acc += Math.sin(24758) + Math.cos(24759) * 23;
+acc += Math.sin(24759) + Math.cos(24760) * 24;
+acc += Math.sin(24760) + Math.cos(24761) * 25;
+acc += Math.sin(24761) + Math.cos(24762) * 26;
+acc += Math.sin(24762) + Math.cos(24763) * 27;
+acc += Math.sin(24763) + Math.cos(24764) * 28;
+acc += Math.sin(24764) + Math.cos(24765) * 29;
+acc += Math.sin(24765) + Math.cos(24766) * 30;
+acc += Math.sin(24766) + Math.cos(24767) * 31;
+acc += Math.sin(24767) + Math.cos(24768) * 32;
+acc += Math.sin(24768) + Math.cos(24769) * 33;
+acc += Math.sin(24769) + Math.cos(24770) * 34;
+acc += Math.sin(24770) + Math.cos(24771) * 35;
+acc += Math.sin(24771) + Math.cos(24772) * 36;
+acc += Math.sin(24772) + Math.cos(24773) * 37;
+acc += Math.sin(24773) + Math.cos(24774) * 38;
+acc += Math.sin(24774) + Math.cos(24775) * 39;
+acc += Math.sin(24775) + Math.cos(24776) * 40;
+acc += Math.sin(24776) + Math.cos(24777) * 41;
+acc += Math.sin(24777) + Math.cos(24778) * 42;
+acc += Math.sin(24778) + Math.cos(24779) * 43;
+acc += Math.sin(24779) + Math.cos(24780) * 44;
+acc += Math.sin(24780) + Math.cos(24781) * 45;
+acc += Math.sin(24781) + Math.cos(24782) * 46;
+acc += Math.sin(24782) + Math.cos(24783) * 47;
+acc += Math.sin(24783) + Math.cos(24784) * 48;
+acc += Math.sin(24784) + Math.cos(24785) * 49;
+acc += Math.sin(24785) + Math.cos(24786) * 50;
+acc += Math.sin(24786) + Math.cos(24787) * 51;
+acc += Math.sin(24787) + Math.cos(24788) * 52;
+acc += Math.sin(24788) + Math.cos(24789) * 53;
+acc += Math.sin(24789) + Math.cos(24790) * 54;
+acc += Math.sin(24790) + Math.cos(24791) * 55;
+acc += Math.sin(24791) + Math.cos(24792) * 56;
+acc += Math.sin(24792) + Math.cos(24793) * 57;
+acc += Math.sin(24793) + Math.cos(24794) * 58;
+acc += Math.sin(24794) + Math.cos(24795) * 59;
+acc += Math.sin(24795) + Math.cos(24796) * 60;
+acc += Math.sin(24796) + Math.cos(24797) * 61;
+acc += Math.sin(24797) + Math.cos(24798) * 62;
+acc += Math.sin(24798) + Math.cos(24799) * 63;
+acc += Math.sin(24799) + Math.cos(24800) * 64;
+acc += Math.sin(24800) + Math.cos(24801) * 65;
+acc += Math.sin(24801) + Math.cos(24802) * 66;
+acc += Math.sin(24802) + Math.cos(24803) * 67;
+acc += Math.sin(24803) + Math.cos(24804) * 68;
+acc += Math.sin(24804) + Math.cos(24805) * 69;
+acc += Math.sin(24805) + Math.cos(24806) * 70;
+acc += Math.sin(24806) + Math.cos(24807) * 71;
+acc += Math.sin(24807) + Math.cos(24808) * 72;
+acc += Math.sin(24808) + Math.cos(24809) * 73;
+acc += Math.sin(24809) + Math.cos(24810) * 74;
+acc += Math.sin(24810) + Math.cos(24811) * 75;
+acc += Math.sin(24811) + Math.cos(24812) * 76;
+acc += Math.sin(24812) + Math.cos(24813) * 77;
+acc += Math.sin(24813) + Math.cos(24814) * 78;
+acc += Math.sin(24814) + Math.cos(24815) * 79;
+acc += Math.sin(24815) + Math.cos(24816) * 80;
+acc += Math.sin(24816) + Math.cos(24817) * 81;
+acc += Math.sin(24817) + Math.cos(24818) * 82;
+acc += Math.sin(24818) + Math.cos(24819) * 83;
+acc += Math.sin(24819) + Math.cos(24820) * 84;
+acc += Math.sin(24820) + Math.cos(24821) * 85;
+acc += Math.sin(24821) + Math.cos(24822) * 86;
+acc += Math.sin(24822) + Math.cos(24823) * 87;
+acc += Math.sin(24823) + Math.cos(24824) * 88;
+acc += Math.sin(24824) + Math.cos(24825) * 89;
+acc += Math.sin(24825) + Math.cos(24826) * 90;
+acc += Math.sin(24826) + Math.cos(24827) * 91;
+acc += Math.sin(24827) + Math.cos(24828) * 92;
+acc += Math.sin(24828) + Math.cos(24829) * 93;
+acc += Math.sin(24829) + Math.cos(24830) * 94;
+acc += Math.sin(24830) + Math.cos(24831) * 95;
+acc += Math.sin(24831) + Math.cos(24832) * 96;
+acc += Math.sin(24832) + Math.cos(24833) * 0;
+acc += Math.sin(24833) + Math.cos(24834) * 1;
+acc += Math.sin(24834) + Math.cos(24835) * 2;
+acc += Math.sin(24835) + Math.cos(24836) * 3;
+acc += Math.sin(24836) + Math.cos(24837) * 4;
+acc += Math.sin(24837) + Math.cos(24838) * 5;
+acc += Math.sin(24838) + Math.cos(24839) * 6;
+acc += Math.sin(24839) + Math.cos(24840) * 7;
+acc += Math.sin(24840) + Math.cos(24841) * 8;
+acc += Math.sin(24841) + Math.cos(24842) * 9;
+acc += Math.sin(24842) + Math.cos(24843) * 10;
+acc += Math.sin(24843) + Math.cos(24844) * 11;
+acc += Math.sin(24844) + Math.cos(24845) * 12;
+acc += Math.sin(24845) + Math.cos(24846) * 13;
+acc += Math.sin(24846) + Math.cos(24847) * 14;
+acc += Math.sin(24847) + Math.cos(24848) * 15;
+acc += Math.sin(24848) + Math.cos(24849) * 16;
+acc += Math.sin(24849) + Math.cos(24850) * 17;
+acc += Math.sin(24850) + Math.cos(24851) * 18;
+acc += Math.sin(24851) + Math.cos(24852) * 19;
+acc += Math.sin(24852) + Math.cos(24853) * 20;
+acc += Math.sin(24853) + Math.cos(24854) * 21;
+acc += Math.sin(24854) + Math.cos(24855) * 22;
+acc += Math.sin(24855) + Math.cos(24856) * 23;
+acc += Math.sin(24856) + Math.cos(24857) * 24;
+acc += Math.sin(24857) + Math.cos(24858) * 25;
+acc += Math.sin(24858) + Math.cos(24859) * 26;
+acc += Math.sin(24859) + Math.cos(24860) * 27;
+acc += Math.sin(24860) + Math.cos(24861) * 28;
+acc += Math.sin(24861) + Math.cos(24862) * 29;
+acc += Math.sin(24862) + Math.cos(24863) * 30;
+acc += Math.sin(24863) + Math.cos(24864) * 31;
+acc += Math.sin(24864) + Math.cos(24865) * 32;
+acc += Math.sin(24865) + Math.cos(24866) * 33;
+acc += Math.sin(24866) + Math.cos(24867) * 34;
+acc += Math.sin(24867) + Math.cos(24868) * 35;
+acc += Math.sin(24868) + Math.cos(24869) * 36;
+acc += Math.sin(24869) + Math.cos(24870) * 37;
+acc += Math.sin(24870) + Math.cos(24871) * 38;
+acc += Math.sin(24871) + Math.cos(24872) * 39;
+acc += Math.sin(24872) + Math.cos(24873) * 40;
+acc += Math.sin(24873) + Math.cos(24874) * 41;
+acc += Math.sin(24874) + Math.cos(24875) * 42;
+acc += Math.sin(24875) + Math.cos(24876) * 43;
+acc += Math.sin(24876) + Math.cos(24877) * 44;
+acc += Math.sin(24877) + Math.cos(24878) * 45;
+acc += Math.sin(24878) + Math.cos(24879) * 46;
+acc += Math.sin(24879) + Math.cos(24880) * 47;
+acc += Math.sin(24880) + Math.cos(24881) * 48;
+acc += Math.sin(24881) + Math.cos(24882) * 49;
+acc += Math.sin(24882) + Math.cos(24883) * 50;
+acc += Math.sin(24883) + Math.cos(24884) * 51;
+acc += Math.sin(24884) + Math.cos(24885) * 52;
+acc += Math.sin(24885) + Math.cos(24886) * 53;
+acc += Math.sin(24886) + Math.cos(24887) * 54;
+acc += Math.sin(24887) + Math.cos(24888) * 55;
+acc += Math.sin(24888) + Math.cos(24889) * 56;
+acc += Math.sin(24889) + Math.cos(24890) * 57;
+acc += Math.sin(24890) + Math.cos(24891) * 58;
+acc += Math.sin(24891) + Math.cos(24892) * 59;
+acc += Math.sin(24892) + Math.cos(24893) * 60;
+acc += Math.sin(24893) + Math.cos(24894) * 61;
+acc += Math.sin(24894) + Math.cos(24895) * 62;
+acc += Math.sin(24895) + Math.cos(24896) * 63;
+acc += Math.sin(24896) + Math.cos(24897) * 64;
+acc += Math.sin(24897) + Math.cos(24898) * 65;
+acc += Math.sin(24898) + Math.cos(24899) * 66;
+acc += Math.sin(24899) + Math.cos(24900) * 67;
+acc += Math.sin(24900) + Math.cos(24901) * 68;
+acc += Math.sin(24901) + Math.cos(24902) * 69;
+acc += Math.sin(24902) + Math.cos(24903) * 70;
+acc += Math.sin(24903) + Math.cos(24904) * 71;
+acc += Math.sin(24904) + Math.cos(24905) * 72;
+acc += Math.sin(24905) + Math.cos(24906) * 73;
+acc += Math.sin(24906) + Math.cos(24907) * 74;
+acc += Math.sin(24907) + Math.cos(24908) * 75;
+acc += Math.sin(24908) + Math.cos(24909) * 76;
+acc += Math.sin(24909) + Math.cos(24910) * 77;
+acc += Math.sin(24910) + Math.cos(24911) * 78;
+acc += Math.sin(24911) + Math.cos(24912) * 79;
+acc += Math.sin(24912) + Math.cos(24913) * 80;
+acc += Math.sin(24913) + Math.cos(24914) * 81;
+acc += Math.sin(24914) + Math.cos(24915) * 82;
+acc += Math.sin(24915) + Math.cos(24916) * 83;
+acc += Math.sin(24916) + Math.cos(24917) * 84;
+acc += Math.sin(24917) + Math.cos(24918) * 85;
+acc += Math.sin(24918) + Math.cos(24919) * 86;
+acc += Math.sin(24919) + Math.cos(24920) * 87;
+acc += Math.sin(24920) + Math.cos(24921) * 88;
+acc += Math.sin(24921) + Math.cos(24922) * 89;
+acc += Math.sin(24922) + Math.cos(24923) * 90;
+acc += Math.sin(24923) + Math.cos(24924) * 91;
+acc += Math.sin(24924) + Math.cos(24925) * 92;
+acc += Math.sin(24925) + Math.cos(24926) * 93;
+acc += Math.sin(24926) + Math.cos(24927) * 94;
+acc += Math.sin(24927) + Math.cos(24928) * 95;
+acc += Math.sin(24928) + Math.cos(24929) * 96;
+acc += Math.sin(24929) + Math.cos(24930) * 0;
+acc += Math.sin(24930) + Math.cos(24931) * 1;
+acc += Math.sin(24931) + Math.cos(24932) * 2;
+acc += Math.sin(24932) + Math.cos(24933) * 3;
+acc += Math.sin(24933) + Math.cos(24934) * 4;
+acc += Math.sin(24934) + Math.cos(24935) * 5;
+acc += Math.sin(24935) + Math.cos(24936) * 6;
+acc += Math.sin(24936) + Math.cos(24937) * 7;
+acc += Math.sin(24937) + Math.cos(24938) * 8;
+acc += Math.sin(24938) + Math.cos(24939) * 9;
+acc += Math.sin(24939) + Math.cos(24940) * 10;
+acc += Math.sin(24940) + Math.cos(24941) * 11;
+acc += Math.sin(24941) + Math.cos(24942) * 12;
+acc += Math.sin(24942) + Math.cos(24943) * 13;
+acc += Math.sin(24943) + Math.cos(24944) * 14;
+acc += Math.sin(24944) + Math.cos(24945) * 15;
+acc += Math.sin(24945) + Math.cos(24946) * 16;
+acc += Math.sin(24946) + Math.cos(24947) * 17;
+acc += Math.sin(24947) + Math.cos(24948) * 18;
+acc += Math.sin(24948) + Math.cos(24949) * 19;
+acc += Math.sin(24949) + Math.cos(24950) * 20;
+acc += Math.sin(24950) + Math.cos(24951) * 21;
+acc += Math.sin(24951) + Math.cos(24952) * 22;
+acc += Math.sin(24952) + Math.cos(24953) * 23;
+acc += Math.sin(24953) + Math.cos(24954) * 24;
+acc += Math.sin(24954) + Math.cos(24955) * 25;
+acc += Math.sin(24955) + Math.cos(24956) * 26;
+acc += Math.sin(24956) + Math.cos(24957) * 27;
+acc += Math.sin(24957) + Math.cos(24958) * 28;
+acc += Math.sin(24958) + Math.cos(24959) * 29;
+acc += Math.sin(24959) + Math.cos(24960) * 30;
+acc += Math.sin(24960) + Math.cos(24961) * 31;
+acc += Math.sin(24961) + Math.cos(24962) * 32;
+acc += Math.sin(24962) + Math.cos(24963) * 33;
+acc += Math.sin(24963) + Math.cos(24964) * 34;
+acc += Math.sin(24964) + Math.cos(24965) * 35;
+acc += Math.sin(24965) + Math.cos(24966) * 36;
+acc += Math.sin(24966) + Math.cos(24967) * 37;
+acc += Math.sin(24967) + Math.cos(24968) * 38;
+acc += Math.sin(24968) + Math.cos(24969) * 39;
+acc += Math.sin(24969) + Math.cos(24970) * 40;
+acc += Math.sin(24970) + Math.cos(24971) * 41;
+acc += Math.sin(24971) + Math.cos(24972) * 42;
+acc += Math.sin(24972) + Math.cos(24973) * 43;
+acc += Math.sin(24973) + Math.cos(24974) * 44;
+acc += Math.sin(24974) + Math.cos(24975) * 45;
+acc += Math.sin(24975) + Math.cos(24976) * 46;
+acc += Math.sin(24976) + Math.cos(24977) * 47;
+acc += Math.sin(24977) + Math.cos(24978) * 48;
+acc += Math.sin(24978) + Math.cos(24979) * 49;
+acc += Math.sin(24979) + Math.cos(24980) * 50;
+acc += Math.sin(24980) + Math.cos(24981) * 51;
+acc += Math.sin(24981) + Math.cos(24982) * 52;
+acc += Math.sin(24982) + Math.cos(24983) * 53;
+acc += Math.sin(24983) + Math.cos(24984) * 54;
+acc += Math.sin(24984) + Math.cos(24985) * 55;
+acc += Math.sin(24985) + Math.cos(24986) * 56;
+acc += Math.sin(24986) + Math.cos(24987) * 57;
+acc += Math.sin(24987) + Math.cos(24988) * 58;
+acc += Math.sin(24988) + Math.cos(24989) * 59;
+acc += Math.sin(24989) + Math.cos(24990) * 60;
+acc += Math.sin(24990) + Math.cos(24991) * 61;
+acc += Math.sin(24991) + Math.cos(24992) * 62;
+acc += Math.sin(24992) + Math.cos(24993) * 63;
+acc += Math.sin(24993) + Math.cos(24994) * 64;
+acc += Math.sin(24994) + Math.cos(24995) * 65;
+acc += Math.sin(24995) + Math.cos(24996) * 66;
+acc += Math.sin(24996) + Math.cos(24997) * 67;
+acc += Math.sin(24997) + Math.cos(24998) * 68;
+acc += Math.sin(24998) + Math.cos(24999) * 69;
+acc += Math.sin(24999) + Math.cos(25000) * 70;
+acc += Math.sin(25000) + Math.cos(25001) * 71;
+acc += Math.sin(25001) + Math.cos(25002) * 72;
+acc += Math.sin(25002) + Math.cos(25003) * 73;
+acc += Math.sin(25003) + Math.cos(25004) * 74;
+acc += Math.sin(25004) + Math.cos(25005) * 75;
+acc += Math.sin(25005) + Math.cos(25006) * 76;
+acc += Math.sin(25006) + Math.cos(25007) * 77;
+acc += Math.sin(25007) + Math.cos(25008) * 78;
+acc += Math.sin(25008) + Math.cos(25009) * 79;
+acc += Math.sin(25009) + Math.cos(25010) * 80;
+acc += Math.sin(25010) + Math.cos(25011) * 81;
+acc += Math.sin(25011) + Math.cos(25012) * 82;
+acc += Math.sin(25012) + Math.cos(25013) * 83;
+acc += Math.sin(25013) + Math.cos(25014) * 84;
+acc += Math.sin(25014) + Math.cos(25015) * 85;
+acc += Math.sin(25015) + Math.cos(25016) * 86;
+acc += Math.sin(25016) + Math.cos(25017) * 87;
+acc += Math.sin(25017) + Math.cos(25018) * 88;
+acc += Math.sin(25018) + Math.cos(25019) * 89;
+acc += Math.sin(25019) + Math.cos(25020) * 90;
+acc += Math.sin(25020) + Math.cos(25021) * 91;
+acc += Math.sin(25021) + Math.cos(25022) * 92;
+acc += Math.sin(25022) + Math.cos(25023) * 93;
+acc += Math.sin(25023) + Math.cos(25024) * 94;
+acc += Math.sin(25024) + Math.cos(25025) * 95;
+acc += Math.sin(25025) + Math.cos(25026) * 96;
+acc += Math.sin(25026) + Math.cos(25027) * 0;
+acc += Math.sin(25027) + Math.cos(25028) * 1;
+acc += Math.sin(25028) + Math.cos(25029) * 2;
+acc += Math.sin(25029) + Math.cos(25030) * 3;
+acc += Math.sin(25030) + Math.cos(25031) * 4;
+acc += Math.sin(25031) + Math.cos(25032) * 5;
+acc += Math.sin(25032) + Math.cos(25033) * 6;
+acc += Math.sin(25033) + Math.cos(25034) * 7;
+acc += Math.sin(25034) + Math.cos(25035) * 8;
+acc += Math.sin(25035) + Math.cos(25036) * 9;
+acc += Math.sin(25036) + Math.cos(25037) * 10;
+acc += Math.sin(25037) + Math.cos(25038) * 11;
+acc += Math.sin(25038) + Math.cos(25039) * 12;
+acc += Math.sin(25039) + Math.cos(25040) * 13;
+acc += Math.sin(25040) + Math.cos(25041) * 14;
+acc += Math.sin(25041) + Math.cos(25042) * 15;
+acc += Math.sin(25042) + Math.cos(25043) * 16;
+acc += Math.sin(25043) + Math.cos(25044) * 17;
+acc += Math.sin(25044) + Math.cos(25045) * 18;
+acc += Math.sin(25045) + Math.cos(25046) * 19;
+acc += Math.sin(25046) + Math.cos(25047) * 20;
+acc += Math.sin(25047) + Math.cos(25048) * 21;
+acc += Math.sin(25048) + Math.cos(25049) * 22;
+acc += Math.sin(25049) + Math.cos(25050) * 23;
+acc += Math.sin(25050) + Math.cos(25051) * 24;
+acc += Math.sin(25051) + Math.cos(25052) * 25;
+acc += Math.sin(25052) + Math.cos(25053) * 26;
+acc += Math.sin(25053) + Math.cos(25054) * 27;
+acc += Math.sin(25054) + Math.cos(25055) * 28;
+acc += Math.sin(25055) + Math.cos(25056) * 29;
+acc += Math.sin(25056) + Math.cos(25057) * 30;
+acc += Math.sin(25057) + Math.cos(25058) * 31;
+acc += Math.sin(25058) + Math.cos(25059) * 32;
+acc += Math.sin(25059) + Math.cos(25060) * 33;
+acc += Math.sin(25060) + Math.cos(25061) * 34;
+acc += Math.sin(25061) + Math.cos(25062) * 35;
+acc += Math.sin(25062) + Math.cos(25063) * 36;
+acc += Math.sin(25063) + Math.cos(25064) * 37;
+acc += Math.sin(25064) + Math.cos(25065) * 38;
+acc += Math.sin(25065) + Math.cos(25066) * 39;
+acc += Math.sin(25066) + Math.cos(25067) * 40;
+acc += Math.sin(25067) + Math.cos(25068) * 41;
+acc += Math.sin(25068) + Math.cos(25069) * 42;
+acc += Math.sin(25069) + Math.cos(25070) * 43;
+acc += Math.sin(25070) + Math.cos(25071) * 44;
+acc += Math.sin(25071) + Math.cos(25072) * 45;
+acc += Math.sin(25072) + Math.cos(25073) * 46;
+acc += Math.sin(25073) + Math.cos(25074) * 47;
+acc += Math.sin(25074) + Math.cos(25075) * 48;
+acc += Math.sin(25075) + Math.cos(25076) * 49;
+acc += Math.sin(25076) + Math.cos(25077) * 50;
+acc += Math.sin(25077) + Math.cos(25078) * 51;
+acc += Math.sin(25078) + Math.cos(25079) * 52;
+acc += Math.sin(25079) + Math.cos(25080) * 53;
+acc += Math.sin(25080) + Math.cos(25081) * 54;
+acc += Math.sin(25081) + Math.cos(25082) * 55;
+acc += Math.sin(25082) + Math.cos(25083) * 56;
+acc += Math.sin(25083) + Math.cos(25084) * 57;
+acc += Math.sin(25084) + Math.cos(25085) * 58;
+acc += Math.sin(25085) + Math.cos(25086) * 59;
+acc += Math.sin(25086) + Math.cos(25087) * 60;
+acc += Math.sin(25087) + Math.cos(25088) * 61;
+acc += Math.sin(25088) + Math.cos(25089) * 62;
+acc += Math.sin(25089) + Math.cos(25090) * 63;
+acc += Math.sin(25090) + Math.cos(25091) * 64;
+acc += Math.sin(25091) + Math.cos(25092) * 65;
+acc += Math.sin(25092) + Math.cos(25093) * 66;
+acc += Math.sin(25093) + Math.cos(25094) * 67;
+acc += Math.sin(25094) + Math.cos(25095) * 68;
+acc += Math.sin(25095) + Math.cos(25096) * 69;
+acc += Math.sin(25096) + Math.cos(25097) * 70;
+acc += Math.sin(25097) + Math.cos(25098) * 71;
+acc += Math.sin(25098) + Math.cos(25099) * 72;
+acc += Math.sin(25099) + Math.cos(25100) * 73;
+acc += Math.sin(25100) + Math.cos(25101) * 74;
+acc += Math.sin(25101) + Math.cos(25102) * 75;
+acc += Math.sin(25102) + Math.cos(25103) * 76;
+acc += Math.sin(25103) + Math.cos(25104) * 77;
+acc += Math.sin(25104) + Math.cos(25105) * 78;
+acc += Math.sin(25105) + Math.cos(25106) * 79;
+acc += Math.sin(25106) + Math.cos(25107) * 80;
+acc += Math.sin(25107) + Math.cos(25108) * 81;
+acc += Math.sin(25108) + Math.cos(25109) * 82;
+acc += Math.sin(25109) + Math.cos(25110) * 83;
+acc += Math.sin(25110) + Math.cos(25111) * 84;
+acc += Math.sin(25111) + Math.cos(25112) * 85;
+acc += Math.sin(25112) + Math.cos(25113) * 86;
+acc += Math.sin(25113) + Math.cos(25114) * 87;
+acc += Math.sin(25114) + Math.cos(25115) * 88;
+acc += Math.sin(25115) + Math.cos(25116) * 89;
+acc += Math.sin(25116) + Math.cos(25117) * 90;
+acc += Math.sin(25117) + Math.cos(25118) * 91;
+acc += Math.sin(25118) + Math.cos(25119) * 92;
+acc += Math.sin(25119) + Math.cos(25120) * 93;
+acc += Math.sin(25120) + Math.cos(25121) * 94;
+acc += Math.sin(25121) + Math.cos(25122) * 95;
+acc += Math.sin(25122) + Math.cos(25123) * 96;
+acc += Math.sin(25123) + Math.cos(25124) * 0;
+acc += Math.sin(25124) + Math.cos(25125) * 1;
+acc += Math.sin(25125) + Math.cos(25126) * 2;
+acc += Math.sin(25126) + Math.cos(25127) * 3;
+acc += Math.sin(25127) + Math.cos(25128) * 4;
+acc += Math.sin(25128) + Math.cos(25129) * 5;
+acc += Math.sin(25129) + Math.cos(25130) * 6;
+acc += Math.sin(25130) + Math.cos(25131) * 7;
+acc += Math.sin(25131) + Math.cos(25132) * 8;
+acc += Math.sin(25132) + Math.cos(25133) * 9;
+acc += Math.sin(25133) + Math.cos(25134) * 10;
+acc += Math.sin(25134) + Math.cos(25135) * 11;
+acc += Math.sin(25135) + Math.cos(25136) * 12;
+acc += Math.sin(25136) + Math.cos(25137) * 13;
+acc += Math.sin(25137) + Math.cos(25138) * 14;
+acc += Math.sin(25138) + Math.cos(25139) * 15;
+acc += Math.sin(25139) + Math.cos(25140) * 16;
+acc += Math.sin(25140) + Math.cos(25141) * 17;
+acc += Math.sin(25141) + Math.cos(25142) * 18;
+acc += Math.sin(25142) + Math.cos(25143) * 19;
+acc += Math.sin(25143) + Math.cos(25144) * 20;
+acc += Math.sin(25144) + Math.cos(25145) * 21;
+acc += Math.sin(25145) + Math.cos(25146) * 22;
+acc += Math.sin(25146) + Math.cos(25147) * 23;
+acc += Math.sin(25147) + Math.cos(25148) * 24;
+acc += Math.sin(25148) + Math.cos(25149) * 25;
+acc += Math.sin(25149) + Math.cos(25150) * 26;
+acc += Math.sin(25150) + Math.cos(25151) * 27;
+acc += Math.sin(25151) + Math.cos(25152) * 28;
+acc += Math.sin(25152) + Math.cos(25153) * 29;
+acc += Math.sin(25153) + Math.cos(25154) * 30;
+acc += Math.sin(25154) + Math.cos(25155) * 31;
+acc += Math.sin(25155) + Math.cos(25156) * 32;
+acc += Math.sin(25156) + Math.cos(25157) * 33;
+acc += Math.sin(25157) + Math.cos(25158) * 34;
+acc += Math.sin(25158) + Math.cos(25159) * 35;
+acc += Math.sin(25159) + Math.cos(25160) * 36;
+acc += Math.sin(25160) + Math.cos(25161) * 37;
+acc += Math.sin(25161) + Math.cos(25162) * 38;
+acc += Math.sin(25162) + Math.cos(25163) * 39;
+acc += Math.sin(25163) + Math.cos(25164) * 40;
+acc += Math.sin(25164) + Math.cos(25165) * 41;
+acc += Math.sin(25165) + Math.cos(25166) * 42;
+acc += Math.sin(25166) + Math.cos(25167) * 43;
+acc += Math.sin(25167) + Math.cos(25168) * 44;
+acc += Math.sin(25168) + Math.cos(25169) * 45;
+acc += Math.sin(25169) + Math.cos(25170) * 46;
+acc += Math.sin(25170) + Math.cos(25171) * 47;
+acc += Math.sin(25171) + Math.cos(25172) * 48;
+acc += Math.sin(25172) + Math.cos(25173) * 49;
+acc += Math.sin(25173) + Math.cos(25174) * 50;
+acc += Math.sin(25174) + Math.cos(25175) * 51;
+acc += Math.sin(25175) + Math.cos(25176) * 52;
+acc += Math.sin(25176) + Math.cos(25177) * 53;
+acc += Math.sin(25177) + Math.cos(25178) * 54;
+acc += Math.sin(25178) + Math.cos(25179) * 55;
+acc += Math.sin(25179) + Math.cos(25180) * 56;
+acc += Math.sin(25180) + Math.cos(25181) * 57;
+acc += Math.sin(25181) + Math.cos(25182) * 58;
+acc += Math.sin(25182) + Math.cos(25183) * 59;
+acc += Math.sin(25183) + Math.cos(25184) * 60;
+acc += Math.sin(25184) + Math.cos(25185) * 61;
+acc += Math.sin(25185) + Math.cos(25186) * 62;
+acc += Math.sin(25186) + Math.cos(25187) * 63;
+acc += Math.sin(25187) + Math.cos(25188) * 64;
+acc += Math.sin(25188) + Math.cos(25189) * 65;
+acc += Math.sin(25189) + Math.cos(25190) * 66;
+acc += Math.sin(25190) + Math.cos(25191) * 67;
+acc += Math.sin(25191) + Math.cos(25192) * 68;
+acc += Math.sin(25192) + Math.cos(25193) * 69;
+acc += Math.sin(25193) + Math.cos(25194) * 70;
+acc += Math.sin(25194) + Math.cos(25195) * 71;
+acc += Math.sin(25195) + Math.cos(25196) * 72;
+acc += Math.sin(25196) + Math.cos(25197) * 73;
+acc += Math.sin(25197) + Math.cos(25198) * 74;
+acc += Math.sin(25198) + Math.cos(25199) * 75;
+acc += Math.sin(25199) + Math.cos(25200) * 76;
+acc += Math.sin(25200) + Math.cos(25201) * 77;
+acc += Math.sin(25201) + Math.cos(25202) * 78;
+acc += Math.sin(25202) + Math.cos(25203) * 79;
+acc += Math.sin(25203) + Math.cos(25204) * 80;
+acc += Math.sin(25204) + Math.cos(25205) * 81;
+acc += Math.sin(25205) + Math.cos(25206) * 82;
+acc += Math.sin(25206) + Math.cos(25207) * 83;
+acc += Math.sin(25207) + Math.cos(25208) * 84;
+acc += Math.sin(25208) + Math.cos(25209) * 85;
+acc += Math.sin(25209) + Math.cos(25210) * 86;
+acc += Math.sin(25210) + Math.cos(25211) * 87;
+acc += Math.sin(25211) + Math.cos(25212) * 88;
+acc += Math.sin(25212) + Math.cos(25213) * 89;
+acc += Math.sin(25213) + Math.cos(25214) * 90;
+acc += Math.sin(25214) + Math.cos(25215) * 91;
+acc += Math.sin(25215) + Math.cos(25216) * 92;
+acc += Math.sin(25216) + Math.cos(25217) * 93;
+acc += Math.sin(25217) + Math.cos(25218) * 94;
+acc += Math.sin(25218) + Math.cos(25219) * 95;
+acc += Math.sin(25219) + Math.cos(25220) * 96;
+acc += Math.sin(25220) + Math.cos(25221) * 0;
+acc += Math.sin(25221) + Math.cos(25222) * 1;
+acc += Math.sin(25222) + Math.cos(25223) * 2;
+acc += Math.sin(25223) + Math.cos(25224) * 3;
+acc += Math.sin(25224) + Math.cos(25225) * 4;
+acc += Math.sin(25225) + Math.cos(25226) * 5;
+acc += Math.sin(25226) + Math.cos(25227) * 6;
+acc += Math.sin(25227) + Math.cos(25228) * 7;
+acc += Math.sin(25228) + Math.cos(25229) * 8;
+acc += Math.sin(25229) + Math.cos(25230) * 9;
+acc += Math.sin(25230) + Math.cos(25231) * 10;
+acc += Math.sin(25231) + Math.cos(25232) * 11;
+acc += Math.sin(25232) + Math.cos(25233) * 12;
+acc += Math.sin(25233) + Math.cos(25234) * 13;
+acc += Math.sin(25234) + Math.cos(25235) * 14;
+acc += Math.sin(25235) + Math.cos(25236) * 15;
+acc += Math.sin(25236) + Math.cos(25237) * 16;
+acc += Math.sin(25237) + Math.cos(25238) * 17;
+acc += Math.sin(25238) + Math.cos(25239) * 18;
+acc += Math.sin(25239) + Math.cos(25240) * 19;
+acc += Math.sin(25240) + Math.cos(25241) * 20;
+acc += Math.sin(25241) + Math.cos(25242) * 21;
+acc += Math.sin(25242) + Math.cos(25243) * 22;
+acc += Math.sin(25243) + Math.cos(25244) * 23;
+acc += Math.sin(25244) + Math.cos(25245) * 24;
+acc += Math.sin(25245) + Math.cos(25246) * 25;
+acc += Math.sin(25246) + Math.cos(25247) * 26;
+acc += Math.sin(25247) + Math.cos(25248) * 27;
+acc += Math.sin(25248) + Math.cos(25249) * 28;
+acc += Math.sin(25249) + Math.cos(25250) * 29;
+acc += Math.sin(25250) + Math.cos(25251) * 30;
+acc += Math.sin(25251) + Math.cos(25252) * 31;
+acc += Math.sin(25252) + Math.cos(25253) * 32;
+acc += Math.sin(25253) + Math.cos(25254) * 33;
+acc += Math.sin(25254) + Math.cos(25255) * 34;
+acc += Math.sin(25255) + Math.cos(25256) * 35;
+acc += Math.sin(25256) + Math.cos(25257) * 36;
+acc += Math.sin(25257) + Math.cos(25258) * 37;
+acc += Math.sin(25258) + Math.cos(25259) * 38;
+acc += Math.sin(25259) + Math.cos(25260) * 39;
+acc += Math.sin(25260) + Math.cos(25261) * 40;
+acc += Math.sin(25261) + Math.cos(25262) * 41;
+acc += Math.sin(25262) + Math.cos(25263) * 42;
+acc += Math.sin(25263) + Math.cos(25264) * 43;
+acc += Math.sin(25264) + Math.cos(25265) * 44;
+acc += Math.sin(25265) + Math.cos(25266) * 45;
+acc += Math.sin(25266) + Math.cos(25267) * 46;
+acc += Math.sin(25267) + Math.cos(25268) * 47;
+acc += Math.sin(25268) + Math.cos(25269) * 48;
+acc += Math.sin(25269) + Math.cos(25270) * 49;
+acc += Math.sin(25270) + Math.cos(25271) * 50;
+acc += Math.sin(25271) + Math.cos(25272) * 51;
+acc += Math.sin(25272) + Math.cos(25273) * 52;
+acc += Math.sin(25273) + Math.cos(25274) * 53;
+acc += Math.sin(25274) + Math.cos(25275) * 54;
+acc += Math.sin(25275) + Math.cos(25276) * 55;
+acc += Math.sin(25276) + Math.cos(25277) * 56;
+acc += Math.sin(25277) + Math.cos(25278) * 57;
+acc += Math.sin(25278) + Math.cos(25279) * 58;
+acc += Math.sin(25279) + Math.cos(25280) * 59;
+acc += Math.sin(25280) + Math.cos(25281) * 60;
+acc += Math.sin(25281) + Math.cos(25282) * 61;
+acc += Math.sin(25282) + Math.cos(25283) * 62;
+acc += Math.sin(25283) + Math.cos(25284) * 63;
+acc += Math.sin(25284) + Math.cos(25285) * 64;
+acc += Math.sin(25285) + Math.cos(25286) * 65;
+acc += Math.sin(25286) + Math.cos(25287) * 66;
+acc += Math.sin(25287) + Math.cos(25288) * 67;
+acc += Math.sin(25288) + Math.cos(25289) * 68;
+acc += Math.sin(25289) + Math.cos(25290) * 69;
+acc += Math.sin(25290) + Math.cos(25291) * 70;
+acc += Math.sin(25291) + Math.cos(25292) * 71;
+acc += Math.sin(25292) + Math.cos(25293) * 72;
+acc += Math.sin(25293) + Math.cos(25294) * 73;
+acc += Math.sin(25294) + Math.cos(25295) * 74;
+acc += Math.sin(25295) + Math.cos(25296) * 75;
+acc += Math.sin(25296) + Math.cos(25297) * 76;
+acc += Math.sin(25297) + Math.cos(25298) * 77;
+acc += Math.sin(25298) + Math.cos(25299) * 78;
+acc += Math.sin(25299) + Math.cos(25300) * 79;
+acc += Math.sin(25300) + Math.cos(25301) * 80;
+acc += Math.sin(25301) + Math.cos(25302) * 81;
+acc += Math.sin(25302) + Math.cos(25303) * 82;
+acc += Math.sin(25303) + Math.cos(25304) * 83;
+acc += Math.sin(25304) + Math.cos(25305) * 84;
+acc += Math.sin(25305) + Math.cos(25306) * 85;
+acc += Math.sin(25306) + Math.cos(25307) * 86;
+acc += Math.sin(25307) + Math.cos(25308) * 87;
+acc += Math.sin(25308) + Math.cos(25309) * 88;
+acc += Math.sin(25309) + Math.cos(25310) * 89;
+acc += Math.sin(25310) + Math.cos(25311) * 90;
+acc += Math.sin(25311) + Math.cos(25312) * 91;
+acc += Math.sin(25312) + Math.cos(25313) * 92;
+acc += Math.sin(25313) + Math.cos(25314) * 93;
+acc += Math.sin(25314) + Math.cos(25315) * 94;
+acc += Math.sin(25315) + Math.cos(25316) * 95;
+acc += Math.sin(25316) + Math.cos(25317) * 96;
+acc += Math.sin(25317) + Math.cos(25318) * 0;
+acc += Math.sin(25318) + Math.cos(25319) * 1;
+acc += Math.sin(25319) + Math.cos(25320) * 2;
+acc += Math.sin(25320) + Math.cos(25321) * 3;
+acc += Math.sin(25321) + Math.cos(25322) * 4;
+acc += Math.sin(25322) + Math.cos(25323) * 5;
+acc += Math.sin(25323) + Math.cos(25324) * 6;
+acc += Math.sin(25324) + Math.cos(25325) * 7;
+acc += Math.sin(25325) + Math.cos(25326) * 8;
+acc += Math.sin(25326) + Math.cos(25327) * 9;
+acc += Math.sin(25327) + Math.cos(25328) * 10;
+acc += Math.sin(25328) + Math.cos(25329) * 11;
+acc += Math.sin(25329) + Math.cos(25330) * 12;
+acc += Math.sin(25330) + Math.cos(25331) * 13;
+acc += Math.sin(25331) + Math.cos(25332) * 14;
+acc += Math.sin(25332) + Math.cos(25333) * 15;
+acc += Math.sin(25333) + Math.cos(25334) * 16;
+acc += Math.sin(25334) + Math.cos(25335) * 17;
+acc += Math.sin(25335) + Math.cos(25336) * 18;
+acc += Math.sin(25336) + Math.cos(25337) * 19;
+acc += Math.sin(25337) + Math.cos(25338) * 20;
+acc += Math.sin(25338) + Math.cos(25339) * 21;
+acc += Math.sin(25339) + Math.cos(25340) * 22;
+acc += Math.sin(25340) + Math.cos(25341) * 23;
+acc += Math.sin(25341) + Math.cos(25342) * 24;
+acc += Math.sin(25342) + Math.cos(25343) * 25;
+acc += Math.sin(25343) + Math.cos(25344) * 26;
+acc += Math.sin(25344) + Math.cos(25345) * 27;
+acc += Math.sin(25345) + Math.cos(25346) * 28;
+acc += Math.sin(25346) + Math.cos(25347) * 29;
+acc += Math.sin(25347) + Math.cos(25348) * 30;
+acc += Math.sin(25348) + Math.cos(25349) * 31;
+acc += Math.sin(25349) + Math.cos(25350) * 32;
+acc += Math.sin(25350) + Math.cos(25351) * 33;
+acc += Math.sin(25351) + Math.cos(25352) * 34;
+acc += Math.sin(25352) + Math.cos(25353) * 35;
+acc += Math.sin(25353) + Math.cos(25354) * 36;
+acc += Math.sin(25354) + Math.cos(25355) * 37;
+acc += Math.sin(25355) + Math.cos(25356) * 38;
+acc += Math.sin(25356) + Math.cos(25357) * 39;
+acc += Math.sin(25357) + Math.cos(25358) * 40;
+acc += Math.sin(25358) + Math.cos(25359) * 41;
+acc += Math.sin(25359) + Math.cos(25360) * 42;
+acc += Math.sin(25360) + Math.cos(25361) * 43;
+acc += Math.sin(25361) + Math.cos(25362) * 44;
+acc += Math.sin(25362) + Math.cos(25363) * 45;
+acc += Math.sin(25363) + Math.cos(25364) * 46;
+acc += Math.sin(25364) + Math.cos(25365) * 47;
+acc += Math.sin(25365) + Math.cos(25366) * 48;
+acc += Math.sin(25366) + Math.cos(25367) * 49;
+acc += Math.sin(25367) + Math.cos(25368) * 50;
+acc += Math.sin(25368) + Math.cos(25369) * 51;
+acc += Math.sin(25369) + Math.cos(25370) * 52;
+acc += Math.sin(25370) + Math.cos(25371) * 53;
+acc += Math.sin(25371) + Math.cos(25372) * 54;
+acc += Math.sin(25372) + Math.cos(25373) * 55;
+acc += Math.sin(25373) + Math.cos(25374) * 56;
+acc += Math.sin(25374) + Math.cos(25375) * 57;
+acc += Math.sin(25375) + Math.cos(25376) * 58;
+acc += Math.sin(25376) + Math.cos(25377) * 59;
+acc += Math.sin(25377) + Math.cos(25378) * 60;
+acc += Math.sin(25378) + Math.cos(25379) * 61;
+acc += Math.sin(25379) + Math.cos(25380) * 62;
+acc += Math.sin(25380) + Math.cos(25381) * 63;
+acc += Math.sin(25381) + Math.cos(25382) * 64;
+acc += Math.sin(25382) + Math.cos(25383) * 65;
+acc += Math.sin(25383) + Math.cos(25384) * 66;
+acc += Math.sin(25384) + Math.cos(25385) * 67;
+acc += Math.sin(25385) + Math.cos(25386) * 68;
+acc += Math.sin(25386) + Math.cos(25387) * 69;
+acc += Math.sin(25387) + Math.cos(25388) * 70;
+acc += Math.sin(25388) + Math.cos(25389) * 71;
+acc += Math.sin(25389) + Math.cos(25390) * 72;
+acc += Math.sin(25390) + Math.cos(25391) * 73;
+acc += Math.sin(25391) + Math.cos(25392) * 74;
+acc += Math.sin(25392) + Math.cos(25393) * 75;
+acc += Math.sin(25393) + Math.cos(25394) * 76;
+acc += Math.sin(25394) + Math.cos(25395) * 77;
+acc += Math.sin(25395) + Math.cos(25396) * 78;
+acc += Math.sin(25396) + Math.cos(25397) * 79;
+acc += Math.sin(25397) + Math.cos(25398) * 80;
+acc += Math.sin(25398) + Math.cos(25399) * 81;
+acc += Math.sin(25399) + Math.cos(25400) * 82;
+acc += Math.sin(25400) + Math.cos(25401) * 83;
+acc += Math.sin(25401) + Math.cos(25402) * 84;
+acc += Math.sin(25402) + Math.cos(25403) * 85;
+acc += Math.sin(25403) + Math.cos(25404) * 86;
+acc += Math.sin(25404) + Math.cos(25405) * 87;
+acc += Math.sin(25405) + Math.cos(25406) * 88;
+acc += Math.sin(25406) + Math.cos(25407) * 89;
+acc += Math.sin(25407) + Math.cos(25408) * 90;
+acc += Math.sin(25408) + Math.cos(25409) * 91;
+acc += Math.sin(25409) + Math.cos(25410) * 92;
+acc += Math.sin(25410) + Math.cos(25411) * 93;
+acc += Math.sin(25411) + Math.cos(25412) * 94;
+acc += Math.sin(25412) + Math.cos(25413) * 95;
+acc += Math.sin(25413) + Math.cos(25414) * 96;
+acc += Math.sin(25414) + Math.cos(25415) * 0;
+acc += Math.sin(25415) + Math.cos(25416) * 1;
+acc += Math.sin(25416) + Math.cos(25417) * 2;
+acc += Math.sin(25417) + Math.cos(25418) * 3;
+acc += Math.sin(25418) + Math.cos(25419) * 4;
+acc += Math.sin(25419) + Math.cos(25420) * 5;
+acc += Math.sin(25420) + Math.cos(25421) * 6;
+acc += Math.sin(25421) + Math.cos(25422) * 7;
+acc += Math.sin(25422) + Math.cos(25423) * 8;
+acc += Math.sin(25423) + Math.cos(25424) * 9;
+acc += Math.sin(25424) + Math.cos(25425) * 10;
+acc += Math.sin(25425) + Math.cos(25426) * 11;
+acc += Math.sin(25426) + Math.cos(25427) * 12;
+acc += Math.sin(25427) + Math.cos(25428) * 13;
+acc += Math.sin(25428) + Math.cos(25429) * 14;
+acc += Math.sin(25429) + Math.cos(25430) * 15;
+acc += Math.sin(25430) + Math.cos(25431) * 16;
+acc += Math.sin(25431) + Math.cos(25432) * 17;
+acc += Math.sin(25432) + Math.cos(25433) * 18;
+acc += Math.sin(25433) + Math.cos(25434) * 19;
+acc += Math.sin(25434) + Math.cos(25435) * 20;
+acc += Math.sin(25435) + Math.cos(25436) * 21;
+acc += Math.sin(25436) + Math.cos(25437) * 22;
+acc += Math.sin(25437) + Math.cos(25438) * 23;
+acc += Math.sin(25438) + Math.cos(25439) * 24;
+acc += Math.sin(25439) + Math.cos(25440) * 25;
+acc += Math.sin(25440) + Math.cos(25441) * 26;
+acc += Math.sin(25441) + Math.cos(25442) * 27;
+acc += Math.sin(25442) + Math.cos(25443) * 28;
+acc += Math.sin(25443) + Math.cos(25444) * 29;
+acc += Math.sin(25444) + Math.cos(25445) * 30;
+acc += Math.sin(25445) + Math.cos(25446) * 31;
+acc += Math.sin(25446) + Math.cos(25447) * 32;
+acc += Math.sin(25447) + Math.cos(25448) * 33;
+acc += Math.sin(25448) + Math.cos(25449) * 34;
+acc += Math.sin(25449) + Math.cos(25450) * 35;
+acc += Math.sin(25450) + Math.cos(25451) * 36;
+acc += Math.sin(25451) + Math.cos(25452) * 37;
+acc += Math.sin(25452) + Math.cos(25453) * 38;
+acc += Math.sin(25453) + Math.cos(25454) * 39;
+acc += Math.sin(25454) + Math.cos(25455) * 40;
+acc += Math.sin(25455) + Math.cos(25456) * 41;
+acc += Math.sin(25456) + Math.cos(25457) * 42;
+acc += Math.sin(25457) + Math.cos(25458) * 43;
+acc += Math.sin(25458) + Math.cos(25459) * 44;
+acc += Math.sin(25459) + Math.cos(25460) * 45;
+acc += Math.sin(25460) + Math.cos(25461) * 46;
+acc += Math.sin(25461) + Math.cos(25462) * 47;
+acc += Math.sin(25462) + Math.cos(25463) * 48;
+acc += Math.sin(25463) + Math.cos(25464) * 49;
+acc += Math.sin(25464) + Math.cos(25465) * 50;
+acc += Math.sin(25465) + Math.cos(25466) * 51;
+acc += Math.sin(25466) + Math.cos(25467) * 52;
+acc += Math.sin(25467) + Math.cos(25468) * 53;
+acc += Math.sin(25468) + Math.cos(25469) * 54;
+acc += Math.sin(25469) + Math.cos(25470) * 55;
+acc += Math.sin(25470) + Math.cos(25471) * 56;
+acc += Math.sin(25471) + Math.cos(25472) * 57;
+acc += Math.sin(25472) + Math.cos(25473) * 58;
+acc += Math.sin(25473) + Math.cos(25474) * 59;
+acc += Math.sin(25474) + Math.cos(25475) * 60;
+acc += Math.sin(25475) + Math.cos(25476) * 61;
+acc += Math.sin(25476) + Math.cos(25477) * 62;
+acc += Math.sin(25477) + Math.cos(25478) * 63;
+acc += Math.sin(25478) + Math.cos(25479) * 64;
+acc += Math.sin(25479) + Math.cos(25480) * 65;
+acc += Math.sin(25480) + Math.cos(25481) * 66;
+acc += Math.sin(25481) + Math.cos(25482) * 67;
+acc += Math.sin(25482) + Math.cos(25483) * 68;
+acc += Math.sin(25483) + Math.cos(25484) * 69;
+acc += Math.sin(25484) + Math.cos(25485) * 70;
+acc += Math.sin(25485) + Math.cos(25486) * 71;
+acc += Math.sin(25486) + Math.cos(25487) * 72;
+acc += Math.sin(25487) + Math.cos(25488) * 73;
+acc += Math.sin(25488) + Math.cos(25489) * 74;
+acc += Math.sin(25489) + Math.cos(25490) * 75;
+acc += Math.sin(25490) + Math.cos(25491) * 76;
+acc += Math.sin(25491) + Math.cos(25492) * 77;
+acc += Math.sin(25492) + Math.cos(25493) * 78;
+acc += Math.sin(25493) + Math.cos(25494) * 79;
+acc += Math.sin(25494) + Math.cos(25495) * 80;
+acc += Math.sin(25495) + Math.cos(25496) * 81;
+acc += Math.sin(25496) + Math.cos(25497) * 82;
+acc += Math.sin(25497) + Math.cos(25498) * 83;
+acc += Math.sin(25498) + Math.cos(25499) * 84;
+acc += Math.sin(25499) + Math.cos(25500) * 85;
+acc += Math.sin(25500) + Math.cos(25501) * 86;
+acc += Math.sin(25501) + Math.cos(25502) * 87;
+acc += Math.sin(25502) + Math.cos(25503) * 88;
+acc += Math.sin(25503) + Math.cos(25504) * 89;
+acc += Math.sin(25504) + Math.cos(25505) * 90;
+acc += Math.sin(25505) + Math.cos(25506) * 91;
+acc += Math.sin(25506) + Math.cos(25507) * 92;
+acc += Math.sin(25507) + Math.cos(25508) * 93;
+acc += Math.sin(25508) + Math.cos(25509) * 94;
+acc += Math.sin(25509) + Math.cos(25510) * 95;
+acc += Math.sin(25510) + Math.cos(25511) * 96;
+acc += Math.sin(25511) + Math.cos(25512) * 0;
+acc += Math.sin(25512) + Math.cos(25513) * 1;
+acc += Math.sin(25513) + Math.cos(25514) * 2;
+acc += Math.sin(25514) + Math.cos(25515) * 3;
+acc += Math.sin(25515) + Math.cos(25516) * 4;
+acc += Math.sin(25516) + Math.cos(25517) * 5;
+acc += Math.sin(25517) + Math.cos(25518) * 6;
+acc += Math.sin(25518) + Math.cos(25519) * 7;
+acc += Math.sin(25519) + Math.cos(25520) * 8;
+acc += Math.sin(25520) + Math.cos(25521) * 9;
+acc += Math.sin(25521) + Math.cos(25522) * 10;
+acc += Math.sin(25522) + Math.cos(25523) * 11;
+acc += Math.sin(25523) + Math.cos(25524) * 12;
+acc += Math.sin(25524) + Math.cos(25525) * 13;
+acc += Math.sin(25525) + Math.cos(25526) * 14;
+acc += Math.sin(25526) + Math.cos(25527) * 15;
+acc += Math.sin(25527) + Math.cos(25528) * 16;
+acc += Math.sin(25528) + Math.cos(25529) * 17;
+acc += Math.sin(25529) + Math.cos(25530) * 18;
+acc += Math.sin(25530) + Math.cos(25531) * 19;
+acc += Math.sin(25531) + Math.cos(25532) * 20;
+acc += Math.sin(25532) + Math.cos(25533) * 21;
+acc += Math.sin(25533) + Math.cos(25534) * 22;
+acc += Math.sin(25534) + Math.cos(25535) * 23;
+acc += Math.sin(25535) + Math.cos(25536) * 24;
+acc += Math.sin(25536) + Math.cos(25537) * 25;
+acc += Math.sin(25537) + Math.cos(25538) * 26;
+acc += Math.sin(25538) + Math.cos(25539) * 27;
+acc += Math.sin(25539) + Math.cos(25540) * 28;
+acc += Math.sin(25540) + Math.cos(25541) * 29;
+acc += Math.sin(25541) + Math.cos(25542) * 30;
+acc += Math.sin(25542) + Math.cos(25543) * 31;
+acc += Math.sin(25543) + Math.cos(25544) * 32;
+acc += Math.sin(25544) + Math.cos(25545) * 33;
+acc += Math.sin(25545) + Math.cos(25546) * 34;
+acc += Math.sin(25546) + Math.cos(25547) * 35;
+acc += Math.sin(25547) + Math.cos(25548) * 36;
+acc += Math.sin(25548) + Math.cos(25549) * 37;
+acc += Math.sin(25549) + Math.cos(25550) * 38;
+acc += Math.sin(25550) + Math.cos(25551) * 39;
+acc += Math.sin(25551) + Math.cos(25552) * 40;
+acc += Math.sin(25552) + Math.cos(25553) * 41;
+acc += Math.sin(25553) + Math.cos(25554) * 42;
+acc += Math.sin(25554) + Math.cos(25555) * 43;
+acc += Math.sin(25555) + Math.cos(25556) * 44;
+acc += Math.sin(25556) + Math.cos(25557) * 45;
+acc += Math.sin(25557) + Math.cos(25558) * 46;
+acc += Math.sin(25558) + Math.cos(25559) * 47;
+acc += Math.sin(25559) + Math.cos(25560) * 48;
+acc += Math.sin(25560) + Math.cos(25561) * 49;
+acc += Math.sin(25561) + Math.cos(25562) * 50;
+acc += Math.sin(25562) + Math.cos(25563) * 51;
+acc += Math.sin(25563) + Math.cos(25564) * 52;
+acc += Math.sin(25564) + Math.cos(25565) * 53;
+acc += Math.sin(25565) + Math.cos(25566) * 54;
+acc += Math.sin(25566) + Math.cos(25567) * 55;
+acc += Math.sin(25567) + Math.cos(25568) * 56;
+acc += Math.sin(25568) + Math.cos(25569) * 57;
+acc += Math.sin(25569) + Math.cos(25570) * 58;
+acc += Math.sin(25570) + Math.cos(25571) * 59;
+acc += Math.sin(25571) + Math.cos(25572) * 60;
+acc += Math.sin(25572) + Math.cos(25573) * 61;
+acc += Math.sin(25573) + Math.cos(25574) * 62;
+acc += Math.sin(25574) + Math.cos(25575) * 63;
+acc += Math.sin(25575) + Math.cos(25576) * 64;
+acc += Math.sin(25576) + Math.cos(25577) * 65;
+acc += Math.sin(25577) + Math.cos(25578) * 66;
+acc += Math.sin(25578) + Math.cos(25579) * 67;
+acc += Math.sin(25579) + Math.cos(25580) * 68;
+acc += Math.sin(25580) + Math.cos(25581) * 69;
+acc += Math.sin(25581) + Math.cos(25582) * 70;
+acc += Math.sin(25582) + Math.cos(25583) * 71;
+acc += Math.sin(25583) + Math.cos(25584) * 72;
+acc += Math.sin(25584) + Math.cos(25585) * 73;
+acc += Math.sin(25585) + Math.cos(25586) * 74;
+acc += Math.sin(25586) + Math.cos(25587) * 75;
+acc += Math.sin(25587) + Math.cos(25588) * 76;
+acc += Math.sin(25588) + Math.cos(25589) * 77;
+acc += Math.sin(25589) + Math.cos(25590) * 78;
+acc += Math.sin(25590) + Math.cos(25591) * 79;
+acc += Math.sin(25591) + Math.cos(25592) * 80;
+acc += Math.sin(25592) + Math.cos(25593) * 81;
+acc += Math.sin(25593) + Math.cos(25594) * 82;
+acc += Math.sin(25594) + Math.cos(25595) * 83;
+acc += Math.sin(25595) + Math.cos(25596) * 84;
+acc += Math.sin(25596) + Math.cos(25597) * 85;
+acc += Math.sin(25597) + Math.cos(25598) * 86;
+acc += Math.sin(25598) + Math.cos(25599) * 87;
+acc += Math.sin(25599) + Math.cos(25600) * 88;
+acc += Math.sin(25600) + Math.cos(25601) * 89;
+acc += Math.sin(25601) + Math.cos(25602) * 90;
+acc += Math.sin(25602) + Math.cos(25603) * 91;
+acc += Math.sin(25603) + Math.cos(25604) * 92;
+acc += Math.sin(25604) + Math.cos(25605) * 93;
+acc += Math.sin(25605) + Math.cos(25606) * 94;
+acc += Math.sin(25606) + Math.cos(25607) * 95;
+acc += Math.sin(25607) + Math.cos(25608) * 96;
+acc += Math.sin(25608) + Math.cos(25609) * 0;
+acc += Math.sin(25609) + Math.cos(25610) * 1;
+acc += Math.sin(25610) + Math.cos(25611) * 2;
+acc += Math.sin(25611) + Math.cos(25612) * 3;
+acc += Math.sin(25612) + Math.cos(25613) * 4;
+acc += Math.sin(25613) + Math.cos(25614) * 5;
+acc += Math.sin(25614) + Math.cos(25615) * 6;
+acc += Math.sin(25615) + Math.cos(25616) * 7;
+acc += Math.sin(25616) + Math.cos(25617) * 8;
+acc += Math.sin(25617) + Math.cos(25618) * 9;
+acc += Math.sin(25618) + Math.cos(25619) * 10;
+acc += Math.sin(25619) + Math.cos(25620) * 11;
+acc += Math.sin(25620) + Math.cos(25621) * 12;
+acc += Math.sin(25621) + Math.cos(25622) * 13;
+acc += Math.sin(25622) + Math.cos(25623) * 14;
+acc += Math.sin(25623) + Math.cos(25624) * 15;
+acc += Math.sin(25624) + Math.cos(25625) * 16;
+acc += Math.sin(25625) + Math.cos(25626) * 17;
+acc += Math.sin(25626) + Math.cos(25627) * 18;
+acc += Math.sin(25627) + Math.cos(25628) * 19;
+acc += Math.sin(25628) + Math.cos(25629) * 20;
+acc += Math.sin(25629) + Math.cos(25630) * 21;
+acc += Math.sin(25630) + Math.cos(25631) * 22;
+acc += Math.sin(25631) + Math.cos(25632) * 23;
+acc += Math.sin(25632) + Math.cos(25633) * 24;
+acc += Math.sin(25633) + Math.cos(25634) * 25;
+acc += Math.sin(25634) + Math.cos(25635) * 26;
+acc += Math.sin(25635) + Math.cos(25636) * 27;
+acc += Math.sin(25636) + Math.cos(25637) * 28;
+acc += Math.sin(25637) + Math.cos(25638) * 29;
+acc += Math.sin(25638) + Math.cos(25639) * 30;
+acc += Math.sin(25639) + Math.cos(25640) * 31;
+acc += Math.sin(25640) + Math.cos(25641) * 32;
+acc += Math.sin(25641) + Math.cos(25642) * 33;
+acc += Math.sin(25642) + Math.cos(25643) * 34;
+acc += Math.sin(25643) + Math.cos(25644) * 35;
+acc += Math.sin(25644) + Math.cos(25645) * 36;
+acc += Math.sin(25645) + Math.cos(25646) * 37;
+acc += Math.sin(25646) + Math.cos(25647) * 38;
+acc += Math.sin(25647) + Math.cos(25648) * 39;
+acc += Math.sin(25648) + Math.cos(25649) * 40;
+acc += Math.sin(25649) + Math.cos(25650) * 41;
+acc += Math.sin(25650) + Math.cos(25651) * 42;
+acc += Math.sin(25651) + Math.cos(25652) * 43;
+acc += Math.sin(25652) + Math.cos(25653) * 44;
+acc += Math.sin(25653) + Math.cos(25654) * 45;
+acc += Math.sin(25654) + Math.cos(25655) * 46;
+acc += Math.sin(25655) + Math.cos(25656) * 47;
+acc += Math.sin(25656) + Math.cos(25657) * 48;
+acc += Math.sin(25657) + Math.cos(25658) * 49;
+acc += Math.sin(25658) + Math.cos(25659) * 50;
+acc += Math.sin(25659) + Math.cos(25660) * 51;
+acc += Math.sin(25660) + Math.cos(25661) * 52;
+acc += Math.sin(25661) + Math.cos(25662) * 53;
+acc += Math.sin(25662) + Math.cos(25663) * 54;
+acc += Math.sin(25663) + Math.cos(25664) * 55;
+acc += Math.sin(25664) + Math.cos(25665) * 56;
+acc += Math.sin(25665) + Math.cos(25666) * 57;
+acc += Math.sin(25666) + Math.cos(25667) * 58;
+acc += Math.sin(25667) + Math.cos(25668) * 59;
+acc += Math.sin(25668) + Math.cos(25669) * 60;
+acc += Math.sin(25669) + Math.cos(25670) * 61;
+acc += Math.sin(25670) + Math.cos(25671) * 62;
+acc += Math.sin(25671) + Math.cos(25672) * 63;
+acc += Math.sin(25672) + Math.cos(25673) * 64;
+acc += Math.sin(25673) + Math.cos(25674) * 65;
+acc += Math.sin(25674) + Math.cos(25675) * 66;
+acc += Math.sin(25675) + Math.cos(25676) * 67;
+acc += Math.sin(25676) + Math.cos(25677) * 68;
+acc += Math.sin(25677) + Math.cos(25678) * 69;
+acc += Math.sin(25678) + Math.cos(25679) * 70;
+acc += Math.sin(25679) + Math.cos(25680) * 71;
+acc += Math.sin(25680) + Math.cos(25681) * 72;
+acc += Math.sin(25681) + Math.cos(25682) * 73;
+acc += Math.sin(25682) + Math.cos(25683) * 74;
+acc += Math.sin(25683) + Math.cos(25684) * 75;
+acc += Math.sin(25684) + Math.cos(25685) * 76;
+acc += Math.sin(25685) + Math.cos(25686) * 77;
+acc += Math.sin(25686) + Math.cos(25687) * 78;
+acc += Math.sin(25687) + Math.cos(25688) * 79;
+acc += Math.sin(25688) + Math.cos(25689) * 80;
+acc += Math.sin(25689) + Math.cos(25690) * 81;
+acc += Math.sin(25690) + Math.cos(25691) * 82;
+acc += Math.sin(25691) + Math.cos(25692) * 83;
+acc += Math.sin(25692) + Math.cos(25693) * 84;
+acc += Math.sin(25693) + Math.cos(25694) * 85;
+acc += Math.sin(25694) + Math.cos(25695) * 86;
+acc += Math.sin(25695) + Math.cos(25696) * 87;
+acc += Math.sin(25696) + Math.cos(25697) * 88;
+acc += Math.sin(25697) + Math.cos(25698) * 89;
+acc += Math.sin(25698) + Math.cos(25699) * 90;
+acc += Math.sin(25699) + Math.cos(25700) * 91;
+acc += Math.sin(25700) + Math.cos(25701) * 92;
+acc += Math.sin(25701) + Math.cos(25702) * 93;
+acc += Math.sin(25702) + Math.cos(25703) * 94;
+acc += Math.sin(25703) + Math.cos(25704) * 95;
+acc += Math.sin(25704) + Math.cos(25705) * 96;
+acc += Math.sin(25705) + Math.cos(25706) * 0;
+acc += Math.sin(25706) + Math.cos(25707) * 1;
+acc += Math.sin(25707) + Math.cos(25708) * 2;
+acc += Math.sin(25708) + Math.cos(25709) * 3;
+acc += Math.sin(25709) + Math.cos(25710) * 4;
+acc += Math.sin(25710) + Math.cos(25711) * 5;
+acc += Math.sin(25711) + Math.cos(25712) * 6;
+acc += Math.sin(25712) + Math.cos(25713) * 7;
+acc += Math.sin(25713) + Math.cos(25714) * 8;
+acc += Math.sin(25714) + Math.cos(25715) * 9;
+acc += Math.sin(25715) + Math.cos(25716) * 10;
+acc += Math.sin(25716) + Math.cos(25717) * 11;
+acc += Math.sin(25717) + Math.cos(25718) * 12;
+acc += Math.sin(25718) + Math.cos(25719) * 13;
+acc += Math.sin(25719) + Math.cos(25720) * 14;
+acc += Math.sin(25720) + Math.cos(25721) * 15;
+acc += Math.sin(25721) + Math.cos(25722) * 16;
+acc += Math.sin(25722) + Math.cos(25723) * 17;
+acc += Math.sin(25723) + Math.cos(25724) * 18;
+acc += Math.sin(25724) + Math.cos(25725) * 19;
+acc += Math.sin(25725) + Math.cos(25726) * 20;
+acc += Math.sin(25726) + Math.cos(25727) * 21;
+acc += Math.sin(25727) + Math.cos(25728) * 22;
+acc += Math.sin(25728) + Math.cos(25729) * 23;
+acc += Math.sin(25729) + Math.cos(25730) * 24;
+acc += Math.sin(25730) + Math.cos(25731) * 25;
+acc += Math.sin(25731) + Math.cos(25732) * 26;
+acc += Math.sin(25732) + Math.cos(25733) * 27;
+acc += Math.sin(25733) + Math.cos(25734) * 28;
+acc += Math.sin(25734) + Math.cos(25735) * 29;
+acc += Math.sin(25735) + Math.cos(25736) * 30;
+acc += Math.sin(25736) + Math.cos(25737) * 31;
+acc += Math.sin(25737) + Math.cos(25738) * 32;
+acc += Math.sin(25738) + Math.cos(25739) * 33;
+acc += Math.sin(25739) + Math.cos(25740) * 34;
+acc += Math.sin(25740) + Math.cos(25741) * 35;
+acc += Math.sin(25741) + Math.cos(25742) * 36;
+acc += Math.sin(25742) + Math.cos(25743) * 37;
+acc += Math.sin(25743) + Math.cos(25744) * 38;
+acc += Math.sin(25744) + Math.cos(25745) * 39;
+acc += Math.sin(25745) + Math.cos(25746) * 40;
+acc += Math.sin(25746) + Math.cos(25747) * 41;
+acc += Math.sin(25747) + Math.cos(25748) * 42;
+acc += Math.sin(25748) + Math.cos(25749) * 43;
+acc += Math.sin(25749) + Math.cos(25750) * 44;
+acc += Math.sin(25750) + Math.cos(25751) * 45;
+acc += Math.sin(25751) + Math.cos(25752) * 46;
+acc += Math.sin(25752) + Math.cos(25753) * 47;
+acc += Math.sin(25753) + Math.cos(25754) * 48;
+acc += Math.sin(25754) + Math.cos(25755) * 49;
+acc += Math.sin(25755) + Math.cos(25756) * 50;
+acc += Math.sin(25756) + Math.cos(25757) * 51;
+acc += Math.sin(25757) + Math.cos(25758) * 52;
+acc += Math.sin(25758) + Math.cos(25759) * 53;
+acc += Math.sin(25759) + Math.cos(25760) * 54;
+acc += Math.sin(25760) + Math.cos(25761) * 55;
+acc += Math.sin(25761) + Math.cos(25762) * 56;
+acc += Math.sin(25762) + Math.cos(25763) * 57;
+acc += Math.sin(25763) + Math.cos(25764) * 58;
+acc += Math.sin(25764) + Math.cos(25765) * 59;
+acc += Math.sin(25765) + Math.cos(25766) * 60;
+acc += Math.sin(25766) + Math.cos(25767) * 61;
+acc += Math.sin(25767) + Math.cos(25768) * 62;
+acc += Math.sin(25768) + Math.cos(25769) * 63;
+acc += Math.sin(25769) + Math.cos(25770) * 64;
+acc += Math.sin(25770) + Math.cos(25771) * 65;
+acc += Math.sin(25771) + Math.cos(25772) * 66;
+acc += Math.sin(25772) + Math.cos(25773) * 67;
+acc += Math.sin(25773) + Math.cos(25774) * 68;
+acc += Math.sin(25774) + Math.cos(25775) * 69;
+acc += Math.sin(25775) + Math.cos(25776) * 70;
+acc += Math.sin(25776) + Math.cos(25777) * 71;
+acc += Math.sin(25777) + Math.cos(25778) * 72;
+acc += Math.sin(25778) + Math.cos(25779) * 73;
+acc += Math.sin(25779) + Math.cos(25780) * 74;
+acc += Math.sin(25780) + Math.cos(25781) * 75;
+acc += Math.sin(25781) + Math.cos(25782) * 76;
+acc += Math.sin(25782) + Math.cos(25783) * 77;
+acc += Math.sin(25783) + Math.cos(25784) * 78;
+acc += Math.sin(25784) + Math.cos(25785) * 79;
+acc += Math.sin(25785) + Math.cos(25786) * 80;
+acc += Math.sin(25786) + Math.cos(25787) * 81;
+acc += Math.sin(25787) + Math.cos(25788) * 82;
+acc += Math.sin(25788) + Math.cos(25789) * 83;
+acc += Math.sin(25789) + Math.cos(25790) * 84;
+acc += Math.sin(25790) + Math.cos(25791) * 85;
+acc += Math.sin(25791) + Math.cos(25792) * 86;
+acc += Math.sin(25792) + Math.cos(25793) * 87;
+acc += Math.sin(25793) + Math.cos(25794) * 88;
+acc += Math.sin(25794) + Math.cos(25795) * 89;
+acc += Math.sin(25795) + Math.cos(25796) * 90;
+acc += Math.sin(25796) + Math.cos(25797) * 91;
+acc += Math.sin(25797) + Math.cos(25798) * 92;
+acc += Math.sin(25798) + Math.cos(25799) * 93;
+acc += Math.sin(25799) + Math.cos(25800) * 94;
+acc += Math.sin(25800) + Math.cos(25801) * 95;
+acc += Math.sin(25801) + Math.cos(25802) * 96;
+acc += Math.sin(25802) + Math.cos(25803) * 0;
+acc += Math.sin(25803) + Math.cos(25804) * 1;
+acc += Math.sin(25804) + Math.cos(25805) * 2;
+acc += Math.sin(25805) + Math.cos(25806) * 3;
+acc += Math.sin(25806) + Math.cos(25807) * 4;
+acc += Math.sin(25807) + Math.cos(25808) * 5;
+acc += Math.sin(25808) + Math.cos(25809) * 6;
+acc += Math.sin(25809) + Math.cos(25810) * 7;
+acc += Math.sin(25810) + Math.cos(25811) * 8;
+acc += Math.sin(25811) + Math.cos(25812) * 9;
+acc += Math.sin(25812) + Math.cos(25813) * 10;
+acc += Math.sin(25813) + Math.cos(25814) * 11;
+acc += Math.sin(25814) + Math.cos(25815) * 12;
+acc += Math.sin(25815) + Math.cos(25816) * 13;
+acc += Math.sin(25816) + Math.cos(25817) * 14;
+acc += Math.sin(25817) + Math.cos(25818) * 15;
+acc += Math.sin(25818) + Math.cos(25819) * 16;
+acc += Math.sin(25819) + Math.cos(25820) * 17;
+acc += Math.sin(25820) + Math.cos(25821) * 18;
+acc += Math.sin(25821) + Math.cos(25822) * 19;
+acc += Math.sin(25822) + Math.cos(25823) * 20;
+acc += Math.sin(25823) + Math.cos(25824) * 21;
+acc += Math.sin(25824) + Math.cos(25825) * 22;
+acc += Math.sin(25825) + Math.cos(25826) * 23;
+acc += Math.sin(25826) + Math.cos(25827) * 24;
+acc += Math.sin(25827) + Math.cos(25828) * 25;
+acc += Math.sin(25828) + Math.cos(25829) * 26;
+acc += Math.sin(25829) + Math.cos(25830) * 27;
+acc += Math.sin(25830) + Math.cos(25831) * 28;
+acc += Math.sin(25831) + Math.cos(25832) * 29;
+acc += Math.sin(25832) + Math.cos(25833) * 30;
+acc += Math.sin(25833) + Math.cos(25834) * 31;
+acc += Math.sin(25834) + Math.cos(25835) * 32;
+acc += Math.sin(25835) + Math.cos(25836) * 33;
+acc += Math.sin(25836) + Math.cos(25837) * 34;
+acc += Math.sin(25837) + Math.cos(25838) * 35;
+acc += Math.sin(25838) + Math.cos(25839) * 36;
+acc += Math.sin(25839) + Math.cos(25840) * 37;
+acc += Math.sin(25840) + Math.cos(25841) * 38;
+acc += Math.sin(25841) + Math.cos(25842) * 39;
+acc += Math.sin(25842) + Math.cos(25843) * 40;
+acc += Math.sin(25843) + Math.cos(25844) * 41;
+acc += Math.sin(25844) + Math.cos(25845) * 42;
+acc += Math.sin(25845) + Math.cos(25846) * 43;
+acc += Math.sin(25846) + Math.cos(25847) * 44;
+acc += Math.sin(25847) + Math.cos(25848) * 45;
+acc += Math.sin(25848) + Math.cos(25849) * 46;
+acc += Math.sin(25849) + Math.cos(25850) * 47;
+acc += Math.sin(25850) + Math.cos(25851) * 48;
+acc += Math.sin(25851) + Math.cos(25852) * 49;
+acc += Math.sin(25852) + Math.cos(25853) * 50;
+acc += Math.sin(25853) + Math.cos(25854) * 51;
+acc += Math.sin(25854) + Math.cos(25855) * 52;
+acc += Math.sin(25855) + Math.cos(25856) * 53;
+acc += Math.sin(25856) + Math.cos(25857) * 54;
+acc += Math.sin(25857) + Math.cos(25858) * 55;
+acc += Math.sin(25858) + Math.cos(25859) * 56;
+acc += Math.sin(25859) + Math.cos(25860) * 57;
+acc += Math.sin(25860) + Math.cos(25861) * 58;
+acc += Math.sin(25861) + Math.cos(25862) * 59;
+acc += Math.sin(25862) + Math.cos(25863) * 60;
+acc += Math.sin(25863) + Math.cos(25864) * 61;
+acc += Math.sin(25864) + Math.cos(25865) * 62;
+acc += Math.sin(25865) + Math.cos(25866) * 63;
+acc += Math.sin(25866) + Math.cos(25867) * 64;
+acc += Math.sin(25867) + Math.cos(25868) * 65;
+acc += Math.sin(25868) + Math.cos(25869) * 66;
+acc += Math.sin(25869) + Math.cos(25870) * 67;
+acc += Math.sin(25870) + Math.cos(25871) * 68;
+acc += Math.sin(25871) + Math.cos(25872) * 69;
+acc += Math.sin(25872) + Math.cos(25873) * 70;
+acc += Math.sin(25873) + Math.cos(25874) * 71;
+acc += Math.sin(25874) + Math.cos(25875) * 72;
+acc += Math.sin(25875) + Math.cos(25876) * 73;
+acc += Math.sin(25876) + Math.cos(25877) * 74;
+acc += Math.sin(25877) + Math.cos(25878) * 75;
+acc += Math.sin(25878) + Math.cos(25879) * 76;
+acc += Math.sin(25879) + Math.cos(25880) * 77;
+acc += Math.sin(25880) + Math.cos(25881) * 78;
+acc += Math.sin(25881) + Math.cos(25882) * 79;
+acc += Math.sin(25882) + Math.cos(25883) * 80;
+acc += Math.sin(25883) + Math.cos(25884) * 81;
+acc += Math.sin(25884) + Math.cos(25885) * 82;
+acc += Math.sin(25885) + Math.cos(25886) * 83;
+acc += Math.sin(25886) + Math.cos(25887) * 84;
+acc += Math.sin(25887) + Math.cos(25888) * 85;
+acc += Math.sin(25888) + Math.cos(25889) * 86;
+acc += Math.sin(25889) + Math.cos(25890) * 87;
+acc += Math.sin(25890) + Math.cos(25891) * 88;
+acc += Math.sin(25891) + Math.cos(25892) * 89;
+acc += Math.sin(25892) + Math.cos(25893) * 90;
+acc += Math.sin(25893) + Math.cos(25894) * 91;
+acc += Math.sin(25894) + Math.cos(25895) * 92;
+acc += Math.sin(25895) + Math.cos(25896) * 93;
+acc += Math.sin(25896) + Math.cos(25897) * 94;
+acc += Math.sin(25897) + Math.cos(25898) * 95;
+acc += Math.sin(25898) + Math.cos(25899) * 96;
+acc += Math.sin(25899) + Math.cos(25900) * 0;
+acc += Math.sin(25900) + Math.cos(25901) * 1;
+acc += Math.sin(25901) + Math.cos(25902) * 2;
+acc += Math.sin(25902) + Math.cos(25903) * 3;
+acc += Math.sin(25903) + Math.cos(25904) * 4;
+acc += Math.sin(25904) + Math.cos(25905) * 5;
+acc += Math.sin(25905) + Math.cos(25906) * 6;
+acc += Math.sin(25906) + Math.cos(25907) * 7;
+acc += Math.sin(25907) + Math.cos(25908) * 8;
+acc += Math.sin(25908) + Math.cos(25909) * 9;
+acc += Math.sin(25909) + Math.cos(25910) * 10;
+acc += Math.sin(25910) + Math.cos(25911) * 11;
+acc += Math.sin(25911) + Math.cos(25912) * 12;
+acc += Math.sin(25912) + Math.cos(25913) * 13;
+acc += Math.sin(25913) + Math.cos(25914) * 14;
+acc += Math.sin(25914) + Math.cos(25915) * 15;
+acc += Math.sin(25915) + Math.cos(25916) * 16;
+acc += Math.sin(25916) + Math.cos(25917) * 17;
+acc += Math.sin(25917) + Math.cos(25918) * 18;
+acc += Math.sin(25918) + Math.cos(25919) * 19;
+acc += Math.sin(25919) + Math.cos(25920) * 20;
+acc += Math.sin(25920) + Math.cos(25921) * 21;
+acc += Math.sin(25921) + Math.cos(25922) * 22;
+acc += Math.sin(25922) + Math.cos(25923) * 23;
+acc += Math.sin(25923) + Math.cos(25924) * 24;
+acc += Math.sin(25924) + Math.cos(25925) * 25;
+acc += Math.sin(25925) + Math.cos(25926) * 26;
+acc += Math.sin(25926) + Math.cos(25927) * 27;
+acc += Math.sin(25927) + Math.cos(25928) * 28;
+acc += Math.sin(25928) + Math.cos(25929) * 29;
+acc += Math.sin(25929) + Math.cos(25930) * 30;
+acc += Math.sin(25930) + Math.cos(25931) * 31;
+acc += Math.sin(25931) + Math.cos(25932) * 32;
+acc += Math.sin(25932) + Math.cos(25933) * 33;
+acc += Math.sin(25933) + Math.cos(25934) * 34;
+acc += Math.sin(25934) + Math.cos(25935) * 35;
+acc += Math.sin(25935) + Math.cos(25936) * 36;
+acc += Math.sin(25936) + Math.cos(25937) * 37;
+acc += Math.sin(25937) + Math.cos(25938) * 38;
+acc += Math.sin(25938) + Math.cos(25939) * 39;
+acc += Math.sin(25939) + Math.cos(25940) * 40;
+acc += Math.sin(25940) + Math.cos(25941) * 41;
+acc += Math.sin(25941) + Math.cos(25942) * 42;
+acc += Math.sin(25942) + Math.cos(25943) * 43;
+acc += Math.sin(25943) + Math.cos(25944) * 44;
+acc += Math.sin(25944) + Math.cos(25945) * 45;
+acc += Math.sin(25945) + Math.cos(25946) * 46;
+acc += Math.sin(25946) + Math.cos(25947) * 47;
+acc += Math.sin(25947) + Math.cos(25948) * 48;
+acc += Math.sin(25948) + Math.cos(25949) * 49;
+acc += Math.sin(25949) + Math.cos(25950) * 50;
+acc += Math.sin(25950) + Math.cos(25951) * 51;
+acc += Math.sin(25951) + Math.cos(25952) * 52;
+acc += Math.sin(25952) + Math.cos(25953) * 53;
+acc += Math.sin(25953) + Math.cos(25954) * 54;
+acc += Math.sin(25954) + Math.cos(25955) * 55;
+acc += Math.sin(25955) + Math.cos(25956) * 56;
+acc += Math.sin(25956) + Math.cos(25957) * 57;
+acc += Math.sin(25957) + Math.cos(25958) * 58;
+acc += Math.sin(25958) + Math.cos(25959) * 59;
+acc += Math.sin(25959) + Math.cos(25960) * 60;
+acc += Math.sin(25960) + Math.cos(25961) * 61;
+acc += Math.sin(25961) + Math.cos(25962) * 62;
+acc += Math.sin(25962) + Math.cos(25963) * 63;
+acc += Math.sin(25963) + Math.cos(25964) * 64;
+acc += Math.sin(25964) + Math.cos(25965) * 65;
+acc += Math.sin(25965) + Math.cos(25966) * 66;
+acc += Math.sin(25966) + Math.cos(25967) * 67;
+acc += Math.sin(25967) + Math.cos(25968) * 68;
+acc += Math.sin(25968) + Math.cos(25969) * 69;
+acc += Math.sin(25969) + Math.cos(25970) * 70;
+acc += Math.sin(25970) + Math.cos(25971) * 71;
+acc += Math.sin(25971) + Math.cos(25972) * 72;
+acc += Math.sin(25972) + Math.cos(25973) * 73;
+acc += Math.sin(25973) + Math.cos(25974) * 74;
+acc += Math.sin(25974) + Math.cos(25975) * 75;
+acc += Math.sin(25975) + Math.cos(25976) * 76;
+acc += Math.sin(25976) + Math.cos(25977) * 77;
+acc += Math.sin(25977) + Math.cos(25978) * 78;
+acc += Math.sin(25978) + Math.cos(25979) * 79;
+acc += Math.sin(25979) + Math.cos(25980) * 80;
+acc += Math.sin(25980) + Math.cos(25981) * 81;
+acc += Math.sin(25981) + Math.cos(25982) * 82;
+acc += Math.sin(25982) + Math.cos(25983) * 83;
+acc += Math.sin(25983) + Math.cos(25984) * 84;
+acc += Math.sin(25984) + Math.cos(25985) * 85;
+acc += Math.sin(25985) + Math.cos(25986) * 86;
+acc += Math.sin(25986) + Math.cos(25987) * 87;
+acc += Math.sin(25987) + Math.cos(25988) * 88;
+acc += Math.sin(25988) + Math.cos(25989) * 89;
+acc += Math.sin(25989) + Math.cos(25990) * 90;
+acc += Math.sin(25990) + Math.cos(25991) * 91;
+acc += Math.sin(25991) + Math.cos(25992) * 92;
+acc += Math.sin(25992) + Math.cos(25993) * 93;
+acc += Math.sin(25993) + Math.cos(25994) * 94;
+acc += Math.sin(25994) + Math.cos(25995) * 95;
+acc += Math.sin(25995) + Math.cos(25996) * 96;
+acc += Math.sin(25996) + Math.cos(25997) * 0;
+acc += Math.sin(25997) + Math.cos(25998) * 1;
+acc += Math.sin(25998) + Math.cos(25999) * 2;
+acc += Math.sin(25999) + Math.cos(26000) * 3;
+acc += Math.sin(26000) + Math.cos(26001) * 4;
+acc += Math.sin(26001) + Math.cos(26002) * 5;
+acc += Math.sin(26002) + Math.cos(26003) * 6;
+acc += Math.sin(26003) + Math.cos(26004) * 7;
+acc += Math.sin(26004) + Math.cos(26005) * 8;
+acc += Math.sin(26005) + Math.cos(26006) * 9;
+acc += Math.sin(26006) + Math.cos(26007) * 10;
+acc += Math.sin(26007) + Math.cos(26008) * 11;
+acc += Math.sin(26008) + Math.cos(26009) * 12;
+acc += Math.sin(26009) + Math.cos(26010) * 13;
+acc += Math.sin(26010) + Math.cos(26011) * 14;
+acc += Math.sin(26011) + Math.cos(26012) * 15;
+acc += Math.sin(26012) + Math.cos(26013) * 16;
+acc += Math.sin(26013) + Math.cos(26014) * 17;
+acc += Math.sin(26014) + Math.cos(26015) * 18;
+acc += Math.sin(26015) + Math.cos(26016) * 19;
+acc += Math.sin(26016) + Math.cos(26017) * 20;
+acc += Math.sin(26017) + Math.cos(26018) * 21;
+acc += Math.sin(26018) + Math.cos(26019) * 22;
+acc += Math.sin(26019) + Math.cos(26020) * 23;
+acc += Math.sin(26020) + Math.cos(26021) * 24;
+acc += Math.sin(26021) + Math.cos(26022) * 25;
+acc += Math.sin(26022) + Math.cos(26023) * 26;
+acc += Math.sin(26023) + Math.cos(26024) * 27;
+acc += Math.sin(26024) + Math.cos(26025) * 28;
+acc += Math.sin(26025) + Math.cos(26026) * 29;
+acc += Math.sin(26026) + Math.cos(26027) * 30;
+acc += Math.sin(26027) + Math.cos(26028) * 31;
+acc += Math.sin(26028) + Math.cos(26029) * 32;
+acc += Math.sin(26029) + Math.cos(26030) * 33;
+acc += Math.sin(26030) + Math.cos(26031) * 34;
+acc += Math.sin(26031) + Math.cos(26032) * 35;
+acc += Math.sin(26032) + Math.cos(26033) * 36;
+acc += Math.sin(26033) + Math.cos(26034) * 37;
+acc += Math.sin(26034) + Math.cos(26035) * 38;
+acc += Math.sin(26035) + Math.cos(26036) * 39;
+acc += Math.sin(26036) + Math.cos(26037) * 40;
+acc += Math.sin(26037) + Math.cos(26038) * 41;
+acc += Math.sin(26038) + Math.cos(26039) * 42;
+acc += Math.sin(26039) + Math.cos(26040) * 43;
+acc += Math.sin(26040) + Math.cos(26041) * 44;
+acc += Math.sin(26041) + Math.cos(26042) * 45;
+acc += Math.sin(26042) + Math.cos(26043) * 46;
+acc += Math.sin(26043) + Math.cos(26044) * 47;
+acc += Math.sin(26044) + Math.cos(26045) * 48;
+acc += Math.sin(26045) + Math.cos(26046) * 49;
+acc += Math.sin(26046) + Math.cos(26047) * 50;
+acc += Math.sin(26047) + Math.cos(26048) * 51;
+acc += Math.sin(26048) + Math.cos(26049) * 52;
+acc += Math.sin(26049) + Math.cos(26050) * 53;
+acc += Math.sin(26050) + Math.cos(26051) * 54;
+acc += Math.sin(26051) + Math.cos(26052) * 55;
+acc += Math.sin(26052) + Math.cos(26053) * 56;
+acc += Math.sin(26053) + Math.cos(26054) * 57;
+acc += Math.sin(26054) + Math.cos(26055) * 58;
+acc += Math.sin(26055) + Math.cos(26056) * 59;
+acc += Math.sin(26056) + Math.cos(26057) * 60;
+acc += Math.sin(26057) + Math.cos(26058) * 61;
+acc += Math.sin(26058) + Math.cos(26059) * 62;
+acc += Math.sin(26059) + Math.cos(26060) * 63;
+acc += Math.sin(26060) + Math.cos(26061) * 64;
+acc += Math.sin(26061) + Math.cos(26062) * 65;
+acc += Math.sin(26062) + Math.cos(26063) * 66;
+acc += Math.sin(26063) + Math.cos(26064) * 67;
+acc += Math.sin(26064) + Math.cos(26065) * 68;
+acc += Math.sin(26065) + Math.cos(26066) * 69;
+acc += Math.sin(26066) + Math.cos(26067) * 70;
+acc += Math.sin(26067) + Math.cos(26068) * 71;
+acc += Math.sin(26068) + Math.cos(26069) * 72;
+acc += Math.sin(26069) + Math.cos(26070) * 73;
+acc += Math.sin(26070) + Math.cos(26071) * 74;
+acc += Math.sin(26071) + Math.cos(26072) * 75;
+acc += Math.sin(26072) + Math.cos(26073) * 76;
+acc += Math.sin(26073) + Math.cos(26074) * 77;
+acc += Math.sin(26074) + Math.cos(26075) * 78;
+acc += Math.sin(26075) + Math.cos(26076) * 79;
+acc += Math.sin(26076) + Math.cos(26077) * 80;
+acc += Math.sin(26077) + Math.cos(26078) * 81;
+acc += Math.sin(26078) + Math.cos(26079) * 82;
+acc += Math.sin(26079) + Math.cos(26080) * 83;
+acc += Math.sin(26080) + Math.cos(26081) * 84;
+acc += Math.sin(26081) + Math.cos(26082) * 85;
+acc += Math.sin(26082) + Math.cos(26083) * 86;
+acc += Math.sin(26083) + Math.cos(26084) * 87;
+acc += Math.sin(26084) + Math.cos(26085) * 88;
+acc += Math.sin(26085) + Math.cos(26086) * 89;
+acc += Math.sin(26086) + Math.cos(26087) * 90;
+acc += Math.sin(26087) + Math.cos(26088) * 91;
+acc += Math.sin(26088) + Math.cos(26089) * 92;
+acc += Math.sin(26089) + Math.cos(26090) * 93;
+acc += Math.sin(26090) + Math.cos(26091) * 94;
+acc += Math.sin(26091) + Math.cos(26092) * 95;
+acc += Math.sin(26092) + Math.cos(26093) * 96;
+acc += Math.sin(26093) + Math.cos(26094) * 0;
+acc += Math.sin(26094) + Math.cos(26095) * 1;
+acc += Math.sin(26095) + Math.cos(26096) * 2;
+acc += Math.sin(26096) + Math.cos(26097) * 3;
+acc += Math.sin(26097) + Math.cos(26098) * 4;
+acc += Math.sin(26098) + Math.cos(26099) * 5;
+acc += Math.sin(26099) + Math.cos(26100) * 6;
+acc += Math.sin(26100) + Math.cos(26101) * 7;
+acc += Math.sin(26101) + Math.cos(26102) * 8;
+acc += Math.sin(26102) + Math.cos(26103) * 9;
+acc += Math.sin(26103) + Math.cos(26104) * 10;
+acc += Math.sin(26104) + Math.cos(26105) * 11;
+acc += Math.sin(26105) + Math.cos(26106) * 12;
+acc += Math.sin(26106) + Math.cos(26107) * 13;
+acc += Math.sin(26107) + Math.cos(26108) * 14;
+acc += Math.sin(26108) + Math.cos(26109) * 15;
+acc += Math.sin(26109) + Math.cos(26110) * 16;
+acc += Math.sin(26110) + Math.cos(26111) * 17;
+acc += Math.sin(26111) + Math.cos(26112) * 18;
+acc += Math.sin(26112) + Math.cos(26113) * 19;
+acc += Math.sin(26113) + Math.cos(26114) * 20;
+acc += Math.sin(26114) + Math.cos(26115) * 21;
+acc += Math.sin(26115) + Math.cos(26116) * 22;
+acc += Math.sin(26116) + Math.cos(26117) * 23;
+acc += Math.sin(26117) + Math.cos(26118) * 24;
+acc += Math.sin(26118) + Math.cos(26119) * 25;
+acc += Math.sin(26119) + Math.cos(26120) * 26;
+acc += Math.sin(26120) + Math.cos(26121) * 27;
+acc += Math.sin(26121) + Math.cos(26122) * 28;
+acc += Math.sin(26122) + Math.cos(26123) * 29;
+acc += Math.sin(26123) + Math.cos(26124) * 30;
+acc += Math.sin(26124) + Math.cos(26125) * 31;
+acc += Math.sin(26125) + Math.cos(26126) * 32;
+acc += Math.sin(26126) + Math.cos(26127) * 33;
+acc += Math.sin(26127) + Math.cos(26128) * 34;
+acc += Math.sin(26128) + Math.cos(26129) * 35;
+acc += Math.sin(26129) + Math.cos(26130) * 36;
+acc += Math.sin(26130) + Math.cos(26131) * 37;
+acc += Math.sin(26131) + Math.cos(26132) * 38;
+acc += Math.sin(26132) + Math.cos(26133) * 39;
+acc += Math.sin(26133) + Math.cos(26134) * 40;
+acc += Math.sin(26134) + Math.cos(26135) * 41;
+acc += Math.sin(26135) + Math.cos(26136) * 42;
+acc += Math.sin(26136) + Math.cos(26137) * 43;
+acc += Math.sin(26137) + Math.cos(26138) * 44;
+acc += Math.sin(26138) + Math.cos(26139) * 45;
+acc += Math.sin(26139) + Math.cos(26140) * 46;
+acc += Math.sin(26140) + Math.cos(26141) * 47;
+acc += Math.sin(26141) + Math.cos(26142) * 48;
+acc += Math.sin(26142) + Math.cos(26143) * 49;
+acc += Math.sin(26143) + Math.cos(26144) * 50;
+acc += Math.sin(26144) + Math.cos(26145) * 51;
+acc += Math.sin(26145) + Math.cos(26146) * 52;
+acc += Math.sin(26146) + Math.cos(26147) * 53;
+acc += Math.sin(26147) + Math.cos(26148) * 54;
+acc += Math.sin(26148) + Math.cos(26149) * 55;
+acc += Math.sin(26149) + Math.cos(26150) * 56;
+acc += Math.sin(26150) + Math.cos(26151) * 57;
+acc += Math.sin(26151) + Math.cos(26152) * 58;
+acc += Math.sin(26152) + Math.cos(26153) * 59;
+acc += Math.sin(26153) + Math.cos(26154) * 60;
+acc += Math.sin(26154) + Math.cos(26155) * 61;
+acc += Math.sin(26155) + Math.cos(26156) * 62;
+acc += Math.sin(26156) + Math.cos(26157) * 63;
+acc += Math.sin(26157) + Math.cos(26158) * 64;
+acc += Math.sin(26158) + Math.cos(26159) * 65;
+acc += Math.sin(26159) + Math.cos(26160) * 66;
+acc += Math.sin(26160) + Math.cos(26161) * 67;
+acc += Math.sin(26161) + Math.cos(26162) * 68;
+acc += Math.sin(26162) + Math.cos(26163) * 69;
+acc += Math.sin(26163) + Math.cos(26164) * 70;
+acc += Math.sin(26164) + Math.cos(26165) * 71;
+acc += Math.sin(26165) + Math.cos(26166) * 72;
+acc += Math.sin(26166) + Math.cos(26167) * 73;
+acc += Math.sin(26167) + Math.cos(26168) * 74;
+acc += Math.sin(26168) + Math.cos(26169) * 75;
+acc += Math.sin(26169) + Math.cos(26170) * 76;
+acc += Math.sin(26170) + Math.cos(26171) * 77;
+acc += Math.sin(26171) + Math.cos(26172) * 78;
+acc += Math.sin(26172) + Math.cos(26173) * 79;
+acc += Math.sin(26173) + Math.cos(26174) * 80;
+acc += Math.sin(26174) + Math.cos(26175) * 81;
+acc += Math.sin(26175) + Math.cos(26176) * 82;
+acc += Math.sin(26176) + Math.cos(26177) * 83;
+acc += Math.sin(26177) + Math.cos(26178) * 84;
+acc += Math.sin(26178) + Math.cos(26179) * 85;
+acc += Math.sin(26179) + Math.cos(26180) * 86;
+acc += Math.sin(26180) + Math.cos(26181) * 87;
+acc += Math.sin(26181) + Math.cos(26182) * 88;
+acc += Math.sin(26182) + Math.cos(26183) * 89;
+acc += Math.sin(26183) + Math.cos(26184) * 90;
+acc += Math.sin(26184) + Math.cos(26185) * 91;
+acc += Math.sin(26185) + Math.cos(26186) * 92;
+acc += Math.sin(26186) + Math.cos(26187) * 93;
+acc += Math.sin(26187) + Math.cos(26188) * 94;
+acc += Math.sin(26188) + Math.cos(26189) * 95;
+acc += Math.sin(26189) + Math.cos(26190) * 96;
+acc += Math.sin(26190) + Math.cos(26191) * 0;
+acc += Math.sin(26191) + Math.cos(26192) * 1;
+acc += Math.sin(26192) + Math.cos(26193) * 2;
+acc += Math.sin(26193) + Math.cos(26194) * 3;
+acc += Math.sin(26194) + Math.cos(26195) * 4;
+acc += Math.sin(26195) + Math.cos(26196) * 5;
+acc += Math.sin(26196) + Math.cos(26197) * 6;
+acc += Math.sin(26197) + Math.cos(26198) * 7;
+acc += Math.sin(26198) + Math.cos(26199) * 8;
+acc += Math.sin(26199) + Math.cos(26200) * 9;
+acc += Math.sin(26200) + Math.cos(26201) * 10;
+acc += Math.sin(26201) + Math.cos(26202) * 11;
+acc += Math.sin(26202) + Math.cos(26203) * 12;
+acc += Math.sin(26203) + Math.cos(26204) * 13;
+acc += Math.sin(26204) + Math.cos(26205) * 14;
+acc += Math.sin(26205) + Math.cos(26206) * 15;
+acc += Math.sin(26206) + Math.cos(26207) * 16;
+acc += Math.sin(26207) + Math.cos(26208) * 17;
+acc += Math.sin(26208) + Math.cos(26209) * 18;
+acc += Math.sin(26209) + Math.cos(26210) * 19;
+acc += Math.sin(26210) + Math.cos(26211) * 20;
+acc += Math.sin(26211) + Math.cos(26212) * 21;
+acc += Math.sin(26212) + Math.cos(26213) * 22;
+acc += Math.sin(26213) + Math.cos(26214) * 23;
+acc += Math.sin(26214) + Math.cos(26215) * 24;
+acc += Math.sin(26215) + Math.cos(26216) * 25;
+acc += Math.sin(26216) + Math.cos(26217) * 26;
+acc += Math.sin(26217) + Math.cos(26218) * 27;
+acc += Math.sin(26218) + Math.cos(26219) * 28;
+acc += Math.sin(26219) + Math.cos(26220) * 29;
+acc += Math.sin(26220) + Math.cos(26221) * 30;
+acc += Math.sin(26221) + Math.cos(26222) * 31;
+acc += Math.sin(26222) + Math.cos(26223) * 32;
+acc += Math.sin(26223) + Math.cos(26224) * 33;
+acc += Math.sin(26224) + Math.cos(26225) * 34;
+acc += Math.sin(26225) + Math.cos(26226) * 35;
+acc += Math.sin(26226) + Math.cos(26227) * 36;
+acc += Math.sin(26227) + Math.cos(26228) * 37;
+acc += Math.sin(26228) + Math.cos(26229) * 38;
+acc += Math.sin(26229) + Math.cos(26230) * 39;
+acc += Math.sin(26230) + Math.cos(26231) * 40;
+acc += Math.sin(26231) + Math.cos(26232) * 41;
+acc += Math.sin(26232) + Math.cos(26233) * 42;
+acc += Math.sin(26233) + Math.cos(26234) * 43;
+acc += Math.sin(26234) + Math.cos(26235) * 44;
+acc += Math.sin(26235) + Math.cos(26236) * 45;
+acc += Math.sin(26236) + Math.cos(26237) * 46;
+acc += Math.sin(26237) + Math.cos(26238) * 47;
+acc += Math.sin(26238) + Math.cos(26239) * 48;
+acc += Math.sin(26239) + Math.cos(26240) * 49;
+acc += Math.sin(26240) + Math.cos(26241) * 50;
+acc += Math.sin(26241) + Math.cos(26242) * 51;
+acc += Math.sin(26242) + Math.cos(26243) * 52;
+acc += Math.sin(26243) + Math.cos(26244) * 53;
+acc += Math.sin(26244) + Math.cos(26245) * 54;
+acc += Math.sin(26245) + Math.cos(26246) * 55;
+acc += Math.sin(26246) + Math.cos(26247) * 56;
+acc += Math.sin(26247) + Math.cos(26248) * 57;
+acc += Math.sin(26248) + Math.cos(26249) * 58;
+acc += Math.sin(26249) + Math.cos(26250) * 59;
+acc += Math.sin(26250) + Math.cos(26251) * 60;
+acc += Math.sin(26251) + Math.cos(26252) * 61;
+acc += Math.sin(26252) + Math.cos(26253) * 62;
+acc += Math.sin(26253) + Math.cos(26254) * 63;
+acc += Math.sin(26254) + Math.cos(26255) * 64;
+acc += Math.sin(26255) + Math.cos(26256) * 65;
+acc += Math.sin(26256) + Math.cos(26257) * 66;
+acc += Math.sin(26257) + Math.cos(26258) * 67;
+acc += Math.sin(26258) + Math.cos(26259) * 68;
+acc += Math.sin(26259) + Math.cos(26260) * 69;
+acc += Math.sin(26260) + Math.cos(26261) * 70;
+acc += Math.sin(26261) + Math.cos(26262) * 71;
+acc += Math.sin(26262) + Math.cos(26263) * 72;
+acc += Math.sin(26263) + Math.cos(26264) * 73;
+acc += Math.sin(26264) + Math.cos(26265) * 74;
+acc += Math.sin(26265) + Math.cos(26266) * 75;
+acc += Math.sin(26266) + Math.cos(26267) * 76;
+acc += Math.sin(26267) + Math.cos(26268) * 77;
+acc += Math.sin(26268) + Math.cos(26269) * 78;
+acc += Math.sin(26269) + Math.cos(26270) * 79;
+acc += Math.sin(26270) + Math.cos(26271) * 80;
+acc += Math.sin(26271) + Math.cos(26272) * 81;
+acc += Math.sin(26272) + Math.cos(26273) * 82;
+acc += Math.sin(26273) + Math.cos(26274) * 83;
+acc += Math.sin(26274) + Math.cos(26275) * 84;
+acc += Math.sin(26275) + Math.cos(26276) * 85;
+acc += Math.sin(26276) + Math.cos(26277) * 86;
+acc += Math.sin(26277) + Math.cos(26278) * 87;
+acc += Math.sin(26278) + Math.cos(26279) * 88;
+acc += Math.sin(26279) + Math.cos(26280) * 89;
+acc += Math.sin(26280) + Math.cos(26281) * 90;
+acc += Math.sin(26281) + Math.cos(26282) * 91;
+acc += Math.sin(26282) + Math.cos(26283) * 92;
+acc += Math.sin(26283) + Math.cos(26284) * 93;
+acc += Math.sin(26284) + Math.cos(26285) * 94;
+acc += Math.sin(26285) + Math.cos(26286) * 95;
+acc += Math.sin(26286) + Math.cos(26287) * 96;
+acc += Math.sin(26287) + Math.cos(26288) * 0;
+acc += Math.sin(26288) + Math.cos(26289) * 1;
+acc += Math.sin(26289) + Math.cos(26290) * 2;
+acc += Math.sin(26290) + Math.cos(26291) * 3;
+acc += Math.sin(26291) + Math.cos(26292) * 4;
+acc += Math.sin(26292) + Math.cos(26293) * 5;
+acc += Math.sin(26293) + Math.cos(26294) * 6;
+acc += Math.sin(26294) + Math.cos(26295) * 7;
+acc += Math.sin(26295) + Math.cos(26296) * 8;
+acc += Math.sin(26296) + Math.cos(26297) * 9;
+acc += Math.sin(26297) + Math.cos(26298) * 10;
+acc += Math.sin(26298) + Math.cos(26299) * 11;
+acc += Math.sin(26299) + Math.cos(26300) * 12;
+acc += Math.sin(26300) + Math.cos(26301) * 13;
+acc += Math.sin(26301) + Math.cos(26302) * 14;
+acc += Math.sin(26302) + Math.cos(26303) * 15;
+acc += Math.sin(26303) + Math.cos(26304) * 16;
+acc += Math.sin(26304) + Math.cos(26305) * 17;
+acc += Math.sin(26305) + Math.cos(26306) * 18;
+acc += Math.sin(26306) + Math.cos(26307) * 19;
+acc += Math.sin(26307) + Math.cos(26308) * 20;
+acc += Math.sin(26308) + Math.cos(26309) * 21;
+acc += Math.sin(26309) + Math.cos(26310) * 22;
+acc += Math.sin(26310) + Math.cos(26311) * 23;
+acc += Math.sin(26311) + Math.cos(26312) * 24;
+acc += Math.sin(26312) + Math.cos(26313) * 25;
+acc += Math.sin(26313) + Math.cos(26314) * 26;
+acc += Math.sin(26314) + Math.cos(26315) * 27;
+acc += Math.sin(26315) + Math.cos(26316) * 28;
+acc += Math.sin(26316) + Math.cos(26317) * 29;
+acc += Math.sin(26317) + Math.cos(26318) * 30;
+acc += Math.sin(26318) + Math.cos(26319) * 31;
+acc += Math.sin(26319) + Math.cos(26320) * 32;
+acc += Math.sin(26320) + Math.cos(26321) * 33;
+acc += Math.sin(26321) + Math.cos(26322) * 34;
+acc += Math.sin(26322) + Math.cos(26323) * 35;
+acc += Math.sin(26323) + Math.cos(26324) * 36;
+acc += Math.sin(26324) + Math.cos(26325) * 37;
+acc += Math.sin(26325) + Math.cos(26326) * 38;
+acc += Math.sin(26326) + Math.cos(26327) * 39;
+acc += Math.sin(26327) + Math.cos(26328) * 40;
+acc += Math.sin(26328) + Math.cos(26329) * 41;
+acc += Math.sin(26329) + Math.cos(26330) * 42;
+acc += Math.sin(26330) + Math.cos(26331) * 43;
+acc += Math.sin(26331) + Math.cos(26332) * 44;
+acc += Math.sin(26332) + Math.cos(26333) * 45;
+acc += Math.sin(26333) + Math.cos(26334) * 46;
+acc += Math.sin(26334) + Math.cos(26335) * 47;
+acc += Math.sin(26335) + Math.cos(26336) * 48;
+acc += Math.sin(26336) + Math.cos(26337) * 49;
+acc += Math.sin(26337) + Math.cos(26338) * 50;
+acc += Math.sin(26338) + Math.cos(26339) * 51;
+acc += Math.sin(26339) + Math.cos(26340) * 52;
+acc += Math.sin(26340) + Math.cos(26341) * 53;
+acc += Math.sin(26341) + Math.cos(26342) * 54;
+acc += Math.sin(26342) + Math.cos(26343) * 55;
+acc += Math.sin(26343) + Math.cos(26344) * 56;
+acc += Math.sin(26344) + Math.cos(26345) * 57;
+acc += Math.sin(26345) + Math.cos(26346) * 58;
+acc += Math.sin(26346) + Math.cos(26347) * 59;
+acc += Math.sin(26347) + Math.cos(26348) * 60;
+acc += Math.sin(26348) + Math.cos(26349) * 61;
+acc += Math.sin(26349) + Math.cos(26350) * 62;
+acc += Math.sin(26350) + Math.cos(26351) * 63;
+acc += Math.sin(26351) + Math.cos(26352) * 64;
+acc += Math.sin(26352) + Math.cos(26353) * 65;
+acc += Math.sin(26353) + Math.cos(26354) * 66;
+acc += Math.sin(26354) + Math.cos(26355) * 67;
+acc += Math.sin(26355) + Math.cos(26356) * 68;
+acc += Math.sin(26356) + Math.cos(26357) * 69;
+acc += Math.sin(26357) + Math.cos(26358) * 70;
+acc += Math.sin(26358) + Math.cos(26359) * 71;
+acc += Math.sin(26359) + Math.cos(26360) * 72;
+acc += Math.sin(26360) + Math.cos(26361) * 73;
+acc += Math.sin(26361) + Math.cos(26362) * 74;
+acc += Math.sin(26362) + Math.cos(26363) * 75;
+acc += Math.sin(26363) + Math.cos(26364) * 76;
+acc += Math.sin(26364) + Math.cos(26365) * 77;
+acc += Math.sin(26365) + Math.cos(26366) * 78;
+acc += Math.sin(26366) + Math.cos(26367) * 79;
+acc += Math.sin(26367) + Math.cos(26368) * 80;
+acc += Math.sin(26368) + Math.cos(26369) * 81;
+acc += Math.sin(26369) + Math.cos(26370) * 82;
+acc += Math.sin(26370) + Math.cos(26371) * 83;
+acc += Math.sin(26371) + Math.cos(26372) * 84;
+acc += Math.sin(26372) + Math.cos(26373) * 85;
+acc += Math.sin(26373) + Math.cos(26374) * 86;
+acc += Math.sin(26374) + Math.cos(26375) * 87;
+acc += Math.sin(26375) + Math.cos(26376) * 88;
+acc += Math.sin(26376) + Math.cos(26377) * 89;
+acc += Math.sin(26377) + Math.cos(26378) * 90;
+acc += Math.sin(26378) + Math.cos(26379) * 91;
+acc += Math.sin(26379) + Math.cos(26380) * 92;
+acc += Math.sin(26380) + Math.cos(26381) * 93;
+acc += Math.sin(26381) + Math.cos(26382) * 94;
+acc += Math.sin(26382) + Math.cos(26383) * 95;
+acc += Math.sin(26383) + Math.cos(26384) * 96;
+acc += Math.sin(26384) + Math.cos(26385) * 0;
+acc += Math.sin(26385) + Math.cos(26386) * 1;
+acc += Math.sin(26386) + Math.cos(26387) * 2;
+acc += Math.sin(26387) + Math.cos(26388) * 3;
+acc += Math.sin(26388) + Math.cos(26389) * 4;
+acc += Math.sin(26389) + Math.cos(26390) * 5;
+acc += Math.sin(26390) + Math.cos(26391) * 6;
+acc += Math.sin(26391) + Math.cos(26392) * 7;
+acc += Math.sin(26392) + Math.cos(26393) * 8;
+acc += Math.sin(26393) + Math.cos(26394) * 9;
+acc += Math.sin(26394) + Math.cos(26395) * 10;
+acc += Math.sin(26395) + Math.cos(26396) * 11;
+acc += Math.sin(26396) + Math.cos(26397) * 12;
+acc += Math.sin(26397) + Math.cos(26398) * 13;
+acc += Math.sin(26398) + Math.cos(26399) * 14;
+acc += Math.sin(26399) + Math.cos(26400) * 15;
+acc += Math.sin(26400) + Math.cos(26401) * 16;
+acc += Math.sin(26401) + Math.cos(26402) * 17;
+acc += Math.sin(26402) + Math.cos(26403) * 18;
+acc += Math.sin(26403) + Math.cos(26404) * 19;
+acc += Math.sin(26404) + Math.cos(26405) * 20;
+acc += Math.sin(26405) + Math.cos(26406) * 21;
+acc += Math.sin(26406) + Math.cos(26407) * 22;
+acc += Math.sin(26407) + Math.cos(26408) * 23;
+acc += Math.sin(26408) + Math.cos(26409) * 24;
+acc += Math.sin(26409) + Math.cos(26410) * 25;
+acc += Math.sin(26410) + Math.cos(26411) * 26;
+acc += Math.sin(26411) + Math.cos(26412) * 27;
+acc += Math.sin(26412) + Math.cos(26413) * 28;
+acc += Math.sin(26413) + Math.cos(26414) * 29;
+acc += Math.sin(26414) + Math.cos(26415) * 30;
+acc += Math.sin(26415) + Math.cos(26416) * 31;
+acc += Math.sin(26416) + Math.cos(26417) * 32;
+acc += Math.sin(26417) + Math.cos(26418) * 33;
+acc += Math.sin(26418) + Math.cos(26419) * 34;
+acc += Math.sin(26419) + Math.cos(26420) * 35;
+acc += Math.sin(26420) + Math.cos(26421) * 36;
+acc += Math.sin(26421) + Math.cos(26422) * 37;
+acc += Math.sin(26422) + Math.cos(26423) * 38;
+acc += Math.sin(26423) + Math.cos(26424) * 39;
+acc += Math.sin(26424) + Math.cos(26425) * 40;
+acc += Math.sin(26425) + Math.cos(26426) * 41;
+acc += Math.sin(26426) + Math.cos(26427) * 42;
+acc += Math.sin(26427) + Math.cos(26428) * 43;
+acc += Math.sin(26428) + Math.cos(26429) * 44;
+acc += Math.sin(26429) + Math.cos(26430) * 45;
+acc += Math.sin(26430) + Math.cos(26431) * 46;
+acc += Math.sin(26431) + Math.cos(26432) * 47;
+acc += Math.sin(26432) + Math.cos(26433) * 48;
+acc += Math.sin(26433) + Math.cos(26434) * 49;
+acc += Math.sin(26434) + Math.cos(26435) * 50;
+acc += Math.sin(26435) + Math.cos(26436) * 51;
+acc += Math.sin(26436) + Math.cos(26437) * 52;
+acc += Math.sin(26437) + Math.cos(26438) * 53;
+acc += Math.sin(26438) + Math.cos(26439) * 54;
+acc += Math.sin(26439) + Math.cos(26440) * 55;
+acc += Math.sin(26440) + Math.cos(26441) * 56;
+acc += Math.sin(26441) + Math.cos(26442) * 57;
+acc += Math.sin(26442) + Math.cos(26443) * 58;
+acc += Math.sin(26443) + Math.cos(26444) * 59;
+acc += Math.sin(26444) + Math.cos(26445) * 60;
+acc += Math.sin(26445) + Math.cos(26446) * 61;
+acc += Math.sin(26446) + Math.cos(26447) * 62;
+acc += Math.sin(26447) + Math.cos(26448) * 63;
+acc += Math.sin(26448) + Math.cos(26449) * 64;
+acc += Math.sin(26449) + Math.cos(26450) * 65;
+acc += Math.sin(26450) + Math.cos(26451) * 66;
+acc += Math.sin(26451) + Math.cos(26452) * 67;
+acc += Math.sin(26452) + Math.cos(26453) * 68;
+acc += Math.sin(26453) + Math.cos(26454) * 69;
+acc += Math.sin(26454) + Math.cos(26455) * 70;
+acc += Math.sin(26455) + Math.cos(26456) * 71;
+acc += Math.sin(26456) + Math.cos(26457) * 72;
+acc += Math.sin(26457) + Math.cos(26458) * 73;
+acc += Math.sin(26458) + Math.cos(26459) * 74;
+acc += Math.sin(26459) + Math.cos(26460) * 75;
+acc += Math.sin(26460) + Math.cos(26461) * 76;
+acc += Math.sin(26461) + Math.cos(26462) * 77;
+acc += Math.sin(26462) + Math.cos(26463) * 78;
+acc += Math.sin(26463) + Math.cos(26464) * 79;
+acc += Math.sin(26464) + Math.cos(26465) * 80;
+acc += Math.sin(26465) + Math.cos(26466) * 81;
+acc += Math.sin(26466) + Math.cos(26467) * 82;
+acc += Math.sin(26467) + Math.cos(26468) * 83;
+acc += Math.sin(26468) + Math.cos(26469) * 84;
+acc += Math.sin(26469) + Math.cos(26470) * 85;
+acc += Math.sin(26470) + Math.cos(26471) * 86;
+acc += Math.sin(26471) + Math.cos(26472) * 87;
+acc += Math.sin(26472) + Math.cos(26473) * 88;
+acc += Math.sin(26473) + Math.cos(26474) * 89;
+acc += Math.sin(26474) + Math.cos(26475) * 90;
+acc += Math.sin(26475) + Math.cos(26476) * 91;
+acc += Math.sin(26476) + Math.cos(26477) * 92;
+acc += Math.sin(26477) + Math.cos(26478) * 93;
+acc += Math.sin(26478) + Math.cos(26479) * 94;
+acc += Math.sin(26479) + Math.cos(26480) * 95;
+acc += Math.sin(26480) + Math.cos(26481) * 96;
+acc += Math.sin(26481) + Math.cos(26482) * 0;
+acc += Math.sin(26482) + Math.cos(26483) * 1;
+acc += Math.sin(26483) + Math.cos(26484) * 2;
+acc += Math.sin(26484) + Math.cos(26485) * 3;
+acc += Math.sin(26485) + Math.cos(26486) * 4;
+acc += Math.sin(26486) + Math.cos(26487) * 5;
+acc += Math.sin(26487) + Math.cos(26488) * 6;
+acc += Math.sin(26488) + Math.cos(26489) * 7;
+acc += Math.sin(26489) + Math.cos(26490) * 8;
+acc += Math.sin(26490) + Math.cos(26491) * 9;
+acc += Math.sin(26491) + Math.cos(26492) * 10;
+acc += Math.sin(26492) + Math.cos(26493) * 11;
+acc += Math.sin(26493) + Math.cos(26494) * 12;
+acc += Math.sin(26494) + Math.cos(26495) * 13;
+acc += Math.sin(26495) + Math.cos(26496) * 14;
+acc += Math.sin(26496) + Math.cos(26497) * 15;
+acc += Math.sin(26497) + Math.cos(26498) * 16;
+acc += Math.sin(26498) + Math.cos(26499) * 17;
+acc += Math.sin(26499) + Math.cos(26500) * 18;
+acc += Math.sin(26500) + Math.cos(26501) * 19;
+acc += Math.sin(26501) + Math.cos(26502) * 20;
+acc += Math.sin(26502) + Math.cos(26503) * 21;
+acc += Math.sin(26503) + Math.cos(26504) * 22;
+acc += Math.sin(26504) + Math.cos(26505) * 23;
+acc += Math.sin(26505) + Math.cos(26506) * 24;
+acc += Math.sin(26506) + Math.cos(26507) * 25;
+acc += Math.sin(26507) + Math.cos(26508) * 26;
+acc += Math.sin(26508) + Math.cos(26509) * 27;
+acc += Math.sin(26509) + Math.cos(26510) * 28;
+acc += Math.sin(26510) + Math.cos(26511) * 29;
+acc += Math.sin(26511) + Math.cos(26512) * 30;
+acc += Math.sin(26512) + Math.cos(26513) * 31;
+acc += Math.sin(26513) + Math.cos(26514) * 32;
+acc += Math.sin(26514) + Math.cos(26515) * 33;
+acc += Math.sin(26515) + Math.cos(26516) * 34;
+acc += Math.sin(26516) + Math.cos(26517) * 35;
+acc += Math.sin(26517) + Math.cos(26518) * 36;
+acc += Math.sin(26518) + Math.cos(26519) * 37;
+acc += Math.sin(26519) + Math.cos(26520) * 38;
+acc += Math.sin(26520) + Math.cos(26521) * 39;
+acc += Math.sin(26521) + Math.cos(26522) * 40;
+acc += Math.sin(26522) + Math.cos(26523) * 41;
+acc += Math.sin(26523) + Math.cos(26524) * 42;
+acc += Math.sin(26524) + Math.cos(26525) * 43;
+acc += Math.sin(26525) + Math.cos(26526) * 44;
+acc += Math.sin(26526) + Math.cos(26527) * 45;
+acc += Math.sin(26527) + Math.cos(26528) * 46;
+acc += Math.sin(26528) + Math.cos(26529) * 47;
+acc += Math.sin(26529) + Math.cos(26530) * 48;
+acc += Math.sin(26530) + Math.cos(26531) * 49;
+acc += Math.sin(26531) + Math.cos(26532) * 50;
+acc += Math.sin(26532) + Math.cos(26533) * 51;
+acc += Math.sin(26533) + Math.cos(26534) * 52;
+acc += Math.sin(26534) + Math.cos(26535) * 53;
+acc += Math.sin(26535) + Math.cos(26536) * 54;
+acc += Math.sin(26536) + Math.cos(26537) * 55;
+acc += Math.sin(26537) + Math.cos(26538) * 56;
+acc += Math.sin(26538) + Math.cos(26539) * 57;
+acc += Math.sin(26539) + Math.cos(26540) * 58;
+acc += Math.sin(26540) + Math.cos(26541) * 59;
+acc += Math.sin(26541) + Math.cos(26542) * 60;
+acc += Math.sin(26542) + Math.cos(26543) * 61;
+acc += Math.sin(26543) + Math.cos(26544) * 62;
+acc += Math.sin(26544) + Math.cos(26545) * 63;
+acc += Math.sin(26545) + Math.cos(26546) * 64;
+acc += Math.sin(26546) + Math.cos(26547) * 65;
+acc += Math.sin(26547) + Math.cos(26548) * 66;
+acc += Math.sin(26548) + Math.cos(26549) * 67;
+acc += Math.sin(26549) + Math.cos(26550) * 68;
+acc += Math.sin(26550) + Math.cos(26551) * 69;
+acc += Math.sin(26551) + Math.cos(26552) * 70;
+acc += Math.sin(26552) + Math.cos(26553) * 71;
+acc += Math.sin(26553) + Math.cos(26554) * 72;
+acc += Math.sin(26554) + Math.cos(26555) * 73;
+acc += Math.sin(26555) + Math.cos(26556) * 74;
+acc += Math.sin(26556) + Math.cos(26557) * 75;
+acc += Math.sin(26557) + Math.cos(26558) * 76;
+acc += Math.sin(26558) + Math.cos(26559) * 77;
+acc += Math.sin(26559) + Math.cos(26560) * 78;
+acc += Math.sin(26560) + Math.cos(26561) * 79;
+acc += Math.sin(26561) + Math.cos(26562) * 80;
+acc += Math.sin(26562) + Math.cos(26563) * 81;
+acc += Math.sin(26563) + Math.cos(26564) * 82;
+acc += Math.sin(26564) + Math.cos(26565) * 83;
+acc += Math.sin(26565) + Math.cos(26566) * 84;
+acc += Math.sin(26566) + Math.cos(26567) * 85;
+acc += Math.sin(26567) + Math.cos(26568) * 86;
+acc += Math.sin(26568) + Math.cos(26569) * 87;
+acc += Math.sin(26569) + Math.cos(26570) * 88;
+acc += Math.sin(26570) + Math.cos(26571) * 89;
+acc += Math.sin(26571) + Math.cos(26572) * 90;
+acc += Math.sin(26572) + Math.cos(26573) * 91;
+acc += Math.sin(26573) + Math.cos(26574) * 92;
+acc += Math.sin(26574) + Math.cos(26575) * 93;
+acc += Math.sin(26575) + Math.cos(26576) * 94;
+acc += Math.sin(26576) + Math.cos(26577) * 95;
+acc += Math.sin(26577) + Math.cos(26578) * 96;
+acc += Math.sin(26578) + Math.cos(26579) * 0;
+acc += Math.sin(26579) + Math.cos(26580) * 1;
+acc += Math.sin(26580) + Math.cos(26581) * 2;
+acc += Math.sin(26581) + Math.cos(26582) * 3;
+acc += Math.sin(26582) + Math.cos(26583) * 4;
+acc += Math.sin(26583) + Math.cos(26584) * 5;
+acc += Math.sin(26584) + Math.cos(26585) * 6;
+acc += Math.sin(26585) + Math.cos(26586) * 7;
+acc += Math.sin(26586) + Math.cos(26587) * 8;
+acc += Math.sin(26587) + Math.cos(26588) * 9;
+acc += Math.sin(26588) + Math.cos(26589) * 10;
+acc += Math.sin(26589) + Math.cos(26590) * 11;
+acc += Math.sin(26590) + Math.cos(26591) * 12;
+acc += Math.sin(26591) + Math.cos(26592) * 13;
+acc += Math.sin(26592) + Math.cos(26593) * 14;
+acc += Math.sin(26593) + Math.cos(26594) * 15;
+acc += Math.sin(26594) + Math.cos(26595) * 16;
+acc += Math.sin(26595) + Math.cos(26596) * 17;
+acc += Math.sin(26596) + Math.cos(26597) * 18;
+acc += Math.sin(26597) + Math.cos(26598) * 19;
+acc += Math.sin(26598) + Math.cos(26599) * 20;
+acc += Math.sin(26599) + Math.cos(26600) * 21;
+acc += Math.sin(26600) + Math.cos(26601) * 22;
+acc += Math.sin(26601) + Math.cos(26602) * 23;
+acc += Math.sin(26602) + Math.cos(26603) * 24;
+acc += Math.sin(26603) + Math.cos(26604) * 25;
+acc += Math.sin(26604) + Math.cos(26605) * 26;
+acc += Math.sin(26605) + Math.cos(26606) * 27;
+acc += Math.sin(26606) + Math.cos(26607) * 28;
+acc += Math.sin(26607) + Math.cos(26608) * 29;
+acc += Math.sin(26608) + Math.cos(26609) * 30;
+acc += Math.sin(26609) + Math.cos(26610) * 31;
+acc += Math.sin(26610) + Math.cos(26611) * 32;
+acc += Math.sin(26611) + Math.cos(26612) * 33;
+acc += Math.sin(26612) + Math.cos(26613) * 34;
+acc += Math.sin(26613) + Math.cos(26614) * 35;
+acc += Math.sin(26614) + Math.cos(26615) * 36;
+acc += Math.sin(26615) + Math.cos(26616) * 37;
+acc += Math.sin(26616) + Math.cos(26617) * 38;
+acc += Math.sin(26617) + Math.cos(26618) * 39;
+acc += Math.sin(26618) + Math.cos(26619) * 40;
+acc += Math.sin(26619) + Math.cos(26620) * 41;
+acc += Math.sin(26620) + Math.cos(26621) * 42;
+acc += Math.sin(26621) + Math.cos(26622) * 43;
+acc += Math.sin(26622) + Math.cos(26623) * 44;
+acc += Math.sin(26623) + Math.cos(26624) * 45;
+acc += Math.sin(26624) + Math.cos(26625) * 46;
+acc += Math.sin(26625) + Math.cos(26626) * 47;
+acc += Math.sin(26626) + Math.cos(26627) * 48;
+acc += Math.sin(26627) + Math.cos(26628) * 49;
+acc += Math.sin(26628) + Math.cos(26629) * 50;
+acc += Math.sin(26629) + Math.cos(26630) * 51;
+acc += Math.sin(26630) + Math.cos(26631) * 52;
+acc += Math.sin(26631) + Math.cos(26632) * 53;
+acc += Math.sin(26632) + Math.cos(26633) * 54;
+acc += Math.sin(26633) + Math.cos(26634) * 55;
+acc += Math.sin(26634) + Math.cos(26635) * 56;
+acc += Math.sin(26635) + Math.cos(26636) * 57;
+acc += Math.sin(26636) + Math.cos(26637) * 58;
+acc += Math.sin(26637) + Math.cos(26638) * 59;
+acc += Math.sin(26638) + Math.cos(26639) * 60;
+acc += Math.sin(26639) + Math.cos(26640) * 61;
+acc += Math.sin(26640) + Math.cos(26641) * 62;
+acc += Math.sin(26641) + Math.cos(26642) * 63;
+acc += Math.sin(26642) + Math.cos(26643) * 64;
+acc += Math.sin(26643) + Math.cos(26644) * 65;
+acc += Math.sin(26644) + Math.cos(26645) * 66;
+acc += Math.sin(26645) + Math.cos(26646) * 67;
+acc += Math.sin(26646) + Math.cos(26647) * 68;
+acc += Math.sin(26647) + Math.cos(26648) * 69;
+acc += Math.sin(26648) + Math.cos(26649) * 70;
+acc += Math.sin(26649) + Math.cos(26650) * 71;
+acc += Math.sin(26650) + Math.cos(26651) * 72;
+acc += Math.sin(26651) + Math.cos(26652) * 73;
+acc += Math.sin(26652) + Math.cos(26653) * 74;
+acc += Math.sin(26653) + Math.cos(26654) * 75;
+acc += Math.sin(26654) + Math.cos(26655) * 76;
+acc += Math.sin(26655) + Math.cos(26656) * 77;
+acc += Math.sin(26656) + Math.cos(26657) * 78;
+acc += Math.sin(26657) + Math.cos(26658) * 79;
+acc += Math.sin(26658) + Math.cos(26659) * 80;
+acc += Math.sin(26659) + Math.cos(26660) * 81;
+acc += Math.sin(26660) + Math.cos(26661) * 82;
+acc += Math.sin(26661) + Math.cos(26662) * 83;
+acc += Math.sin(26662) + Math.cos(26663) * 84;
+acc += Math.sin(26663) + Math.cos(26664) * 85;
+acc += Math.sin(26664) + Math.cos(26665) * 86;
+acc += Math.sin(26665) + Math.cos(26666) * 87;
+acc += Math.sin(26666) + Math.cos(26667) * 88;
+acc += Math.sin(26667) + Math.cos(26668) * 89;
+acc += Math.sin(26668) + Math.cos(26669) * 90;
+acc += Math.sin(26669) + Math.cos(26670) * 91;
+acc += Math.sin(26670) + Math.cos(26671) * 92;
+acc += Math.sin(26671) + Math.cos(26672) * 93;
+acc += Math.sin(26672) + Math.cos(26673) * 94;
+acc += Math.sin(26673) + Math.cos(26674) * 95;
+acc += Math.sin(26674) + Math.cos(26675) * 96;
+acc += Math.sin(26675) + Math.cos(26676) * 0;
+acc += Math.sin(26676) + Math.cos(26677) * 1;
+acc += Math.sin(26677) + Math.cos(26678) * 2;
+acc += Math.sin(26678) + Math.cos(26679) * 3;
+acc += Math.sin(26679) + Math.cos(26680) * 4;
+acc += Math.sin(26680) + Math.cos(26681) * 5;
+acc += Math.sin(26681) + Math.cos(26682) * 6;
+acc += Math.sin(26682) + Math.cos(26683) * 7;
+acc += Math.sin(26683) + Math.cos(26684) * 8;
+acc += Math.sin(26684) + Math.cos(26685) * 9;
+acc += Math.sin(26685) + Math.cos(26686) * 10;
+acc += Math.sin(26686) + Math.cos(26687) * 11;
+acc += Math.sin(26687) + Math.cos(26688) * 12;
+acc += Math.sin(26688) + Math.cos(26689) * 13;
+acc += Math.sin(26689) + Math.cos(26690) * 14;
+acc += Math.sin(26690) + Math.cos(26691) * 15;
+acc += Math.sin(26691) + Math.cos(26692) * 16;
+acc += Math.sin(26692) + Math.cos(26693) * 17;
+acc += Math.sin(26693) + Math.cos(26694) * 18;
+acc += Math.sin(26694) + Math.cos(26695) * 19;
+acc += Math.sin(26695) + Math.cos(26696) * 20;
+acc += Math.sin(26696) + Math.cos(26697) * 21;
+acc += Math.sin(26697) + Math.cos(26698) * 22;
+acc += Math.sin(26698) + Math.cos(26699) * 23;
+acc += Math.sin(26699) + Math.cos(26700) * 24;
+acc += Math.sin(26700) + Math.cos(26701) * 25;
+acc += Math.sin(26701) + Math.cos(26702) * 26;
+acc += Math.sin(26702) + Math.cos(26703) * 27;
+acc += Math.sin(26703) + Math.cos(26704) * 28;
+acc += Math.sin(26704) + Math.cos(26705) * 29;
+acc += Math.sin(26705) + Math.cos(26706) * 30;
+acc += Math.sin(26706) + Math.cos(26707) * 31;
+acc += Math.sin(26707) + Math.cos(26708) * 32;
+acc += Math.sin(26708) + Math.cos(26709) * 33;
+acc += Math.sin(26709) + Math.cos(26710) * 34;
+acc += Math.sin(26710) + Math.cos(26711) * 35;
+acc += Math.sin(26711) + Math.cos(26712) * 36;
+acc += Math.sin(26712) + Math.cos(26713) * 37;
+acc += Math.sin(26713) + Math.cos(26714) * 38;
+acc += Math.sin(26714) + Math.cos(26715) * 39;
+acc += Math.sin(26715) + Math.cos(26716) * 40;
+acc += Math.sin(26716) + Math.cos(26717) * 41;
+acc += Math.sin(26717) + Math.cos(26718) * 42;
+acc += Math.sin(26718) + Math.cos(26719) * 43;
+acc += Math.sin(26719) + Math.cos(26720) * 44;
+acc += Math.sin(26720) + Math.cos(26721) * 45;
+acc += Math.sin(26721) + Math.cos(26722) * 46;
+acc += Math.sin(26722) + Math.cos(26723) * 47;
+acc += Math.sin(26723) + Math.cos(26724) * 48;
+acc += Math.sin(26724) + Math.cos(26725) * 49;
+acc += Math.sin(26725) + Math.cos(26726) * 50;
+acc += Math.sin(26726) + Math.cos(26727) * 51;
+acc += Math.sin(26727) + Math.cos(26728) * 52;
+acc += Math.sin(26728) + Math.cos(26729) * 53;
+acc += Math.sin(26729) + Math.cos(26730) * 54;
+acc += Math.sin(26730) + Math.cos(26731) * 55;
+acc += Math.sin(26731) + Math.cos(26732) * 56;
+acc += Math.sin(26732) + Math.cos(26733) * 57;
+acc += Math.sin(26733) + Math.cos(26734) * 58;
+acc += Math.sin(26734) + Math.cos(26735) * 59;
+acc += Math.sin(26735) + Math.cos(26736) * 60;
+acc += Math.sin(26736) + Math.cos(26737) * 61;
+acc += Math.sin(26737) + Math.cos(26738) * 62;
+acc += Math.sin(26738) + Math.cos(26739) * 63;
+acc += Math.sin(26739) + Math.cos(26740) * 64;
+acc += Math.sin(26740) + Math.cos(26741) * 65;
+acc += Math.sin(26741) + Math.cos(26742) * 66;
+acc += Math.sin(26742) + Math.cos(26743) * 67;
+acc += Math.sin(26743) + Math.cos(26744) * 68;
+acc += Math.sin(26744) + Math.cos(26745) * 69;
+acc += Math.sin(26745) + Math.cos(26746) * 70;
+acc += Math.sin(26746) + Math.cos(26747) * 71;
+acc += Math.sin(26747) + Math.cos(26748) * 72;
+acc += Math.sin(26748) + Math.cos(26749) * 73;
+acc += Math.sin(26749) + Math.cos(26750) * 74;
+acc += Math.sin(26750) + Math.cos(26751) * 75;
+acc += Math.sin(26751) + Math.cos(26752) * 76;
+acc += Math.sin(26752) + Math.cos(26753) * 77;
+acc += Math.sin(26753) + Math.cos(26754) * 78;
+acc += Math.sin(26754) + Math.cos(26755) * 79;
+acc += Math.sin(26755) + Math.cos(26756) * 80;
+acc += Math.sin(26756) + Math.cos(26757) * 81;
+acc += Math.sin(26757) + Math.cos(26758) * 82;
+acc += Math.sin(26758) + Math.cos(26759) * 83;
+acc += Math.sin(26759) + Math.cos(26760) * 84;
+acc += Math.sin(26760) + Math.cos(26761) * 85;
+acc += Math.sin(26761) + Math.cos(26762) * 86;
+acc += Math.sin(26762) + Math.cos(26763) * 87;
+acc += Math.sin(26763) + Math.cos(26764) * 88;
+acc += Math.sin(26764) + Math.cos(26765) * 89;
+acc += Math.sin(26765) + Math.cos(26766) * 90;
+acc += Math.sin(26766) + Math.cos(26767) * 91;
+acc += Math.sin(26767) + Math.cos(26768) * 92;
+acc += Math.sin(26768) + Math.cos(26769) * 93;
+acc += Math.sin(26769) + Math.cos(26770) * 94;
+acc += Math.sin(26770) + Math.cos(26771) * 95;
+acc += Math.sin(26771) + Math.cos(26772) * 96;
+acc += Math.sin(26772) + Math.cos(26773) * 0;
+acc += Math.sin(26773) + Math.cos(26774) * 1;
+acc += Math.sin(26774) + Math.cos(26775) * 2;
+acc += Math.sin(26775) + Math.cos(26776) * 3;
+acc += Math.sin(26776) + Math.cos(26777) * 4;
+acc += Math.sin(26777) + Math.cos(26778) * 5;
+acc += Math.sin(26778) + Math.cos(26779) * 6;
+acc += Math.sin(26779) + Math.cos(26780) * 7;
+acc += Math.sin(26780) + Math.cos(26781) * 8;
+acc += Math.sin(26781) + Math.cos(26782) * 9;
+acc += Math.sin(26782) + Math.cos(26783) * 10;
+acc += Math.sin(26783) + Math.cos(26784) * 11;
+acc += Math.sin(26784) + Math.cos(26785) * 12;
+acc += Math.sin(26785) + Math.cos(26786) * 13;
+acc += Math.sin(26786) + Math.cos(26787) * 14;
+acc += Math.sin(26787) + Math.cos(26788) * 15;
+acc += Math.sin(26788) + Math.cos(26789) * 16;
+acc += Math.sin(26789) + Math.cos(26790) * 17;
+acc += Math.sin(26790) + Math.cos(26791) * 18;
+acc += Math.sin(26791) + Math.cos(26792) * 19;
+acc += Math.sin(26792) + Math.cos(26793) * 20;
+acc += Math.sin(26793) + Math.cos(26794) * 21;
+acc += Math.sin(26794) + Math.cos(26795) * 22;
+acc += Math.sin(26795) + Math.cos(26796) * 23;
+acc += Math.sin(26796) + Math.cos(26797) * 24;
+acc += Math.sin(26797) + Math.cos(26798) * 25;
+acc += Math.sin(26798) + Math.cos(26799) * 26;
+acc += Math.sin(26799) + Math.cos(26800) * 27;
+acc += Math.sin(26800) + Math.cos(26801) * 28;
+acc += Math.sin(26801) + Math.cos(26802) * 29;
+acc += Math.sin(26802) + Math.cos(26803) * 30;
+acc += Math.sin(26803) + Math.cos(26804) * 31;
+acc += Math.sin(26804) + Math.cos(26805) * 32;
+acc += Math.sin(26805) + Math.cos(26806) * 33;
+acc += Math.sin(26806) + Math.cos(26807) * 34;
+acc += Math.sin(26807) + Math.cos(26808) * 35;
+acc += Math.sin(26808) + Math.cos(26809) * 36;
+acc += Math.sin(26809) + Math.cos(26810) * 37;
+acc += Math.sin(26810) + Math.cos(26811) * 38;
+acc += Math.sin(26811) + Math.cos(26812) * 39;
+acc += Math.sin(26812) + Math.cos(26813) * 40;
+acc += Math.sin(26813) + Math.cos(26814) * 41;
+acc += Math.sin(26814) + Math.cos(26815) * 42;
+acc += Math.sin(26815) + Math.cos(26816) * 43;
+acc += Math.sin(26816) + Math.cos(26817) * 44;
+acc += Math.sin(26817) + Math.cos(26818) * 45;
+acc += Math.sin(26818) + Math.cos(26819) * 46;
+acc += Math.sin(26819) + Math.cos(26820) * 47;
+acc += Math.sin(26820) + Math.cos(26821) * 48;
+acc += Math.sin(26821) + Math.cos(26822) * 49;
+acc += Math.sin(26822) + Math.cos(26823) * 50;
+acc += Math.sin(26823) + Math.cos(26824) * 51;
+acc += Math.sin(26824) + Math.cos(26825) * 52;
+acc += Math.sin(26825) + Math.cos(26826) * 53;
+acc += Math.sin(26826) + Math.cos(26827) * 54;
+acc += Math.sin(26827) + Math.cos(26828) * 55;
+acc += Math.sin(26828) + Math.cos(26829) * 56;
+acc += Math.sin(26829) + Math.cos(26830) * 57;
+acc += Math.sin(26830) + Math.cos(26831) * 58;
+acc += Math.sin(26831) + Math.cos(26832) * 59;
+acc += Math.sin(26832) + Math.cos(26833) * 60;
+acc += Math.sin(26833) + Math.cos(26834) * 61;
+acc += Math.sin(26834) + Math.cos(26835) * 62;
+acc += Math.sin(26835) + Math.cos(26836) * 63;
+acc += Math.sin(26836) + Math.cos(26837) * 64;
+acc += Math.sin(26837) + Math.cos(26838) * 65;
+acc += Math.sin(26838) + Math.cos(26839) * 66;
+acc += Math.sin(26839) + Math.cos(26840) * 67;
+acc += Math.sin(26840) + Math.cos(26841) * 68;
+acc += Math.sin(26841) + Math.cos(26842) * 69;
+acc += Math.sin(26842) + Math.cos(26843) * 70;
+acc += Math.sin(26843) + Math.cos(26844) * 71;
+acc += Math.sin(26844) + Math.cos(26845) * 72;
+acc += Math.sin(26845) + Math.cos(26846) * 73;
+acc += Math.sin(26846) + Math.cos(26847) * 74;
+acc += Math.sin(26847) + Math.cos(26848) * 75;
+acc += Math.sin(26848) + Math.cos(26849) * 76;
+acc += Math.sin(26849) + Math.cos(26850) * 77;
+acc += Math.sin(26850) + Math.cos(26851) * 78;
+acc += Math.sin(26851) + Math.cos(26852) * 79;
+acc += Math.sin(26852) + Math.cos(26853) * 80;
+acc += Math.sin(26853) + Math.cos(26854) * 81;
+acc += Math.sin(26854) + Math.cos(26855) * 82;
+acc += Math.sin(26855) + Math.cos(26856) * 83;
+acc += Math.sin(26856) + Math.cos(26857) * 84;
+acc += Math.sin(26857) + Math.cos(26858) * 85;
+acc += Math.sin(26858) + Math.cos(26859) * 86;
+acc += Math.sin(26859) + Math.cos(26860) * 87;
+acc += Math.sin(26860) + Math.cos(26861) * 88;
+acc += Math.sin(26861) + Math.cos(26862) * 89;
+acc += Math.sin(26862) + Math.cos(26863) * 90;
+acc += Math.sin(26863) + Math.cos(26864) * 91;
+acc += Math.sin(26864) + Math.cos(26865) * 92;
+acc += Math.sin(26865) + Math.cos(26866) * 93;
+acc += Math.sin(26866) + Math.cos(26867) * 94;
+acc += Math.sin(26867) + Math.cos(26868) * 95;
+acc += Math.sin(26868) + Math.cos(26869) * 96;
+acc += Math.sin(26869) + Math.cos(26870) * 0;
+acc += Math.sin(26870) + Math.cos(26871) * 1;
+acc += Math.sin(26871) + Math.cos(26872) * 2;
+acc += Math.sin(26872) + Math.cos(26873) * 3;
+acc += Math.sin(26873) + Math.cos(26874) * 4;
+acc += Math.sin(26874) + Math.cos(26875) * 5;
+acc += Math.sin(26875) + Math.cos(26876) * 6;
+acc += Math.sin(26876) + Math.cos(26877) * 7;
+acc += Math.sin(26877) + Math.cos(26878) * 8;
+acc += Math.sin(26878) + Math.cos(26879) * 9;
+acc += Math.sin(26879) + Math.cos(26880) * 10;
+acc += Math.sin(26880) + Math.cos(26881) * 11;
+acc += Math.sin(26881) + Math.cos(26882) * 12;
+acc += Math.sin(26882) + Math.cos(26883) * 13;
+acc += Math.sin(26883) + Math.cos(26884) * 14;
+acc += Math.sin(26884) + Math.cos(26885) * 15;
+acc += Math.sin(26885) + Math.cos(26886) * 16;
+acc += Math.sin(26886) + Math.cos(26887) * 17;
+acc += Math.sin(26887) + Math.cos(26888) * 18;
+acc += Math.sin(26888) + Math.cos(26889) * 19;
+acc += Math.sin(26889) + Math.cos(26890) * 20;
+acc += Math.sin(26890) + Math.cos(26891) * 21;
+acc += Math.sin(26891) + Math.cos(26892) * 22;
+acc += Math.sin(26892) + Math.cos(26893) * 23;
+acc += Math.sin(26893) + Math.cos(26894) * 24;
+acc += Math.sin(26894) + Math.cos(26895) * 25;
+acc += Math.sin(26895) + Math.cos(26896) * 26;
+acc += Math.sin(26896) + Math.cos(26897) * 27;
+acc += Math.sin(26897) + Math.cos(26898) * 28;
+acc += Math.sin(26898) + Math.cos(26899) * 29;
+acc += Math.sin(26899) + Math.cos(26900) * 30;
+acc += Math.sin(26900) + Math.cos(26901) * 31;
+acc += Math.sin(26901) + Math.cos(26902) * 32;
+acc += Math.sin(26902) + Math.cos(26903) * 33;
+acc += Math.sin(26903) + Math.cos(26904) * 34;
+acc += Math.sin(26904) + Math.cos(26905) * 35;
+acc += Math.sin(26905) + Math.cos(26906) * 36;
+acc += Math.sin(26906) + Math.cos(26907) * 37;
+acc += Math.sin(26907) + Math.cos(26908) * 38;
+acc += Math.sin(26908) + Math.cos(26909) * 39;
+acc += Math.sin(26909) + Math.cos(26910) * 40;
+acc += Math.sin(26910) + Math.cos(26911) * 41;
+acc += Math.sin(26911) + Math.cos(26912) * 42;
+acc += Math.sin(26912) + Math.cos(26913) * 43;
+acc += Math.sin(26913) + Math.cos(26914) * 44;
+acc += Math.sin(26914) + Math.cos(26915) * 45;
+acc += Math.sin(26915) + Math.cos(26916) * 46;
+acc += Math.sin(26916) + Math.cos(26917) * 47;
+acc += Math.sin(26917) + Math.cos(26918) * 48;
+acc += Math.sin(26918) + Math.cos(26919) * 49;
+acc += Math.sin(26919) + Math.cos(26920) * 50;
+acc += Math.sin(26920) + Math.cos(26921) * 51;
+acc += Math.sin(26921) + Math.cos(26922) * 52;
+acc += Math.sin(26922) + Math.cos(26923) * 53;
+acc += Math.sin(26923) + Math.cos(26924) * 54;
+acc += Math.sin(26924) + Math.cos(26925) * 55;
+acc += Math.sin(26925) + Math.cos(26926) * 56;
+acc += Math.sin(26926) + Math.cos(26927) * 57;
+acc += Math.sin(26927) + Math.cos(26928) * 58;
+acc += Math.sin(26928) + Math.cos(26929) * 59;
+acc += Math.sin(26929) + Math.cos(26930) * 60;
+acc += Math.sin(26930) + Math.cos(26931) * 61;
+acc += Math.sin(26931) + Math.cos(26932) * 62;
+acc += Math.sin(26932) + Math.cos(26933) * 63;
+acc += Math.sin(26933) + Math.cos(26934) * 64;
+acc += Math.sin(26934) + Math.cos(26935) * 65;
+acc += Math.sin(26935) + Math.cos(26936) * 66;
+acc += Math.sin(26936) + Math.cos(26937) * 67;
+acc += Math.sin(26937) + Math.cos(26938) * 68;
+acc += Math.sin(26938) + Math.cos(26939) * 69;
+acc += Math.sin(26939) + Math.cos(26940) * 70;
+acc += Math.sin(26940) + Math.cos(26941) * 71;
+acc += Math.sin(26941) + Math.cos(26942) * 72;
+acc += Math.sin(26942) + Math.cos(26943) * 73;
+acc += Math.sin(26943) + Math.cos(26944) * 74;
+acc += Math.sin(26944) + Math.cos(26945) * 75;
+acc += Math.sin(26945) + Math.cos(26946) * 76;
+acc += Math.sin(26946) + Math.cos(26947) * 77;
+acc += Math.sin(26947) + Math.cos(26948) * 78;
+acc += Math.sin(26948) + Math.cos(26949) * 79;
+acc += Math.sin(26949) + Math.cos(26950) * 80;
+acc += Math.sin(26950) + Math.cos(26951) * 81;
+acc += Math.sin(26951) + Math.cos(26952) * 82;
+acc += Math.sin(26952) + Math.cos(26953) * 83;
+acc += Math.sin(26953) + Math.cos(26954) * 84;
+acc += Math.sin(26954) + Math.cos(26955) * 85;
+acc += Math.sin(26955) + Math.cos(26956) * 86;
+acc += Math.sin(26956) + Math.cos(26957) * 87;
+acc += Math.sin(26957) + Math.cos(26958) * 88;
+acc += Math.sin(26958) + Math.cos(26959) * 89;
+acc += Math.sin(26959) + Math.cos(26960) * 90;
+acc += Math.sin(26960) + Math.cos(26961) * 91;
+acc += Math.sin(26961) + Math.cos(26962) * 92;
+acc += Math.sin(26962) + Math.cos(26963) * 93;
+acc += Math.sin(26963) + Math.cos(26964) * 94;
+acc += Math.sin(26964) + Math.cos(26965) * 95;
+acc += Math.sin(26965) + Math.cos(26966) * 96;
+acc += Math.sin(26966) + Math.cos(26967) * 0;
+acc += Math.sin(26967) + Math.cos(26968) * 1;
+acc += Math.sin(26968) + Math.cos(26969) * 2;
+acc += Math.sin(26969) + Math.cos(26970) * 3;
+acc += Math.sin(26970) + Math.cos(26971) * 4;
+acc += Math.sin(26971) + Math.cos(26972) * 5;
+acc += Math.sin(26972) + Math.cos(26973) * 6;
+acc += Math.sin(26973) + Math.cos(26974) * 7;
+acc += Math.sin(26974) + Math.cos(26975) * 8;
+acc += Math.sin(26975) + Math.cos(26976) * 9;
+acc += Math.sin(26976) + Math.cos(26977) * 10;
+acc += Math.sin(26977) + Math.cos(26978) * 11;
+acc += Math.sin(26978) + Math.cos(26979) * 12;
+acc += Math.sin(26979) + Math.cos(26980) * 13;
+acc += Math.sin(26980) + Math.cos(26981) * 14;
+acc += Math.sin(26981) + Math.cos(26982) * 15;
+acc += Math.sin(26982) + Math.cos(26983) * 16;
+acc += Math.sin(26983) + Math.cos(26984) * 17;
+acc += Math.sin(26984) + Math.cos(26985) * 18;
+acc += Math.sin(26985) + Math.cos(26986) * 19;
+acc += Math.sin(26986) + Math.cos(26987) * 20;
+acc += Math.sin(26987) + Math.cos(26988) * 21;
+acc += Math.sin(26988) + Math.cos(26989) * 22;
+acc += Math.sin(26989) + Math.cos(26990) * 23;
+acc += Math.sin(26990) + Math.cos(26991) * 24;
+acc += Math.sin(26991) + Math.cos(26992) * 25;
+acc += Math.sin(26992) + Math.cos(26993) * 26;
+acc += Math.sin(26993) + Math.cos(26994) * 27;
+acc += Math.sin(26994) + Math.cos(26995) * 28;
+acc += Math.sin(26995) + Math.cos(26996) * 29;
+acc += Math.sin(26996) + Math.cos(26997) * 30;
+acc += Math.sin(26997) + Math.cos(26998) * 31;
+acc += Math.sin(26998) + Math.cos(26999) * 32;
+acc += Math.sin(26999) + Math.cos(27000) * 33;
+acc += Math.sin(27000) + Math.cos(27001) * 34;
+acc += Math.sin(27001) + Math.cos(27002) * 35;
+acc += Math.sin(27002) + Math.cos(27003) * 36;
+acc += Math.sin(27003) + Math.cos(27004) * 37;
+acc += Math.sin(27004) + Math.cos(27005) * 38;
+acc += Math.sin(27005) + Math.cos(27006) * 39;
+acc += Math.sin(27006) + Math.cos(27007) * 40;
+acc += Math.sin(27007) + Math.cos(27008) * 41;
+acc += Math.sin(27008) + Math.cos(27009) * 42;
+acc += Math.sin(27009) + Math.cos(27010) * 43;
+acc += Math.sin(27010) + Math.cos(27011) * 44;
+acc += Math.sin(27011) + Math.cos(27012) * 45;
+acc += Math.sin(27012) + Math.cos(27013) * 46;
+acc += Math.sin(27013) + Math.cos(27014) * 47;
+acc += Math.sin(27014) + Math.cos(27015) * 48;
+acc += Math.sin(27015) + Math.cos(27016) * 49;
+acc += Math.sin(27016) + Math.cos(27017) * 50;
+acc += Math.sin(27017) + Math.cos(27018) * 51;
+acc += Math.sin(27018) + Math.cos(27019) * 52;
+acc += Math.sin(27019) + Math.cos(27020) * 53;
+acc += Math.sin(27020) + Math.cos(27021) * 54;
+acc += Math.sin(27021) + Math.cos(27022) * 55;
+acc += Math.sin(27022) + Math.cos(27023) * 56;
+acc += Math.sin(27023) + Math.cos(27024) * 57;
+acc += Math.sin(27024) + Math.cos(27025) * 58;
+acc += Math.sin(27025) + Math.cos(27026) * 59;
+acc += Math.sin(27026) + Math.cos(27027) * 60;
+acc += Math.sin(27027) + Math.cos(27028) * 61;
+acc += Math.sin(27028) + Math.cos(27029) * 62;
+acc += Math.sin(27029) + Math.cos(27030) * 63;
+acc += Math.sin(27030) + Math.cos(27031) * 64;
+acc += Math.sin(27031) + Math.cos(27032) * 65;
+acc += Math.sin(27032) + Math.cos(27033) * 66;
+acc += Math.sin(27033) + Math.cos(27034) * 67;
+acc += Math.sin(27034) + Math.cos(27035) * 68;
+acc += Math.sin(27035) + Math.cos(27036) * 69;
+acc += Math.sin(27036) + Math.cos(27037) * 70;
+acc += Math.sin(27037) + Math.cos(27038) * 71;
+acc += Math.sin(27038) + Math.cos(27039) * 72;
+acc += Math.sin(27039) + Math.cos(27040) * 73;
+acc += Math.sin(27040) + Math.cos(27041) * 74;
+acc += Math.sin(27041) + Math.cos(27042) * 75;
+acc += Math.sin(27042) + Math.cos(27043) * 76;
+acc += Math.sin(27043) + Math.cos(27044) * 77;
+acc += Math.sin(27044) + Math.cos(27045) * 78;
+acc += Math.sin(27045) + Math.cos(27046) * 79;
+acc += Math.sin(27046) + Math.cos(27047) * 80;
+acc += Math.sin(27047) + Math.cos(27048) * 81;
+acc += Math.sin(27048) + Math.cos(27049) * 82;
+acc += Math.sin(27049) + Math.cos(27050) * 83;
+acc += Math.sin(27050) + Math.cos(27051) * 84;
+acc += Math.sin(27051) + Math.cos(27052) * 85;
+acc += Math.sin(27052) + Math.cos(27053) * 86;
+acc += Math.sin(27053) + Math.cos(27054) * 87;
+acc += Math.sin(27054) + Math.cos(27055) * 88;
+acc += Math.sin(27055) + Math.cos(27056) * 89;
+acc += Math.sin(27056) + Math.cos(27057) * 90;
+acc += Math.sin(27057) + Math.cos(27058) * 91;
+acc += Math.sin(27058) + Math.cos(27059) * 92;
+acc += Math.sin(27059) + Math.cos(27060) * 93;
+acc += Math.sin(27060) + Math.cos(27061) * 94;
+acc += Math.sin(27061) + Math.cos(27062) * 95;
+acc += Math.sin(27062) + Math.cos(27063) * 96;
+acc += Math.sin(27063) + Math.cos(27064) * 0;
+acc += Math.sin(27064) + Math.cos(27065) * 1;
+acc += Math.sin(27065) + Math.cos(27066) * 2;
+acc += Math.sin(27066) + Math.cos(27067) * 3;
+acc += Math.sin(27067) + Math.cos(27068) * 4;
+acc += Math.sin(27068) + Math.cos(27069) * 5;
+acc += Math.sin(27069) + Math.cos(27070) * 6;
+acc += Math.sin(27070) + Math.cos(27071) * 7;
+acc += Math.sin(27071) + Math.cos(27072) * 8;
+acc += Math.sin(27072) + Math.cos(27073) * 9;
+acc += Math.sin(27073) + Math.cos(27074) * 10;
+acc += Math.sin(27074) + Math.cos(27075) * 11;
+acc += Math.sin(27075) + Math.cos(27076) * 12;
+acc += Math.sin(27076) + Math.cos(27077) * 13;
+acc += Math.sin(27077) + Math.cos(27078) * 14;
+acc += Math.sin(27078) + Math.cos(27079) * 15;
+acc += Math.sin(27079) + Math.cos(27080) * 16;
+acc += Math.sin(27080) + Math.cos(27081) * 17;
+acc += Math.sin(27081) + Math.cos(27082) * 18;
+acc += Math.sin(27082) + Math.cos(27083) * 19;
+acc += Math.sin(27083) + Math.cos(27084) * 20;
+acc += Math.sin(27084) + Math.cos(27085) * 21;
+acc += Math.sin(27085) + Math.cos(27086) * 22;
+acc += Math.sin(27086) + Math.cos(27087) * 23;
+acc += Math.sin(27087) + Math.cos(27088) * 24;
+acc += Math.sin(27088) + Math.cos(27089) * 25;
+acc += Math.sin(27089) + Math.cos(27090) * 26;
+acc += Math.sin(27090) + Math.cos(27091) * 27;
+acc += Math.sin(27091) + Math.cos(27092) * 28;
+acc += Math.sin(27092) + Math.cos(27093) * 29;
+acc += Math.sin(27093) + Math.cos(27094) * 30;
+acc += Math.sin(27094) + Math.cos(27095) * 31;
+acc += Math.sin(27095) + Math.cos(27096) * 32;
+acc += Math.sin(27096) + Math.cos(27097) * 33;
+acc += Math.sin(27097) + Math.cos(27098) * 34;
+acc += Math.sin(27098) + Math.cos(27099) * 35;
+acc += Math.sin(27099) + Math.cos(27100) * 36;
+acc += Math.sin(27100) + Math.cos(27101) * 37;
+acc += Math.sin(27101) + Math.cos(27102) * 38;
+acc += Math.sin(27102) + Math.cos(27103) * 39;
+acc += Math.sin(27103) + Math.cos(27104) * 40;
+acc += Math.sin(27104) + Math.cos(27105) * 41;
+acc += Math.sin(27105) + Math.cos(27106) * 42;
+acc += Math.sin(27106) + Math.cos(27107) * 43;
+acc += Math.sin(27107) + Math.cos(27108) * 44;
+acc += Math.sin(27108) + Math.cos(27109) * 45;
+acc += Math.sin(27109) + Math.cos(27110) * 46;
+acc += Math.sin(27110) + Math.cos(27111) * 47;
+acc += Math.sin(27111) + Math.cos(27112) * 48;
+acc += Math.sin(27112) + Math.cos(27113) * 49;
+acc += Math.sin(27113) + Math.cos(27114) * 50;
+acc += Math.sin(27114) + Math.cos(27115) * 51;
+acc += Math.sin(27115) + Math.cos(27116) * 52;
+acc += Math.sin(27116) + Math.cos(27117) * 53;
+acc += Math.sin(27117) + Math.cos(27118) * 54;
+acc += Math.sin(27118) + Math.cos(27119) * 55;
+acc += Math.sin(27119) + Math.cos(27120) * 56;
+acc += Math.sin(27120) + Math.cos(27121) * 57;
+acc += Math.sin(27121) + Math.cos(27122) * 58;
+acc += Math.sin(27122) + Math.cos(27123) * 59;
+acc += Math.sin(27123) + Math.cos(27124) * 60;
+acc += Math.sin(27124) + Math.cos(27125) * 61;
+acc += Math.sin(27125) + Math.cos(27126) * 62;
+acc += Math.sin(27126) + Math.cos(27127) * 63;
+acc += Math.sin(27127) + Math.cos(27128) * 64;
+acc += Math.sin(27128) + Math.cos(27129) * 65;
+acc += Math.sin(27129) + Math.cos(27130) * 66;
+acc += Math.sin(27130) + Math.cos(27131) * 67;
+acc += Math.sin(27131) + Math.cos(27132) * 68;
+acc += Math.sin(27132) + Math.cos(27133) * 69;
+acc += Math.sin(27133) + Math.cos(27134) * 70;
+acc += Math.sin(27134) + Math.cos(27135) * 71;
+acc += Math.sin(27135) + Math.cos(27136) * 72;
+acc += Math.sin(27136) + Math.cos(27137) * 73;
+acc += Math.sin(27137) + Math.cos(27138) * 74;
+acc += Math.sin(27138) + Math.cos(27139) * 75;
+acc += Math.sin(27139) + Math.cos(27140) * 76;
+acc += Math.sin(27140) + Math.cos(27141) * 77;
+acc += Math.sin(27141) + Math.cos(27142) * 78;
+acc += Math.sin(27142) + Math.cos(27143) * 79;
+acc += Math.sin(27143) + Math.cos(27144) * 80;
+acc += Math.sin(27144) + Math.cos(27145) * 81;
+acc += Math.sin(27145) + Math.cos(27146) * 82;
+acc += Math.sin(27146) + Math.cos(27147) * 83;
+acc += Math.sin(27147) + Math.cos(27148) * 84;
+acc += Math.sin(27148) + Math.cos(27149) * 85;
+acc += Math.sin(27149) + Math.cos(27150) * 86;
+acc += Math.sin(27150) + Math.cos(27151) * 87;
+acc += Math.sin(27151) + Math.cos(27152) * 88;
+acc += Math.sin(27152) + Math.cos(27153) * 89;
+acc += Math.sin(27153) + Math.cos(27154) * 90;
+acc += Math.sin(27154) + Math.cos(27155) * 91;
+acc += Math.sin(27155) + Math.cos(27156) * 92;
+acc += Math.sin(27156) + Math.cos(27157) * 93;
+acc += Math.sin(27157) + Math.cos(27158) * 94;
+acc += Math.sin(27158) + Math.cos(27159) * 95;
+acc += Math.sin(27159) + Math.cos(27160) * 96;
+acc += Math.sin(27160) + Math.cos(27161) * 0;
+acc += Math.sin(27161) + Math.cos(27162) * 1;
+acc += Math.sin(27162) + Math.cos(27163) * 2;
+acc += Math.sin(27163) + Math.cos(27164) * 3;
+acc += Math.sin(27164) + Math.cos(27165) * 4;
+acc += Math.sin(27165) + Math.cos(27166) * 5;
+acc += Math.sin(27166) + Math.cos(27167) * 6;
+acc += Math.sin(27167) + Math.cos(27168) * 7;
+acc += Math.sin(27168) + Math.cos(27169) * 8;
+acc += Math.sin(27169) + Math.cos(27170) * 9;
+acc += Math.sin(27170) + Math.cos(27171) * 10;
+acc += Math.sin(27171) + Math.cos(27172) * 11;
+acc += Math.sin(27172) + Math.cos(27173) * 12;
+acc += Math.sin(27173) + Math.cos(27174) * 13;
+acc += Math.sin(27174) + Math.cos(27175) * 14;
+acc += Math.sin(27175) + Math.cos(27176) * 15;
+acc += Math.sin(27176) + Math.cos(27177) * 16;
+acc += Math.sin(27177) + Math.cos(27178) * 17;
+acc += Math.sin(27178) + Math.cos(27179) * 18;
+acc += Math.sin(27179) + Math.cos(27180) * 19;
+acc += Math.sin(27180) + Math.cos(27181) * 20;
+acc += Math.sin(27181) + Math.cos(27182) * 21;
+acc += Math.sin(27182) + Math.cos(27183) * 22;
+acc += Math.sin(27183) + Math.cos(27184) * 23;
+acc += Math.sin(27184) + Math.cos(27185) * 24;
+acc += Math.sin(27185) + Math.cos(27186) * 25;
+acc += Math.sin(27186) + Math.cos(27187) * 26;
+acc += Math.sin(27187) + Math.cos(27188) * 27;
+acc += Math.sin(27188) + Math.cos(27189) * 28;
+acc += Math.sin(27189) + Math.cos(27190) * 29;
+acc += Math.sin(27190) + Math.cos(27191) * 30;
+acc += Math.sin(27191) + Math.cos(27192) * 31;
+acc += Math.sin(27192) + Math.cos(27193) * 32;
+acc += Math.sin(27193) + Math.cos(27194) * 33;
+acc += Math.sin(27194) + Math.cos(27195) * 34;
+acc += Math.sin(27195) + Math.cos(27196) * 35;
+acc += Math.sin(27196) + Math.cos(27197) * 36;
+acc += Math.sin(27197) + Math.cos(27198) * 37;
+acc += Math.sin(27198) + Math.cos(27199) * 38;
+acc += Math.sin(27199) + Math.cos(27200) * 39;
+acc += Math.sin(27200) + Math.cos(27201) * 40;
+acc += Math.sin(27201) + Math.cos(27202) * 41;
+acc += Math.sin(27202) + Math.cos(27203) * 42;
+acc += Math.sin(27203) + Math.cos(27204) * 43;
+acc += Math.sin(27204) + Math.cos(27205) * 44;
+acc += Math.sin(27205) + Math.cos(27206) * 45;
+acc += Math.sin(27206) + Math.cos(27207) * 46;
+acc += Math.sin(27207) + Math.cos(27208) * 47;
+acc += Math.sin(27208) + Math.cos(27209) * 48;
+acc += Math.sin(27209) + Math.cos(27210) * 49;
+acc += Math.sin(27210) + Math.cos(27211) * 50;
+acc += Math.sin(27211) + Math.cos(27212) * 51;
+acc += Math.sin(27212) + Math.cos(27213) * 52;
+acc += Math.sin(27213) + Math.cos(27214) * 53;
+acc += Math.sin(27214) + Math.cos(27215) * 54;
+acc += Math.sin(27215) + Math.cos(27216) * 55;
+acc += Math.sin(27216) + Math.cos(27217) * 56;
+acc += Math.sin(27217) + Math.cos(27218) * 57;
+acc += Math.sin(27218) + Math.cos(27219) * 58;
+acc += Math.sin(27219) + Math.cos(27220) * 59;
+acc += Math.sin(27220) + Math.cos(27221) * 60;
+acc += Math.sin(27221) + Math.cos(27222) * 61;
+acc += Math.sin(27222) + Math.cos(27223) * 62;
+acc += Math.sin(27223) + Math.cos(27224) * 63;
+acc += Math.sin(27224) + Math.cos(27225) * 64;
+acc += Math.sin(27225) + Math.cos(27226) * 65;
+acc += Math.sin(27226) + Math.cos(27227) * 66;
+acc += Math.sin(27227) + Math.cos(27228) * 67;
+acc += Math.sin(27228) + Math.cos(27229) * 68;
+acc += Math.sin(27229) + Math.cos(27230) * 69;
+acc += Math.sin(27230) + Math.cos(27231) * 70;
+acc += Math.sin(27231) + Math.cos(27232) * 71;
+acc += Math.sin(27232) + Math.cos(27233) * 72;
+acc += Math.sin(27233) + Math.cos(27234) * 73;
+acc += Math.sin(27234) + Math.cos(27235) * 74;
+acc += Math.sin(27235) + Math.cos(27236) * 75;
+acc += Math.sin(27236) + Math.cos(27237) * 76;
+acc += Math.sin(27237) + Math.cos(27238) * 77;
+acc += Math.sin(27238) + Math.cos(27239) * 78;
+acc += Math.sin(27239) + Math.cos(27240) * 79;
+acc += Math.sin(27240) + Math.cos(27241) * 80;
+acc += Math.sin(27241) + Math.cos(27242) * 81;
+acc += Math.sin(27242) + Math.cos(27243) * 82;
+acc += Math.sin(27243) + Math.cos(27244) * 83;
+acc += Math.sin(27244) + Math.cos(27245) * 84;
+acc += Math.sin(27245) + Math.cos(27246) * 85;
+acc += Math.sin(27246) + Math.cos(27247) * 86;
+acc += Math.sin(27247) + Math.cos(27248) * 87;
+acc += Math.sin(27248) + Math.cos(27249) * 88;
+acc += Math.sin(27249) + Math.cos(27250) * 89;
+acc += Math.sin(27250) + Math.cos(27251) * 90;
+acc += Math.sin(27251) + Math.cos(27252) * 91;
+acc += Math.sin(27252) + Math.cos(27253) * 92;
+acc += Math.sin(27253) + Math.cos(27254) * 93;
+acc += Math.sin(27254) + Math.cos(27255) * 94;
+acc += Math.sin(27255) + Math.cos(27256) * 95;
+acc += Math.sin(27256) + Math.cos(27257) * 96;
+acc += Math.sin(27257) + Math.cos(27258) * 0;
+acc += Math.sin(27258) + Math.cos(27259) * 1;
+acc += Math.sin(27259) + Math.cos(27260) * 2;
+acc += Math.sin(27260) + Math.cos(27261) * 3;
+acc += Math.sin(27261) + Math.cos(27262) * 4;
+acc += Math.sin(27262) + Math.cos(27263) * 5;
+acc += Math.sin(27263) + Math.cos(27264) * 6;
+acc += Math.sin(27264) + Math.cos(27265) * 7;
+acc += Math.sin(27265) + Math.cos(27266) * 8;
+acc += Math.sin(27266) + Math.cos(27267) * 9;
+acc += Math.sin(27267) + Math.cos(27268) * 10;
+acc += Math.sin(27268) + Math.cos(27269) * 11;
+acc += Math.sin(27269) + Math.cos(27270) * 12;
+acc += Math.sin(27270) + Math.cos(27271) * 13;
+acc += Math.sin(27271) + Math.cos(27272) * 14;
+acc += Math.sin(27272) + Math.cos(27273) * 15;
+acc += Math.sin(27273) + Math.cos(27274) * 16;
+acc += Math.sin(27274) + Math.cos(27275) * 17;
+acc += Math.sin(27275) + Math.cos(27276) * 18;
+acc += Math.sin(27276) + Math.cos(27277) * 19;
+acc += Math.sin(27277) + Math.cos(27278) * 20;
+acc += Math.sin(27278) + Math.cos(27279) * 21;
+acc += Math.sin(27279) + Math.cos(27280) * 22;
+acc += Math.sin(27280) + Math.cos(27281) * 23;
+acc += Math.sin(27281) + Math.cos(27282) * 24;
+acc += Math.sin(27282) + Math.cos(27283) * 25;
+acc += Math.sin(27283) + Math.cos(27284) * 26;
+acc += Math.sin(27284) + Math.cos(27285) * 27;
+acc += Math.sin(27285) + Math.cos(27286) * 28;
+acc += Math.sin(27286) + Math.cos(27287) * 29;
+acc += Math.sin(27287) + Math.cos(27288) * 30;
+acc += Math.sin(27288) + Math.cos(27289) * 31;
+acc += Math.sin(27289) + Math.cos(27290) * 32;
+acc += Math.sin(27290) + Math.cos(27291) * 33;
+acc += Math.sin(27291) + Math.cos(27292) * 34;
+acc += Math.sin(27292) + Math.cos(27293) * 35;
+acc += Math.sin(27293) + Math.cos(27294) * 36;
+acc += Math.sin(27294) + Math.cos(27295) * 37;
+acc += Math.sin(27295) + Math.cos(27296) * 38;
+acc += Math.sin(27296) + Math.cos(27297) * 39;
+acc += Math.sin(27297) + Math.cos(27298) * 40;
+acc += Math.sin(27298) + Math.cos(27299) * 41;
+acc += Math.sin(27299) + Math.cos(27300) * 42;
+acc += Math.sin(27300) + Math.cos(27301) * 43;
+acc += Math.sin(27301) + Math.cos(27302) * 44;
+acc += Math.sin(27302) + Math.cos(27303) * 45;
+acc += Math.sin(27303) + Math.cos(27304) * 46;
+acc += Math.sin(27304) + Math.cos(27305) * 47;
+acc += Math.sin(27305) + Math.cos(27306) * 48;
+acc += Math.sin(27306) + Math.cos(27307) * 49;
+acc += Math.sin(27307) + Math.cos(27308) * 50;
+acc += Math.sin(27308) + Math.cos(27309) * 51;
+acc += Math.sin(27309) + Math.cos(27310) * 52;
+acc += Math.sin(27310) + Math.cos(27311) * 53;
+acc += Math.sin(27311) + Math.cos(27312) * 54;
+acc += Math.sin(27312) + Math.cos(27313) * 55;
+acc += Math.sin(27313) + Math.cos(27314) * 56;
+acc += Math.sin(27314) + Math.cos(27315) * 57;
+acc += Math.sin(27315) + Math.cos(27316) * 58;
+acc += Math.sin(27316) + Math.cos(27317) * 59;
+acc += Math.sin(27317) + Math.cos(27318) * 60;
+acc += Math.sin(27318) + Math.cos(27319) * 61;
+acc += Math.sin(27319) + Math.cos(27320) * 62;
+acc += Math.sin(27320) + Math.cos(27321) * 63;
+acc += Math.sin(27321) + Math.cos(27322) * 64;
+acc += Math.sin(27322) + Math.cos(27323) * 65;
+acc += Math.sin(27323) + Math.cos(27324) * 66;
+acc += Math.sin(27324) + Math.cos(27325) * 67;
+acc += Math.sin(27325) + Math.cos(27326) * 68;
+acc += Math.sin(27326) + Math.cos(27327) * 69;
+acc += Math.sin(27327) + Math.cos(27328) * 70;
+acc += Math.sin(27328) + Math.cos(27329) * 71;
+acc += Math.sin(27329) + Math.cos(27330) * 72;
+acc += Math.sin(27330) + Math.cos(27331) * 73;
+acc += Math.sin(27331) + Math.cos(27332) * 74;
+acc += Math.sin(27332) + Math.cos(27333) * 75;
+acc += Math.sin(27333) + Math.cos(27334) * 76;
+acc += Math.sin(27334) + Math.cos(27335) * 77;
+acc += Math.sin(27335) + Math.cos(27336) * 78;
+acc += Math.sin(27336) + Math.cos(27337) * 79;
+acc += Math.sin(27337) + Math.cos(27338) * 80;
+acc += Math.sin(27338) + Math.cos(27339) * 81;
+acc += Math.sin(27339) + Math.cos(27340) * 82;
+acc += Math.sin(27340) + Math.cos(27341) * 83;
+acc += Math.sin(27341) + Math.cos(27342) * 84;
+acc += Math.sin(27342) + Math.cos(27343) * 85;
+acc += Math.sin(27343) + Math.cos(27344) * 86;
+acc += Math.sin(27344) + Math.cos(27345) * 87;
+acc += Math.sin(27345) + Math.cos(27346) * 88;
+acc += Math.sin(27346) + Math.cos(27347) * 89;
+acc += Math.sin(27347) + Math.cos(27348) * 90;
+acc += Math.sin(27348) + Math.cos(27349) * 91;
+acc += Math.sin(27349) + Math.cos(27350) * 92;
+acc += Math.sin(27350) + Math.cos(27351) * 93;
+acc += Math.sin(27351) + Math.cos(27352) * 94;
+acc += Math.sin(27352) + Math.cos(27353) * 95;
+acc += Math.sin(27353) + Math.cos(27354) * 96;
+acc += Math.sin(27354) + Math.cos(27355) * 0;
+acc += Math.sin(27355) + Math.cos(27356) * 1;
+acc += Math.sin(27356) + Math.cos(27357) * 2;
+acc += Math.sin(27357) + Math.cos(27358) * 3;
+acc += Math.sin(27358) + Math.cos(27359) * 4;
+acc += Math.sin(27359) + Math.cos(27360) * 5;
+acc += Math.sin(27360) + Math.cos(27361) * 6;
+acc += Math.sin(27361) + Math.cos(27362) * 7;
+acc += Math.sin(27362) + Math.cos(27363) * 8;
+acc += Math.sin(27363) + Math.cos(27364) * 9;
+acc += Math.sin(27364) + Math.cos(27365) * 10;
+acc += Math.sin(27365) + Math.cos(27366) * 11;
+acc += Math.sin(27366) + Math.cos(27367) * 12;
+acc += Math.sin(27367) + Math.cos(27368) * 13;
+acc += Math.sin(27368) + Math.cos(27369) * 14;
+acc += Math.sin(27369) + Math.cos(27370) * 15;
+acc += Math.sin(27370) + Math.cos(27371) * 16;
+acc += Math.sin(27371) + Math.cos(27372) * 17;
+acc += Math.sin(27372) + Math.cos(27373) * 18;
+acc += Math.sin(27373) + Math.cos(27374) * 19;
+acc += Math.sin(27374) + Math.cos(27375) * 20;
+acc += Math.sin(27375) + Math.cos(27376) * 21;
+acc += Math.sin(27376) + Math.cos(27377) * 22;
+acc += Math.sin(27377) + Math.cos(27378) * 23;
+acc += Math.sin(27378) + Math.cos(27379) * 24;
+acc += Math.sin(27379) + Math.cos(27380) * 25;
+acc += Math.sin(27380) + Math.cos(27381) * 26;
+acc += Math.sin(27381) + Math.cos(27382) * 27;
+acc += Math.sin(27382) + Math.cos(27383) * 28;
+acc += Math.sin(27383) + Math.cos(27384) * 29;
+acc += Math.sin(27384) + Math.cos(27385) * 30;
+acc += Math.sin(27385) + Math.cos(27386) * 31;
+acc += Math.sin(27386) + Math.cos(27387) * 32;
+acc += Math.sin(27387) + Math.cos(27388) * 33;
+acc += Math.sin(27388) + Math.cos(27389) * 34;
+acc += Math.sin(27389) + Math.cos(27390) * 35;
+acc += Math.sin(27390) + Math.cos(27391) * 36;
+acc += Math.sin(27391) + Math.cos(27392) * 37;
+acc += Math.sin(27392) + Math.cos(27393) * 38;
+acc += Math.sin(27393) + Math.cos(27394) * 39;
+acc += Math.sin(27394) + Math.cos(27395) * 40;
+acc += Math.sin(27395) + Math.cos(27396) * 41;
+acc += Math.sin(27396) + Math.cos(27397) * 42;
+acc += Math.sin(27397) + Math.cos(27398) * 43;
+acc += Math.sin(27398) + Math.cos(27399) * 44;
+acc += Math.sin(27399) + Math.cos(27400) * 45;
+acc += Math.sin(27400) + Math.cos(27401) * 46;
+acc += Math.sin(27401) + Math.cos(27402) * 47;
+acc += Math.sin(27402) + Math.cos(27403) * 48;
+acc += Math.sin(27403) + Math.cos(27404) * 49;
+acc += Math.sin(27404) + Math.cos(27405) * 50;
+acc += Math.sin(27405) + Math.cos(27406) * 51;
+acc += Math.sin(27406) + Math.cos(27407) * 52;
+acc += Math.sin(27407) + Math.cos(27408) * 53;
+acc += Math.sin(27408) + Math.cos(27409) * 54;
+acc += Math.sin(27409) + Math.cos(27410) * 55;
+acc += Math.sin(27410) + Math.cos(27411) * 56;
+acc += Math.sin(27411) + Math.cos(27412) * 57;
+acc += Math.sin(27412) + Math.cos(27413) * 58;
+acc += Math.sin(27413) + Math.cos(27414) * 59;
+acc += Math.sin(27414) + Math.cos(27415) * 60;
+acc += Math.sin(27415) + Math.cos(27416) * 61;
+acc += Math.sin(27416) + Math.cos(27417) * 62;
+acc += Math.sin(27417) + Math.cos(27418) * 63;
+acc += Math.sin(27418) + Math.cos(27419) * 64;
+acc += Math.sin(27419) + Math.cos(27420) * 65;
+acc += Math.sin(27420) + Math.cos(27421) * 66;
+acc += Math.sin(27421) + Math.cos(27422) * 67;
+acc += Math.sin(27422) + Math.cos(27423) * 68;
+acc += Math.sin(27423) + Math.cos(27424) * 69;
+acc += Math.sin(27424) + Math.cos(27425) * 70;
+acc += Math.sin(27425) + Math.cos(27426) * 71;
+acc += Math.sin(27426) + Math.cos(27427) * 72;
+acc += Math.sin(27427) + Math.cos(27428) * 73;
+acc += Math.sin(27428) + Math.cos(27429) * 74;
+acc += Math.sin(27429) + Math.cos(27430) * 75;
+acc += Math.sin(27430) + Math.cos(27431) * 76;
+acc += Math.sin(27431) + Math.cos(27432) * 77;
+acc += Math.sin(27432) + Math.cos(27433) * 78;
+acc += Math.sin(27433) + Math.cos(27434) * 79;
+acc += Math.sin(27434) + Math.cos(27435) * 80;
+acc += Math.sin(27435) + Math.cos(27436) * 81;
+acc += Math.sin(27436) + Math.cos(27437) * 82;
+acc += Math.sin(27437) + Math.cos(27438) * 83;
+acc += Math.sin(27438) + Math.cos(27439) * 84;
+acc += Math.sin(27439) + Math.cos(27440) * 85;
+acc += Math.sin(27440) + Math.cos(27441) * 86;
+acc += Math.sin(27441) + Math.cos(27442) * 87;
+acc += Math.sin(27442) + Math.cos(27443) * 88;
+acc += Math.sin(27443) + Math.cos(27444) * 89;
+acc += Math.sin(27444) + Math.cos(27445) * 90;
+acc += Math.sin(27445) + Math.cos(27446) * 91;
+acc += Math.sin(27446) + Math.cos(27447) * 92;
+acc += Math.sin(27447) + Math.cos(27448) * 93;
+acc += Math.sin(27448) + Math.cos(27449) * 94;
+acc += Math.sin(27449) + Math.cos(27450) * 95;
+acc += Math.sin(27450) + Math.cos(27451) * 96;
+acc += Math.sin(27451) + Math.cos(27452) * 0;
+acc += Math.sin(27452) + Math.cos(27453) * 1;
+acc += Math.sin(27453) + Math.cos(27454) * 2;
+acc += Math.sin(27454) + Math.cos(27455) * 3;
+acc += Math.sin(27455) + Math.cos(27456) * 4;
+acc += Math.sin(27456) + Math.cos(27457) * 5;
+acc += Math.sin(27457) + Math.cos(27458) * 6;
+acc += Math.sin(27458) + Math.cos(27459) * 7;
+acc += Math.sin(27459) + Math.cos(27460) * 8;
+acc += Math.sin(27460) + Math.cos(27461) * 9;
+acc += Math.sin(27461) + Math.cos(27462) * 10;
+acc += Math.sin(27462) + Math.cos(27463) * 11;
+acc += Math.sin(27463) + Math.cos(27464) * 12;
+acc += Math.sin(27464) + Math.cos(27465) * 13;
+acc += Math.sin(27465) + Math.cos(27466) * 14;
+acc += Math.sin(27466) + Math.cos(27467) * 15;
+acc += Math.sin(27467) + Math.cos(27468) * 16;
+acc += Math.sin(27468) + Math.cos(27469) * 17;
+acc += Math.sin(27469) + Math.cos(27470) * 18;
+acc += Math.sin(27470) + Math.cos(27471) * 19;
+acc += Math.sin(27471) + Math.cos(27472) * 20;
+acc += Math.sin(27472) + Math.cos(27473) * 21;
+acc += Math.sin(27473) + Math.cos(27474) * 22;
+acc += Math.sin(27474) + Math.cos(27475) * 23;
+acc += Math.sin(27475) + Math.cos(27476) * 24;
+acc += Math.sin(27476) + Math.cos(27477) * 25;
+acc += Math.sin(27477) + Math.cos(27478) * 26;
+acc += Math.sin(27478) + Math.cos(27479) * 27;
+acc += Math.sin(27479) + Math.cos(27480) * 28;
+acc += Math.sin(27480) + Math.cos(27481) * 29;
+acc += Math.sin(27481) + Math.cos(27482) * 30;
+acc += Math.sin(27482) + Math.cos(27483) * 31;
+acc += Math.sin(27483) + Math.cos(27484) * 32;
+acc += Math.sin(27484) + Math.cos(27485) * 33;
+acc += Math.sin(27485) + Math.cos(27486) * 34;
+acc += Math.sin(27486) + Math.cos(27487) * 35;
+acc += Math.sin(27487) + Math.cos(27488) * 36;
+acc += Math.sin(27488) + Math.cos(27489) * 37;
+acc += Math.sin(27489) + Math.cos(27490) * 38;
+acc += Math.sin(27490) + Math.cos(27491) * 39;
+acc += Math.sin(27491) + Math.cos(27492) * 40;
+acc += Math.sin(27492) + Math.cos(27493) * 41;
+acc += Math.sin(27493) + Math.cos(27494) * 42;
+acc += Math.sin(27494) + Math.cos(27495) * 43;
+acc += Math.sin(27495) + Math.cos(27496) * 44;
+acc += Math.sin(27496) + Math.cos(27497) * 45;
+acc += Math.sin(27497) + Math.cos(27498) * 46;
+acc += Math.sin(27498) + Math.cos(27499) * 47;
+acc += Math.sin(27499) + Math.cos(27500) * 48;
+acc += Math.sin(27500) + Math.cos(27501) * 49;
+acc += Math.sin(27501) + Math.cos(27502) * 50;
+acc += Math.sin(27502) + Math.cos(27503) * 51;
+acc += Math.sin(27503) + Math.cos(27504) * 52;
+acc += Math.sin(27504) + Math.cos(27505) * 53;
+acc += Math.sin(27505) + Math.cos(27506) * 54;
+acc += Math.sin(27506) + Math.cos(27507) * 55;
+acc += Math.sin(27507) + Math.cos(27508) * 56;
+acc += Math.sin(27508) + Math.cos(27509) * 57;
+acc += Math.sin(27509) + Math.cos(27510) * 58;
+acc += Math.sin(27510) + Math.cos(27511) * 59;
+acc += Math.sin(27511) + Math.cos(27512) * 60;
+acc += Math.sin(27512) + Math.cos(27513) * 61;
+acc += Math.sin(27513) + Math.cos(27514) * 62;
+acc += Math.sin(27514) + Math.cos(27515) * 63;
+acc += Math.sin(27515) + Math.cos(27516) * 64;
+acc += Math.sin(27516) + Math.cos(27517) * 65;
+acc += Math.sin(27517) + Math.cos(27518) * 66;
+acc += Math.sin(27518) + Math.cos(27519) * 67;
+acc += Math.sin(27519) + Math.cos(27520) * 68;
+acc += Math.sin(27520) + Math.cos(27521) * 69;
+acc += Math.sin(27521) + Math.cos(27522) * 70;
+acc += Math.sin(27522) + Math.cos(27523) * 71;
+acc += Math.sin(27523) + Math.cos(27524) * 72;
+acc += Math.sin(27524) + Math.cos(27525) * 73;
+acc += Math.sin(27525) + Math.cos(27526) * 74;
+acc += Math.sin(27526) + Math.cos(27527) * 75;
+acc += Math.sin(27527) + Math.cos(27528) * 76;
+acc += Math.sin(27528) + Math.cos(27529) * 77;
+acc += Math.sin(27529) + Math.cos(27530) * 78;
+acc += Math.sin(27530) + Math.cos(27531) * 79;
+acc += Math.sin(27531) + Math.cos(27532) * 80;
+acc += Math.sin(27532) + Math.cos(27533) * 81;
+acc += Math.sin(27533) + Math.cos(27534) * 82;
+acc += Math.sin(27534) + Math.cos(27535) * 83;
+acc += Math.sin(27535) + Math.cos(27536) * 84;
+acc += Math.sin(27536) + Math.cos(27537) * 85;
+acc += Math.sin(27537) + Math.cos(27538) * 86;
+acc += Math.sin(27538) + Math.cos(27539) * 87;
+acc += Math.sin(27539) + Math.cos(27540) * 88;
+acc += Math.sin(27540) + Math.cos(27541) * 89;
+acc += Math.sin(27541) + Math.cos(27542) * 90;
+acc += Math.sin(27542) + Math.cos(27543) * 91;
+acc += Math.sin(27543) + Math.cos(27544) * 92;
+acc += Math.sin(27544) + Math.cos(27545) * 93;
+acc += Math.sin(27545) + Math.cos(27546) * 94;
+acc += Math.sin(27546) + Math.cos(27547) * 95;
+acc += Math.sin(27547) + Math.cos(27548) * 96;
+acc += Math.sin(27548) + Math.cos(27549) * 0;
+acc += Math.sin(27549) + Math.cos(27550) * 1;
+acc += Math.sin(27550) + Math.cos(27551) * 2;
+acc += Math.sin(27551) + Math.cos(27552) * 3;
+acc += Math.sin(27552) + Math.cos(27553) * 4;
+acc += Math.sin(27553) + Math.cos(27554) * 5;
+acc += Math.sin(27554) + Math.cos(27555) * 6;
+acc += Math.sin(27555) + Math.cos(27556) * 7;
+acc += Math.sin(27556) + Math.cos(27557) * 8;
+acc += Math.sin(27557) + Math.cos(27558) * 9;
+acc += Math.sin(27558) + Math.cos(27559) * 10;
+acc += Math.sin(27559) + Math.cos(27560) * 11;
+acc += Math.sin(27560) + Math.cos(27561) * 12;
+acc += Math.sin(27561) + Math.cos(27562) * 13;
+acc += Math.sin(27562) + Math.cos(27563) * 14;
+acc += Math.sin(27563) + Math.cos(27564) * 15;
+acc += Math.sin(27564) + Math.cos(27565) * 16;
+acc += Math.sin(27565) + Math.cos(27566) * 17;
+acc += Math.sin(27566) + Math.cos(27567) * 18;
+acc += Math.sin(27567) + Math.cos(27568) * 19;
+acc += Math.sin(27568) + Math.cos(27569) * 20;
+acc += Math.sin(27569) + Math.cos(27570) * 21;
+acc += Math.sin(27570) + Math.cos(27571) * 22;
+acc += Math.sin(27571) + Math.cos(27572) * 23;
+acc += Math.sin(27572) + Math.cos(27573) * 24;
+acc += Math.sin(27573) + Math.cos(27574) * 25;
+acc += Math.sin(27574) + Math.cos(27575) * 26;
+acc += Math.sin(27575) + Math.cos(27576) * 27;
+acc += Math.sin(27576) + Math.cos(27577) * 28;
+acc += Math.sin(27577) + Math.cos(27578) * 29;
+acc += Math.sin(27578) + Math.cos(27579) * 30;
+acc += Math.sin(27579) + Math.cos(27580) * 31;
+acc += Math.sin(27580) + Math.cos(27581) * 32;
+acc += Math.sin(27581) + Math.cos(27582) * 33;
+acc += Math.sin(27582) + Math.cos(27583) * 34;
+acc += Math.sin(27583) + Math.cos(27584) * 35;
+acc += Math.sin(27584) + Math.cos(27585) * 36;
+acc += Math.sin(27585) + Math.cos(27586) * 37;
+acc += Math.sin(27586) + Math.cos(27587) * 38;
+acc += Math.sin(27587) + Math.cos(27588) * 39;
+acc += Math.sin(27588) + Math.cos(27589) * 40;
+acc += Math.sin(27589) + Math.cos(27590) * 41;
+acc += Math.sin(27590) + Math.cos(27591) * 42;
+acc += Math.sin(27591) + Math.cos(27592) * 43;
+acc += Math.sin(27592) + Math.cos(27593) * 44;
+acc += Math.sin(27593) + Math.cos(27594) * 45;
+acc += Math.sin(27594) + Math.cos(27595) * 46;
+acc += Math.sin(27595) + Math.cos(27596) * 47;
+acc += Math.sin(27596) + Math.cos(27597) * 48;
+acc += Math.sin(27597) + Math.cos(27598) * 49;
+acc += Math.sin(27598) + Math.cos(27599) * 50;
+acc += Math.sin(27599) + Math.cos(27600) * 51;
+acc += Math.sin(27600) + Math.cos(27601) * 52;
+acc += Math.sin(27601) + Math.cos(27602) * 53;
+acc += Math.sin(27602) + Math.cos(27603) * 54;
+acc += Math.sin(27603) + Math.cos(27604) * 55;
+acc += Math.sin(27604) + Math.cos(27605) * 56;
+acc += Math.sin(27605) + Math.cos(27606) * 57;
+acc += Math.sin(27606) + Math.cos(27607) * 58;
+acc += Math.sin(27607) + Math.cos(27608) * 59;
+acc += Math.sin(27608) + Math.cos(27609) * 60;
+acc += Math.sin(27609) + Math.cos(27610) * 61;
+acc += Math.sin(27610) + Math.cos(27611) * 62;
+acc += Math.sin(27611) + Math.cos(27612) * 63;
+acc += Math.sin(27612) + Math.cos(27613) * 64;
+acc += Math.sin(27613) + Math.cos(27614) * 65;
+acc += Math.sin(27614) + Math.cos(27615) * 66;
+acc += Math.sin(27615) + Math.cos(27616) * 67;
+acc += Math.sin(27616) + Math.cos(27617) * 68;
+acc += Math.sin(27617) + Math.cos(27618) * 69;
+acc += Math.sin(27618) + Math.cos(27619) * 70;
+acc += Math.sin(27619) + Math.cos(27620) * 71;
+acc += Math.sin(27620) + Math.cos(27621) * 72;
+acc += Math.sin(27621) + Math.cos(27622) * 73;
+acc += Math.sin(27622) + Math.cos(27623) * 74;
+acc += Math.sin(27623) + Math.cos(27624) * 75;
+acc += Math.sin(27624) + Math.cos(27625) * 76;
+acc += Math.sin(27625) + Math.cos(27626) * 77;
+acc += Math.sin(27626) + Math.cos(27627) * 78;
+acc += Math.sin(27627) + Math.cos(27628) * 79;
+acc += Math.sin(27628) + Math.cos(27629) * 80;
+acc += Math.sin(27629) + Math.cos(27630) * 81;
+acc += Math.sin(27630) + Math.cos(27631) * 82;
+acc += Math.sin(27631) + Math.cos(27632) * 83;
+acc += Math.sin(27632) + Math.cos(27633) * 84;
+acc += Math.sin(27633) + Math.cos(27634) * 85;
+acc += Math.sin(27634) + Math.cos(27635) * 86;
+acc += Math.sin(27635) + Math.cos(27636) * 87;
+acc += Math.sin(27636) + Math.cos(27637) * 88;
+acc += Math.sin(27637) + Math.cos(27638) * 89;
+acc += Math.sin(27638) + Math.cos(27639) * 90;
+acc += Math.sin(27639) + Math.cos(27640) * 91;
+acc += Math.sin(27640) + Math.cos(27641) * 92;
+acc += Math.sin(27641) + Math.cos(27642) * 93;
+acc += Math.sin(27642) + Math.cos(27643) * 94;
+acc += Math.sin(27643) + Math.cos(27644) * 95;
+acc += Math.sin(27644) + Math.cos(27645) * 96;
+acc += Math.sin(27645) + Math.cos(27646) * 0;
+acc += Math.sin(27646) + Math.cos(27647) * 1;
+acc += Math.sin(27647) + Math.cos(27648) * 2;
+acc += Math.sin(27648) + Math.cos(27649) * 3;
+acc += Math.sin(27649) + Math.cos(27650) * 4;
+acc += Math.sin(27650) + Math.cos(27651) * 5;
+acc += Math.sin(27651) + Math.cos(27652) * 6;
+acc += Math.sin(27652) + Math.cos(27653) * 7;
+acc += Math.sin(27653) + Math.cos(27654) * 8;
+acc += Math.sin(27654) + Math.cos(27655) * 9;
+acc += Math.sin(27655) + Math.cos(27656) * 10;
+acc += Math.sin(27656) + Math.cos(27657) * 11;
+acc += Math.sin(27657) + Math.cos(27658) * 12;
+acc += Math.sin(27658) + Math.cos(27659) * 13;
+acc += Math.sin(27659) + Math.cos(27660) * 14;
+acc += Math.sin(27660) + Math.cos(27661) * 15;
+acc += Math.sin(27661) + Math.cos(27662) * 16;
+acc += Math.sin(27662) + Math.cos(27663) * 17;
+acc += Math.sin(27663) + Math.cos(27664) * 18;
+acc += Math.sin(27664) + Math.cos(27665) * 19;
+acc += Math.sin(27665) + Math.cos(27666) * 20;
+acc += Math.sin(27666) + Math.cos(27667) * 21;
+acc += Math.sin(27667) + Math.cos(27668) * 22;
+acc += Math.sin(27668) + Math.cos(27669) * 23;
+acc += Math.sin(27669) + Math.cos(27670) * 24;
+acc += Math.sin(27670) + Math.cos(27671) * 25;
+acc += Math.sin(27671) + Math.cos(27672) * 26;
+acc += Math.sin(27672) + Math.cos(27673) * 27;
+acc += Math.sin(27673) + Math.cos(27674) * 28;
+acc += Math.sin(27674) + Math.cos(27675) * 29;
+acc += Math.sin(27675) + Math.cos(27676) * 30;
+acc += Math.sin(27676) + Math.cos(27677) * 31;
+acc += Math.sin(27677) + Math.cos(27678) * 32;
+acc += Math.sin(27678) + Math.cos(27679) * 33;
+acc += Math.sin(27679) + Math.cos(27680) * 34;
+acc += Math.sin(27680) + Math.cos(27681) * 35;
+acc += Math.sin(27681) + Math.cos(27682) * 36;
+acc += Math.sin(27682) + Math.cos(27683) * 37;
+acc += Math.sin(27683) + Math.cos(27684) * 38;
+acc += Math.sin(27684) + Math.cos(27685) * 39;
+acc += Math.sin(27685) + Math.cos(27686) * 40;
+acc += Math.sin(27686) + Math.cos(27687) * 41;
+acc += Math.sin(27687) + Math.cos(27688) * 42;
+acc += Math.sin(27688) + Math.cos(27689) * 43;
+acc += Math.sin(27689) + Math.cos(27690) * 44;
+acc += Math.sin(27690) + Math.cos(27691) * 45;
+acc += Math.sin(27691) + Math.cos(27692) * 46;
+acc += Math.sin(27692) + Math.cos(27693) * 47;
+acc += Math.sin(27693) + Math.cos(27694) * 48;
+acc += Math.sin(27694) + Math.cos(27695) * 49;
+acc += Math.sin(27695) + Math.cos(27696) * 50;
+acc += Math.sin(27696) + Math.cos(27697) * 51;
+acc += Math.sin(27697) + Math.cos(27698) * 52;
+acc += Math.sin(27698) + Math.cos(27699) * 53;
+acc += Math.sin(27699) + Math.cos(27700) * 54;
+acc += Math.sin(27700) + Math.cos(27701) * 55;
+acc += Math.sin(27701) + Math.cos(27702) * 56;
+acc += Math.sin(27702) + Math.cos(27703) * 57;
+acc += Math.sin(27703) + Math.cos(27704) * 58;
+acc += Math.sin(27704) + Math.cos(27705) * 59;
+acc += Math.sin(27705) + Math.cos(27706) * 60;
+acc += Math.sin(27706) + Math.cos(27707) * 61;
+acc += Math.sin(27707) + Math.cos(27708) * 62;
+acc += Math.sin(27708) + Math.cos(27709) * 63;
+acc += Math.sin(27709) + Math.cos(27710) * 64;
+acc += Math.sin(27710) + Math.cos(27711) * 65;
+acc += Math.sin(27711) + Math.cos(27712) * 66;
+acc += Math.sin(27712) + Math.cos(27713) * 67;
+acc += Math.sin(27713) + Math.cos(27714) * 68;
+acc += Math.sin(27714) + Math.cos(27715) * 69;
+acc += Math.sin(27715) + Math.cos(27716) * 70;
+acc += Math.sin(27716) + Math.cos(27717) * 71;
+acc += Math.sin(27717) + Math.cos(27718) * 72;
+acc += Math.sin(27718) + Math.cos(27719) * 73;
+acc += Math.sin(27719) + Math.cos(27720) * 74;
+acc += Math.sin(27720) + Math.cos(27721) * 75;
+acc += Math.sin(27721) + Math.cos(27722) * 76;
+acc += Math.sin(27722) + Math.cos(27723) * 77;
+acc += Math.sin(27723) + Math.cos(27724) * 78;
+acc += Math.sin(27724) + Math.cos(27725) * 79;
+acc += Math.sin(27725) + Math.cos(27726) * 80;
+acc += Math.sin(27726) + Math.cos(27727) * 81;
+acc += Math.sin(27727) + Math.cos(27728) * 82;
+acc += Math.sin(27728) + Math.cos(27729) * 83;
+acc += Math.sin(27729) + Math.cos(27730) * 84;
+acc += Math.sin(27730) + Math.cos(27731) * 85;
+acc += Math.sin(27731) + Math.cos(27732) * 86;
+acc += Math.sin(27732) + Math.cos(27733) * 87;
+acc += Math.sin(27733) + Math.cos(27734) * 88;
+acc += Math.sin(27734) + Math.cos(27735) * 89;
+acc += Math.sin(27735) + Math.cos(27736) * 90;
+acc += Math.sin(27736) + Math.cos(27737) * 91;
+acc += Math.sin(27737) + Math.cos(27738) * 92;
+acc += Math.sin(27738) + Math.cos(27739) * 93;
+acc += Math.sin(27739) + Math.cos(27740) * 94;
+acc += Math.sin(27740) + Math.cos(27741) * 95;
+acc += Math.sin(27741) + Math.cos(27742) * 96;
+acc += Math.sin(27742) + Math.cos(27743) * 0;
+acc += Math.sin(27743) + Math.cos(27744) * 1;
+acc += Math.sin(27744) + Math.cos(27745) * 2;
+acc += Math.sin(27745) + Math.cos(27746) * 3;
+acc += Math.sin(27746) + Math.cos(27747) * 4;
+acc += Math.sin(27747) + Math.cos(27748) * 5;
+acc += Math.sin(27748) + Math.cos(27749) * 6;
+acc += Math.sin(27749) + Math.cos(27750) * 7;
+acc += Math.sin(27750) + Math.cos(27751) * 8;
+acc += Math.sin(27751) + Math.cos(27752) * 9;
+acc += Math.sin(27752) + Math.cos(27753) * 10;
+acc += Math.sin(27753) + Math.cos(27754) * 11;
+acc += Math.sin(27754) + Math.cos(27755) * 12;
+acc += Math.sin(27755) + Math.cos(27756) * 13;
+acc += Math.sin(27756) + Math.cos(27757) * 14;
+acc += Math.sin(27757) + Math.cos(27758) * 15;
+acc += Math.sin(27758) + Math.cos(27759) * 16;
+acc += Math.sin(27759) + Math.cos(27760) * 17;
+acc += Math.sin(27760) + Math.cos(27761) * 18;
+acc += Math.sin(27761) + Math.cos(27762) * 19;
+acc += Math.sin(27762) + Math.cos(27763) * 20;
+acc += Math.sin(27763) + Math.cos(27764) * 21;
+acc += Math.sin(27764) + Math.cos(27765) * 22;
+acc += Math.sin(27765) + Math.cos(27766) * 23;
+acc += Math.sin(27766) + Math.cos(27767) * 24;
+acc += Math.sin(27767) + Math.cos(27768) * 25;
+acc += Math.sin(27768) + Math.cos(27769) * 26;
+acc += Math.sin(27769) + Math.cos(27770) * 27;
+acc += Math.sin(27770) + Math.cos(27771) * 28;
+acc += Math.sin(27771) + Math.cos(27772) * 29;
+acc += Math.sin(27772) + Math.cos(27773) * 30;
+acc += Math.sin(27773) + Math.cos(27774) * 31;
+acc += Math.sin(27774) + Math.cos(27775) * 32;
+acc += Math.sin(27775) + Math.cos(27776) * 33;
+acc += Math.sin(27776) + Math.cos(27777) * 34;
+acc += Math.sin(27777) + Math.cos(27778) * 35;
+acc += Math.sin(27778) + Math.cos(27779) * 36;
+acc += Math.sin(27779) + Math.cos(27780) * 37;
+acc += Math.sin(27780) + Math.cos(27781) * 38;
+acc += Math.sin(27781) + Math.cos(27782) * 39;
+acc += Math.sin(27782) + Math.cos(27783) * 40;
+acc += Math.sin(27783) + Math.cos(27784) * 41;
+acc += Math.sin(27784) + Math.cos(27785) * 42;
+acc += Math.sin(27785) + Math.cos(27786) * 43;
+acc += Math.sin(27786) + Math.cos(27787) * 44;
+acc += Math.sin(27787) + Math.cos(27788) * 45;
+acc += Math.sin(27788) + Math.cos(27789) * 46;
+acc += Math.sin(27789) + Math.cos(27790) * 47;
+acc += Math.sin(27790) + Math.cos(27791) * 48;
+acc += Math.sin(27791) + Math.cos(27792) * 49;
+acc += Math.sin(27792) + Math.cos(27793) * 50;
+acc += Math.sin(27793) + Math.cos(27794) * 51;
+acc += Math.sin(27794) + Math.cos(27795) * 52;
+acc += Math.sin(27795) + Math.cos(27796) * 53;
+acc += Math.sin(27796) + Math.cos(27797) * 54;
+acc += Math.sin(27797) + Math.cos(27798) * 55;
+acc += Math.sin(27798) + Math.cos(27799) * 56;
+acc += Math.sin(27799) + Math.cos(27800) * 57;
+acc += Math.sin(27800) + Math.cos(27801) * 58;
+acc += Math.sin(27801) + Math.cos(27802) * 59;
+acc += Math.sin(27802) + Math.cos(27803) * 60;
+acc += Math.sin(27803) + Math.cos(27804) * 61;
+acc += Math.sin(27804) + Math.cos(27805) * 62;
+acc += Math.sin(27805) + Math.cos(27806) * 63;
+acc += Math.sin(27806) + Math.cos(27807) * 64;
+acc += Math.sin(27807) + Math.cos(27808) * 65;
+acc += Math.sin(27808) + Math.cos(27809) * 66;
+acc += Math.sin(27809) + Math.cos(27810) * 67;
+acc += Math.sin(27810) + Math.cos(27811) * 68;
+acc += Math.sin(27811) + Math.cos(27812) * 69;
+acc += Math.sin(27812) + Math.cos(27813) * 70;
+acc += Math.sin(27813) + Math.cos(27814) * 71;
+acc += Math.sin(27814) + Math.cos(27815) * 72;
+acc += Math.sin(27815) + Math.cos(27816) * 73;
+acc += Math.sin(27816) + Math.cos(27817) * 74;
+acc += Math.sin(27817) + Math.cos(27818) * 75;
+acc += Math.sin(27818) + Math.cos(27819) * 76;
+acc += Math.sin(27819) + Math.cos(27820) * 77;
+acc += Math.sin(27820) + Math.cos(27821) * 78;
+acc += Math.sin(27821) + Math.cos(27822) * 79;
+acc += Math.sin(27822) + Math.cos(27823) * 80;
+acc += Math.sin(27823) + Math.cos(27824) * 81;
+acc += Math.sin(27824) + Math.cos(27825) * 82;
+acc += Math.sin(27825) + Math.cos(27826) * 83;
+acc += Math.sin(27826) + Math.cos(27827) * 84;
+acc += Math.sin(27827) + Math.cos(27828) * 85;
+acc += Math.sin(27828) + Math.cos(27829) * 86;
+acc += Math.sin(27829) + Math.cos(27830) * 87;
+acc += Math.sin(27830) + Math.cos(27831) * 88;
+acc += Math.sin(27831) + Math.cos(27832) * 89;
+acc += Math.sin(27832) + Math.cos(27833) * 90;
+acc += Math.sin(27833) + Math.cos(27834) * 91;
+acc += Math.sin(27834) + Math.cos(27835) * 92;
+acc += Math.sin(27835) + Math.cos(27836) * 93;
+acc += Math.sin(27836) + Math.cos(27837) * 94;
+acc += Math.sin(27837) + Math.cos(27838) * 95;
+acc += Math.sin(27838) + Math.cos(27839) * 96;
+acc += Math.sin(27839) + Math.cos(27840) * 0;
+acc += Math.sin(27840) + Math.cos(27841) * 1;
+acc += Math.sin(27841) + Math.cos(27842) * 2;
+acc += Math.sin(27842) + Math.cos(27843) * 3;
+acc += Math.sin(27843) + Math.cos(27844) * 4;
+acc += Math.sin(27844) + Math.cos(27845) * 5;
+acc += Math.sin(27845) + Math.cos(27846) * 6;
+acc += Math.sin(27846) + Math.cos(27847) * 7;
+acc += Math.sin(27847) + Math.cos(27848) * 8;
+acc += Math.sin(27848) + Math.cos(27849) * 9;
+acc += Math.sin(27849) + Math.cos(27850) * 10;
+acc += Math.sin(27850) + Math.cos(27851) * 11;
+acc += Math.sin(27851) + Math.cos(27852) * 12;
+acc += Math.sin(27852) + Math.cos(27853) * 13;
+acc += Math.sin(27853) + Math.cos(27854) * 14;
+acc += Math.sin(27854) + Math.cos(27855) * 15;
+acc += Math.sin(27855) + Math.cos(27856) * 16;
+acc += Math.sin(27856) + Math.cos(27857) * 17;
+acc += Math.sin(27857) + Math.cos(27858) * 18;
+acc += Math.sin(27858) + Math.cos(27859) * 19;
+acc += Math.sin(27859) + Math.cos(27860) * 20;
+acc += Math.sin(27860) + Math.cos(27861) * 21;
+acc += Math.sin(27861) + Math.cos(27862) * 22;
+acc += Math.sin(27862) + Math.cos(27863) * 23;
+acc += Math.sin(27863) + Math.cos(27864) * 24;
+acc += Math.sin(27864) + Math.cos(27865) * 25;
+acc += Math.sin(27865) + Math.cos(27866) * 26;
+acc += Math.sin(27866) + Math.cos(27867) * 27;
+acc += Math.sin(27867) + Math.cos(27868) * 28;
+acc += Math.sin(27868) + Math.cos(27869) * 29;
+acc += Math.sin(27869) + Math.cos(27870) * 30;
+acc += Math.sin(27870) + Math.cos(27871) * 31;
+acc += Math.sin(27871) + Math.cos(27872) * 32;
+acc += Math.sin(27872) + Math.cos(27873) * 33;
+acc += Math.sin(27873) + Math.cos(27874) * 34;
+acc += Math.sin(27874) + Math.cos(27875) * 35;
+acc += Math.sin(27875) + Math.cos(27876) * 36;
+acc += Math.sin(27876) + Math.cos(27877) * 37;
+acc += Math.sin(27877) + Math.cos(27878) * 38;
+acc += Math.sin(27878) + Math.cos(27879) * 39;
+acc += Math.sin(27879) + Math.cos(27880) * 40;
+acc += Math.sin(27880) + Math.cos(27881) * 41;
+acc += Math.sin(27881) + Math.cos(27882) * 42;
+acc += Math.sin(27882) + Math.cos(27883) * 43;
+acc += Math.sin(27883) + Math.cos(27884) * 44;
+acc += Math.sin(27884) + Math.cos(27885) * 45;
+acc += Math.sin(27885) + Math.cos(27886) * 46;
+acc += Math.sin(27886) + Math.cos(27887) * 47;
+acc += Math.sin(27887) + Math.cos(27888) * 48;
+acc += Math.sin(27888) + Math.cos(27889) * 49;
+acc += Math.sin(27889) + Math.cos(27890) * 50;
+acc += Math.sin(27890) + Math.cos(27891) * 51;
+acc += Math.sin(27891) + Math.cos(27892) * 52;
+acc += Math.sin(27892) + Math.cos(27893) * 53;
+acc += Math.sin(27893) + Math.cos(27894) * 54;
+acc += Math.sin(27894) + Math.cos(27895) * 55;
+acc += Math.sin(27895) + Math.cos(27896) * 56;
+acc += Math.sin(27896) + Math.cos(27897) * 57;
+acc += Math.sin(27897) + Math.cos(27898) * 58;
+acc += Math.sin(27898) + Math.cos(27899) * 59;
+acc += Math.sin(27899) + Math.cos(27900) * 60;
+acc += Math.sin(27900) + Math.cos(27901) * 61;
+acc += Math.sin(27901) + Math.cos(27902) * 62;
+acc += Math.sin(27902) + Math.cos(27903) * 63;
+acc += Math.sin(27903) + Math.cos(27904) * 64;
+acc += Math.sin(27904) + Math.cos(27905) * 65;
+acc += Math.sin(27905) + Math.cos(27906) * 66;
+acc += Math.sin(27906) + Math.cos(27907) * 67;
+acc += Math.sin(27907) + Math.cos(27908) * 68;
+acc += Math.sin(27908) + Math.cos(27909) * 69;
+acc += Math.sin(27909) + Math.cos(27910) * 70;
+acc += Math.sin(27910) + Math.cos(27911) * 71;
+acc += Math.sin(27911) + Math.cos(27912) * 72;
+acc += Math.sin(27912) + Math.cos(27913) * 73;
+acc += Math.sin(27913) + Math.cos(27914) * 74;
+acc += Math.sin(27914) + Math.cos(27915) * 75;
+acc += Math.sin(27915) + Math.cos(27916) * 76;
+acc += Math.sin(27916) + Math.cos(27917) * 77;
+acc += Math.sin(27917) + Math.cos(27918) * 78;
+acc += Math.sin(27918) + Math.cos(27919) * 79;
+acc += Math.sin(27919) + Math.cos(27920) * 80;
+acc += Math.sin(27920) + Math.cos(27921) * 81;
+acc += Math.sin(27921) + Math.cos(27922) * 82;
+acc += Math.sin(27922) + Math.cos(27923) * 83;
+acc += Math.sin(27923) + Math.cos(27924) * 84;
+acc += Math.sin(27924) + Math.cos(27925) * 85;
+acc += Math.sin(27925) + Math.cos(27926) * 86;
+acc += Math.sin(27926) + Math.cos(27927) * 87;
+acc += Math.sin(27927) + Math.cos(27928) * 88;
+acc += Math.sin(27928) + Math.cos(27929) * 89;
+acc += Math.sin(27929) + Math.cos(27930) * 90;
+acc += Math.sin(27930) + Math.cos(27931) * 91;
+acc += Math.sin(27931) + Math.cos(27932) * 92;
+acc += Math.sin(27932) + Math.cos(27933) * 93;
+acc += Math.sin(27933) + Math.cos(27934) * 94;
+acc += Math.sin(27934) + Math.cos(27935) * 95;
+acc += Math.sin(27935) + Math.cos(27936) * 96;
+acc += Math.sin(27936) + Math.cos(27937) * 0;
+acc += Math.sin(27937) + Math.cos(27938) * 1;
+acc += Math.sin(27938) + Math.cos(27939) * 2;
+acc += Math.sin(27939) + Math.cos(27940) * 3;
+acc += Math.sin(27940) + Math.cos(27941) * 4;
+acc += Math.sin(27941) + Math.cos(27942) * 5;
+acc += Math.sin(27942) + Math.cos(27943) * 6;
+acc += Math.sin(27943) + Math.cos(27944) * 7;
+acc += Math.sin(27944) + Math.cos(27945) * 8;
+acc += Math.sin(27945) + Math.cos(27946) * 9;
+acc += Math.sin(27946) + Math.cos(27947) * 10;
+acc += Math.sin(27947) + Math.cos(27948) * 11;
+acc += Math.sin(27948) + Math.cos(27949) * 12;
+acc += Math.sin(27949) + Math.cos(27950) * 13;
+acc += Math.sin(27950) + Math.cos(27951) * 14;
+acc += Math.sin(27951) + Math.cos(27952) * 15;
+acc += Math.sin(27952) + Math.cos(27953) * 16;
+acc += Math.sin(27953) + Math.cos(27954) * 17;
+acc += Math.sin(27954) + Math.cos(27955) * 18;
+acc += Math.sin(27955) + Math.cos(27956) * 19;
+acc += Math.sin(27956) + Math.cos(27957) * 20;
+acc += Math.sin(27957) + Math.cos(27958) * 21;
+acc += Math.sin(27958) + Math.cos(27959) * 22;
+acc += Math.sin(27959) + Math.cos(27960) * 23;
+acc += Math.sin(27960) + Math.cos(27961) * 24;
+acc += Math.sin(27961) + Math.cos(27962) * 25;
+acc += Math.sin(27962) + Math.cos(27963) * 26;
+acc += Math.sin(27963) + Math.cos(27964) * 27;
+acc += Math.sin(27964) + Math.cos(27965) * 28;
+acc += Math.sin(27965) + Math.cos(27966) * 29;
+acc += Math.sin(27966) + Math.cos(27967) * 30;
+acc += Math.sin(27967) + Math.cos(27968) * 31;
+acc += Math.sin(27968) + Math.cos(27969) * 32;
+acc += Math.sin(27969) + Math.cos(27970) * 33;
+acc += Math.sin(27970) + Math.cos(27971) * 34;
+acc += Math.sin(27971) + Math.cos(27972) * 35;
+acc += Math.sin(27972) + Math.cos(27973) * 36;
+acc += Math.sin(27973) + Math.cos(27974) * 37;
+acc += Math.sin(27974) + Math.cos(27975) * 38;
+acc += Math.sin(27975) + Math.cos(27976) * 39;
+acc += Math.sin(27976) + Math.cos(27977) * 40;
+acc += Math.sin(27977) + Math.cos(27978) * 41;
+acc += Math.sin(27978) + Math.cos(27979) * 42;
+acc += Math.sin(27979) + Math.cos(27980) * 43;
+acc += Math.sin(27980) + Math.cos(27981) * 44;
+acc += Math.sin(27981) + Math.cos(27982) * 45;
+acc += Math.sin(27982) + Math.cos(27983) * 46;
+acc += Math.sin(27983) + Math.cos(27984) * 47;
+acc += Math.sin(27984) + Math.cos(27985) * 48;
+acc += Math.sin(27985) + Math.cos(27986) * 49;
+acc += Math.sin(27986) + Math.cos(27987) * 50;
+acc += Math.sin(27987) + Math.cos(27988) * 51;
+acc += Math.sin(27988) + Math.cos(27989) * 52;
+acc += Math.sin(27989) + Math.cos(27990) * 53;
+acc += Math.sin(27990) + Math.cos(27991) * 54;
+acc += Math.sin(27991) + Math.cos(27992) * 55;
+acc += Math.sin(27992) + Math.cos(27993) * 56;
+acc += Math.sin(27993) + Math.cos(27994) * 57;
+acc += Math.sin(27994) + Math.cos(27995) * 58;
+acc += Math.sin(27995) + Math.cos(27996) * 59;
+acc += Math.sin(27996) + Math.cos(27997) * 60;
+acc += Math.sin(27997) + Math.cos(27998) * 61;
+acc += Math.sin(27998) + Math.cos(27999) * 62;
+acc += Math.sin(27999) + Math.cos(28000) * 63;
+acc += Math.sin(28000) + Math.cos(28001) * 64;
+acc += Math.sin(28001) + Math.cos(28002) * 65;
+acc += Math.sin(28002) + Math.cos(28003) * 66;
+acc += Math.sin(28003) + Math.cos(28004) * 67;
+acc += Math.sin(28004) + Math.cos(28005) * 68;
+acc += Math.sin(28005) + Math.cos(28006) * 69;
+acc += Math.sin(28006) + Math.cos(28007) * 70;
+acc += Math.sin(28007) + Math.cos(28008) * 71;
+acc += Math.sin(28008) + Math.cos(28009) * 72;
+acc += Math.sin(28009) + Math.cos(28010) * 73;
+acc += Math.sin(28010) + Math.cos(28011) * 74;
+acc += Math.sin(28011) + Math.cos(28012) * 75;
+acc += Math.sin(28012) + Math.cos(28013) * 76;
+acc += Math.sin(28013) + Math.cos(28014) * 77;
+acc += Math.sin(28014) + Math.cos(28015) * 78;
+acc += Math.sin(28015) + Math.cos(28016) * 79;
+acc += Math.sin(28016) + Math.cos(28017) * 80;
+acc += Math.sin(28017) + Math.cos(28018) * 81;
+acc += Math.sin(28018) + Math.cos(28019) * 82;
+acc += Math.sin(28019) + Math.cos(28020) * 83;
+acc += Math.sin(28020) + Math.cos(28021) * 84;
+acc += Math.sin(28021) + Math.cos(28022) * 85;
+acc += Math.sin(28022) + Math.cos(28023) * 86;
+acc += Math.sin(28023) + Math.cos(28024) * 87;
+acc += Math.sin(28024) + Math.cos(28025) * 88;
+acc += Math.sin(28025) + Math.cos(28026) * 89;
+acc += Math.sin(28026) + Math.cos(28027) * 90;
+acc += Math.sin(28027) + Math.cos(28028) * 91;
+acc += Math.sin(28028) + Math.cos(28029) * 92;
+acc += Math.sin(28029) + Math.cos(28030) * 93;
+acc += Math.sin(28030) + Math.cos(28031) * 94;
+acc += Math.sin(28031) + Math.cos(28032) * 95;
+acc += Math.sin(28032) + Math.cos(28033) * 96;
+acc += Math.sin(28033) + Math.cos(28034) * 0;
+acc += Math.sin(28034) + Math.cos(28035) * 1;
+acc += Math.sin(28035) + Math.cos(28036) * 2;
+acc += Math.sin(28036) + Math.cos(28037) * 3;
+acc += Math.sin(28037) + Math.cos(28038) * 4;
+acc += Math.sin(28038) + Math.cos(28039) * 5;
+acc += Math.sin(28039) + Math.cos(28040) * 6;
+acc += Math.sin(28040) + Math.cos(28041) * 7;
+acc += Math.sin(28041) + Math.cos(28042) * 8;
+acc += Math.sin(28042) + Math.cos(28043) * 9;
+acc += Math.sin(28043) + Math.cos(28044) * 10;
+acc += Math.sin(28044) + Math.cos(28045) * 11;
+acc += Math.sin(28045) + Math.cos(28046) * 12;
+acc += Math.sin(28046) + Math.cos(28047) * 13;
+acc += Math.sin(28047) + Math.cos(28048) * 14;
+acc += Math.sin(28048) + Math.cos(28049) * 15;
+acc += Math.sin(28049) + Math.cos(28050) * 16;
+acc += Math.sin(28050) + Math.cos(28051) * 17;
+acc += Math.sin(28051) + Math.cos(28052) * 18;
+acc += Math.sin(28052) + Math.cos(28053) * 19;
+acc += Math.sin(28053) + Math.cos(28054) * 20;
+acc += Math.sin(28054) + Math.cos(28055) * 21;
+acc += Math.sin(28055) + Math.cos(28056) * 22;
+acc += Math.sin(28056) + Math.cos(28057) * 23;
+acc += Math.sin(28057) + Math.cos(28058) * 24;
+acc += Math.sin(28058) + Math.cos(28059) * 25;
+acc += Math.sin(28059) + Math.cos(28060) * 26;
+acc += Math.sin(28060) + Math.cos(28061) * 27;
+acc += Math.sin(28061) + Math.cos(28062) * 28;
+acc += Math.sin(28062) + Math.cos(28063) * 29;
+acc += Math.sin(28063) + Math.cos(28064) * 30;
+acc += Math.sin(28064) + Math.cos(28065) * 31;
+acc += Math.sin(28065) + Math.cos(28066) * 32;
+acc += Math.sin(28066) + Math.cos(28067) * 33;
+acc += Math.sin(28067) + Math.cos(28068) * 34;
+acc += Math.sin(28068) + Math.cos(28069) * 35;
+acc += Math.sin(28069) + Math.cos(28070) * 36;
+acc += Math.sin(28070) + Math.cos(28071) * 37;
+acc += Math.sin(28071) + Math.cos(28072) * 38;
+acc += Math.sin(28072) + Math.cos(28073) * 39;
+acc += Math.sin(28073) + Math.cos(28074) * 40;
+acc += Math.sin(28074) + Math.cos(28075) * 41;
+acc += Math.sin(28075) + Math.cos(28076) * 42;
+acc += Math.sin(28076) + Math.cos(28077) * 43;
+acc += Math.sin(28077) + Math.cos(28078) * 44;
+acc += Math.sin(28078) + Math.cos(28079) * 45;
+acc += Math.sin(28079) + Math.cos(28080) * 46;
+acc += Math.sin(28080) + Math.cos(28081) * 47;
+acc += Math.sin(28081) + Math.cos(28082) * 48;
+acc += Math.sin(28082) + Math.cos(28083) * 49;
+acc += Math.sin(28083) + Math.cos(28084) * 50;
+acc += Math.sin(28084) + Math.cos(28085) * 51;
+acc += Math.sin(28085) + Math.cos(28086) * 52;
+acc += Math.sin(28086) + Math.cos(28087) * 53;
+acc += Math.sin(28087) + Math.cos(28088) * 54;
+acc += Math.sin(28088) + Math.cos(28089) * 55;
+acc += Math.sin(28089) + Math.cos(28090) * 56;
+acc += Math.sin(28090) + Math.cos(28091) * 57;
+acc += Math.sin(28091) + Math.cos(28092) * 58;
+acc += Math.sin(28092) + Math.cos(28093) * 59;
+acc += Math.sin(28093) + Math.cos(28094) * 60;
+acc += Math.sin(28094) + Math.cos(28095) * 61;
+acc += Math.sin(28095) + Math.cos(28096) * 62;
+acc += Math.sin(28096) + Math.cos(28097) * 63;
+acc += Math.sin(28097) + Math.cos(28098) * 64;
+acc += Math.sin(28098) + Math.cos(28099) * 65;
+acc += Math.sin(28099) + Math.cos(28100) * 66;
+acc += Math.sin(28100) + Math.cos(28101) * 67;
+acc += Math.sin(28101) + Math.cos(28102) * 68;
+acc += Math.sin(28102) + Math.cos(28103) * 69;
+acc += Math.sin(28103) + Math.cos(28104) * 70;
+acc += Math.sin(28104) + Math.cos(28105) * 71;
+acc += Math.sin(28105) + Math.cos(28106) * 72;
+acc += Math.sin(28106) + Math.cos(28107) * 73;
+acc += Math.sin(28107) + Math.cos(28108) * 74;
+acc += Math.sin(28108) + Math.cos(28109) * 75;
+acc += Math.sin(28109) + Math.cos(28110) * 76;
+acc += Math.sin(28110) + Math.cos(28111) * 77;
+acc += Math.sin(28111) + Math.cos(28112) * 78;
+acc += Math.sin(28112) + Math.cos(28113) * 79;
+acc += Math.sin(28113) + Math.cos(28114) * 80;
+acc += Math.sin(28114) + Math.cos(28115) * 81;
+acc += Math.sin(28115) + Math.cos(28116) * 82;
+acc += Math.sin(28116) + Math.cos(28117) * 83;
+acc += Math.sin(28117) + Math.cos(28118) * 84;
+acc += Math.sin(28118) + Math.cos(28119) * 85;
+acc += Math.sin(28119) + Math.cos(28120) * 86;
+acc += Math.sin(28120) + Math.cos(28121) * 87;
+acc += Math.sin(28121) + Math.cos(28122) * 88;
+acc += Math.sin(28122) + Math.cos(28123) * 89;
+acc += Math.sin(28123) + Math.cos(28124) * 90;
+acc += Math.sin(28124) + Math.cos(28125) * 91;
+acc += Math.sin(28125) + Math.cos(28126) * 92;
+acc += Math.sin(28126) + Math.cos(28127) * 93;
+acc += Math.sin(28127) + Math.cos(28128) * 94;
+acc += Math.sin(28128) + Math.cos(28129) * 95;
+acc += Math.sin(28129) + Math.cos(28130) * 96;
+acc += Math.sin(28130) + Math.cos(28131) * 0;
+acc += Math.sin(28131) + Math.cos(28132) * 1;
+acc += Math.sin(28132) + Math.cos(28133) * 2;
+acc += Math.sin(28133) + Math.cos(28134) * 3;
+acc += Math.sin(28134) + Math.cos(28135) * 4;
+acc += Math.sin(28135) + Math.cos(28136) * 5;
+acc += Math.sin(28136) + Math.cos(28137) * 6;
+acc += Math.sin(28137) + Math.cos(28138) * 7;
+acc += Math.sin(28138) + Math.cos(28139) * 8;
+acc += Math.sin(28139) + Math.cos(28140) * 9;
+acc += Math.sin(28140) + Math.cos(28141) * 10;
+acc += Math.sin(28141) + Math.cos(28142) * 11;
+acc += Math.sin(28142) + Math.cos(28143) * 12;
+acc += Math.sin(28143) + Math.cos(28144) * 13;
+acc += Math.sin(28144) + Math.cos(28145) * 14;
+acc += Math.sin(28145) + Math.cos(28146) * 15;
+acc += Math.sin(28146) + Math.cos(28147) * 16;
+acc += Math.sin(28147) + Math.cos(28148) * 17;
+acc += Math.sin(28148) + Math.cos(28149) * 18;
+acc += Math.sin(28149) + Math.cos(28150) * 19;
+acc += Math.sin(28150) + Math.cos(28151) * 20;
+acc += Math.sin(28151) + Math.cos(28152) * 21;
+acc += Math.sin(28152) + Math.cos(28153) * 22;
+acc += Math.sin(28153) + Math.cos(28154) * 23;
+acc += Math.sin(28154) + Math.cos(28155) * 24;
+acc += Math.sin(28155) + Math.cos(28156) * 25;
+acc += Math.sin(28156) + Math.cos(28157) * 26;
+acc += Math.sin(28157) + Math.cos(28158) * 27;
+acc += Math.sin(28158) + Math.cos(28159) * 28;
+acc += Math.sin(28159) + Math.cos(28160) * 29;
+acc += Math.sin(28160) + Math.cos(28161) * 30;
+acc += Math.sin(28161) + Math.cos(28162) * 31;
+acc += Math.sin(28162) + Math.cos(28163) * 32;
+acc += Math.sin(28163) + Math.cos(28164) * 33;
+acc += Math.sin(28164) + Math.cos(28165) * 34;
+acc += Math.sin(28165) + Math.cos(28166) * 35;
+acc += Math.sin(28166) + Math.cos(28167) * 36;
+acc += Math.sin(28167) + Math.cos(28168) * 37;
+acc += Math.sin(28168) + Math.cos(28169) * 38;
+acc += Math.sin(28169) + Math.cos(28170) * 39;
+acc += Math.sin(28170) + Math.cos(28171) * 40;
+acc += Math.sin(28171) + Math.cos(28172) * 41;
+acc += Math.sin(28172) + Math.cos(28173) * 42;
+acc += Math.sin(28173) + Math.cos(28174) * 43;
+acc += Math.sin(28174) + Math.cos(28175) * 44;
+acc += Math.sin(28175) + Math.cos(28176) * 45;
+acc += Math.sin(28176) + Math.cos(28177) * 46;
+acc += Math.sin(28177) + Math.cos(28178) * 47;
+acc += Math.sin(28178) + Math.cos(28179) * 48;
+acc += Math.sin(28179) + Math.cos(28180) * 49;
+acc += Math.sin(28180) + Math.cos(28181) * 50;
+acc += Math.sin(28181) + Math.cos(28182) * 51;
+acc += Math.sin(28182) + Math.cos(28183) * 52;
+acc += Math.sin(28183) + Math.cos(28184) * 53;
+acc += Math.sin(28184) + Math.cos(28185) * 54;
+acc += Math.sin(28185) + Math.cos(28186) * 55;
+acc += Math.sin(28186) + Math.cos(28187) * 56;
+acc += Math.sin(28187) + Math.cos(28188) * 57;
+acc += Math.sin(28188) + Math.cos(28189) * 58;
+acc += Math.sin(28189) + Math.cos(28190) * 59;
+acc += Math.sin(28190) + Math.cos(28191) * 60;
+acc += Math.sin(28191) + Math.cos(28192) * 61;
+acc += Math.sin(28192) + Math.cos(28193) * 62;
+acc += Math.sin(28193) + Math.cos(28194) * 63;
+acc += Math.sin(28194) + Math.cos(28195) * 64;
+acc += Math.sin(28195) + Math.cos(28196) * 65;
+acc += Math.sin(28196) + Math.cos(28197) * 66;
+acc += Math.sin(28197) + Math.cos(28198) * 67;
+acc += Math.sin(28198) + Math.cos(28199) * 68;
+acc += Math.sin(28199) + Math.cos(28200) * 69;
+acc += Math.sin(28200) + Math.cos(28201) * 70;
+acc += Math.sin(28201) + Math.cos(28202) * 71;
+acc += Math.sin(28202) + Math.cos(28203) * 72;
+acc += Math.sin(28203) + Math.cos(28204) * 73;
+acc += Math.sin(28204) + Math.cos(28205) * 74;
+acc += Math.sin(28205) + Math.cos(28206) * 75;
+acc += Math.sin(28206) + Math.cos(28207) * 76;
+acc += Math.sin(28207) + Math.cos(28208) * 77;
+acc += Math.sin(28208) + Math.cos(28209) * 78;
+acc += Math.sin(28209) + Math.cos(28210) * 79;
+acc += Math.sin(28210) + Math.cos(28211) * 80;
+acc += Math.sin(28211) + Math.cos(28212) * 81;
+acc += Math.sin(28212) + Math.cos(28213) * 82;
+acc += Math.sin(28213) + Math.cos(28214) * 83;
+acc += Math.sin(28214) + Math.cos(28215) * 84;
+acc += Math.sin(28215) + Math.cos(28216) * 85;
+acc += Math.sin(28216) + Math.cos(28217) * 86;
+acc += Math.sin(28217) + Math.cos(28218) * 87;
+acc += Math.sin(28218) + Math.cos(28219) * 88;
+acc += Math.sin(28219) + Math.cos(28220) * 89;
+acc += Math.sin(28220) + Math.cos(28221) * 90;
+acc += Math.sin(28221) + Math.cos(28222) * 91;
+acc += Math.sin(28222) + Math.cos(28223) * 92;
+acc += Math.sin(28223) + Math.cos(28224) * 93;
+acc += Math.sin(28224) + Math.cos(28225) * 94;
+acc += Math.sin(28225) + Math.cos(28226) * 95;
+acc += Math.sin(28226) + Math.cos(28227) * 96;
+acc += Math.sin(28227) + Math.cos(28228) * 0;
+acc += Math.sin(28228) + Math.cos(28229) * 1;
+acc += Math.sin(28229) + Math.cos(28230) * 2;
+acc += Math.sin(28230) + Math.cos(28231) * 3;
+acc += Math.sin(28231) + Math.cos(28232) * 4;
+acc += Math.sin(28232) + Math.cos(28233) * 5;
+acc += Math.sin(28233) + Math.cos(28234) * 6;
+acc += Math.sin(28234) + Math.cos(28235) * 7;
+acc += Math.sin(28235) + Math.cos(28236) * 8;
+acc += Math.sin(28236) + Math.cos(28237) * 9;
+acc += Math.sin(28237) + Math.cos(28238) * 10;
+acc += Math.sin(28238) + Math.cos(28239) * 11;
+acc += Math.sin(28239) + Math.cos(28240) * 12;
+acc += Math.sin(28240) + Math.cos(28241) * 13;
+acc += Math.sin(28241) + Math.cos(28242) * 14;
+acc += Math.sin(28242) + Math.cos(28243) * 15;
+acc += Math.sin(28243) + Math.cos(28244) * 16;
+acc += Math.sin(28244) + Math.cos(28245) * 17;
+acc += Math.sin(28245) + Math.cos(28246) * 18;
+acc += Math.sin(28246) + Math.cos(28247) * 19;
+acc += Math.sin(28247) + Math.cos(28248) * 20;
+acc += Math.sin(28248) + Math.cos(28249) * 21;
+acc += Math.sin(28249) + Math.cos(28250) * 22;
+acc += Math.sin(28250) + Math.cos(28251) * 23;
+acc += Math.sin(28251) + Math.cos(28252) * 24;
+acc += Math.sin(28252) + Math.cos(28253) * 25;
+acc += Math.sin(28253) + Math.cos(28254) * 26;
+acc += Math.sin(28254) + Math.cos(28255) * 27;
+acc += Math.sin(28255) + Math.cos(28256) * 28;
+acc += Math.sin(28256) + Math.cos(28257) * 29;
+acc += Math.sin(28257) + Math.cos(28258) * 30;
+acc += Math.sin(28258) + Math.cos(28259) * 31;
+acc += Math.sin(28259) + Math.cos(28260) * 32;
+acc += Math.sin(28260) + Math.cos(28261) * 33;
+acc += Math.sin(28261) + Math.cos(28262) * 34;
+acc += Math.sin(28262) + Math.cos(28263) * 35;
+acc += Math.sin(28263) + Math.cos(28264) * 36;
+acc += Math.sin(28264) + Math.cos(28265) * 37;
+acc += Math.sin(28265) + Math.cos(28266) * 38;
+acc += Math.sin(28266) + Math.cos(28267) * 39;
+acc += Math.sin(28267) + Math.cos(28268) * 40;
+acc += Math.sin(28268) + Math.cos(28269) * 41;
+acc += Math.sin(28269) + Math.cos(28270) * 42;
+acc += Math.sin(28270) + Math.cos(28271) * 43;
+acc += Math.sin(28271) + Math.cos(28272) * 44;
+acc += Math.sin(28272) + Math.cos(28273) * 45;
+acc += Math.sin(28273) + Math.cos(28274) * 46;
+acc += Math.sin(28274) + Math.cos(28275) * 47;
+acc += Math.sin(28275) + Math.cos(28276) * 48;
+acc += Math.sin(28276) + Math.cos(28277) * 49;
+acc += Math.sin(28277) + Math.cos(28278) * 50;
+acc += Math.sin(28278) + Math.cos(28279) * 51;
+acc += Math.sin(28279) + Math.cos(28280) * 52;
+acc += Math.sin(28280) + Math.cos(28281) * 53;
+acc += Math.sin(28281) + Math.cos(28282) * 54;
+acc += Math.sin(28282) + Math.cos(28283) * 55;
+acc += Math.sin(28283) + Math.cos(28284) * 56;
+acc += Math.sin(28284) + Math.cos(28285) * 57;
+acc += Math.sin(28285) + Math.cos(28286) * 58;
+acc += Math.sin(28286) + Math.cos(28287) * 59;
+acc += Math.sin(28287) + Math.cos(28288) * 60;
+acc += Math.sin(28288) + Math.cos(28289) * 61;
+acc += Math.sin(28289) + Math.cos(28290) * 62;
+acc += Math.sin(28290) + Math.cos(28291) * 63;
+acc += Math.sin(28291) + Math.cos(28292) * 64;
+acc += Math.sin(28292) + Math.cos(28293) * 65;
+acc += Math.sin(28293) + Math.cos(28294) * 66;
+acc += Math.sin(28294) + Math.cos(28295) * 67;
+acc += Math.sin(28295) + Math.cos(28296) * 68;
+acc += Math.sin(28296) + Math.cos(28297) * 69;
+acc += Math.sin(28297) + Math.cos(28298) * 70;
+acc += Math.sin(28298) + Math.cos(28299) * 71;
+acc += Math.sin(28299) + Math.cos(28300) * 72;
+acc += Math.sin(28300) + Math.cos(28301) * 73;
+acc += Math.sin(28301) + Math.cos(28302) * 74;
+acc += Math.sin(28302) + Math.cos(28303) * 75;
+acc += Math.sin(28303) + Math.cos(28304) * 76;
+acc += Math.sin(28304) + Math.cos(28305) * 77;
+acc += Math.sin(28305) + Math.cos(28306) * 78;
+acc += Math.sin(28306) + Math.cos(28307) * 79;
+acc += Math.sin(28307) + Math.cos(28308) * 80;
+acc += Math.sin(28308) + Math.cos(28309) * 81;
+acc += Math.sin(28309) + Math.cos(28310) * 82;
+acc += Math.sin(28310) + Math.cos(28311) * 83;
+acc += Math.sin(28311) + Math.cos(28312) * 84;
+acc += Math.sin(28312) + Math.cos(28313) * 85;
+acc += Math.sin(28313) + Math.cos(28314) * 86;
+acc += Math.sin(28314) + Math.cos(28315) * 87;
+acc += Math.sin(28315) + Math.cos(28316) * 88;
+acc += Math.sin(28316) + Math.cos(28317) * 89;
+acc += Math.sin(28317) + Math.cos(28318) * 90;
+acc += Math.sin(28318) + Math.cos(28319) * 91;
+acc += Math.sin(28319) + Math.cos(28320) * 92;
+acc += Math.sin(28320) + Math.cos(28321) * 93;
+acc += Math.sin(28321) + Math.cos(28322) * 94;
+acc += Math.sin(28322) + Math.cos(28323) * 95;
+acc += Math.sin(28323) + Math.cos(28324) * 96;
+acc += Math.sin(28324) + Math.cos(28325) * 0;
+acc += Math.sin(28325) + Math.cos(28326) * 1;
+acc += Math.sin(28326) + Math.cos(28327) * 2;
+acc += Math.sin(28327) + Math.cos(28328) * 3;
+acc += Math.sin(28328) + Math.cos(28329) * 4;
+acc += Math.sin(28329) + Math.cos(28330) * 5;
+acc += Math.sin(28330) + Math.cos(28331) * 6;
+acc += Math.sin(28331) + Math.cos(28332) * 7;
+acc += Math.sin(28332) + Math.cos(28333) * 8;
+acc += Math.sin(28333) + Math.cos(28334) * 9;
+acc += Math.sin(28334) + Math.cos(28335) * 10;
+acc += Math.sin(28335) + Math.cos(28336) * 11;
+acc += Math.sin(28336) + Math.cos(28337) * 12;
+acc += Math.sin(28337) + Math.cos(28338) * 13;
+acc += Math.sin(28338) + Math.cos(28339) * 14;
+acc += Math.sin(28339) + Math.cos(28340) * 15;
+acc += Math.sin(28340) + Math.cos(28341) * 16;
+acc += Math.sin(28341) + Math.cos(28342) * 17;
+acc += Math.sin(28342) + Math.cos(28343) * 18;
+acc += Math.sin(28343) + Math.cos(28344) * 19;
+acc += Math.sin(28344) + Math.cos(28345) * 20;
+acc += Math.sin(28345) + Math.cos(28346) * 21;
+acc += Math.sin(28346) + Math.cos(28347) * 22;
+acc += Math.sin(28347) + Math.cos(28348) * 23;
+acc += Math.sin(28348) + Math.cos(28349) * 24;
+acc += Math.sin(28349) + Math.cos(28350) * 25;
+acc += Math.sin(28350) + Math.cos(28351) * 26;
+acc += Math.sin(28351) + Math.cos(28352) * 27;
+acc += Math.sin(28352) + Math.cos(28353) * 28;
+acc += Math.sin(28353) + Math.cos(28354) * 29;
+acc += Math.sin(28354) + Math.cos(28355) * 30;
+acc += Math.sin(28355) + Math.cos(28356) * 31;
+acc += Math.sin(28356) + Math.cos(28357) * 32;
+acc += Math.sin(28357) + Math.cos(28358) * 33;
+acc += Math.sin(28358) + Math.cos(28359) * 34;
+acc += Math.sin(28359) + Math.cos(28360) * 35;
+acc += Math.sin(28360) + Math.cos(28361) * 36;
+acc += Math.sin(28361) + Math.cos(28362) * 37;
+acc += Math.sin(28362) + Math.cos(28363) * 38;
+acc += Math.sin(28363) + Math.cos(28364) * 39;
+acc += Math.sin(28364) + Math.cos(28365) * 40;
+acc += Math.sin(28365) + Math.cos(28366) * 41;
+acc += Math.sin(28366) + Math.cos(28367) * 42;
+acc += Math.sin(28367) + Math.cos(28368) * 43;
+acc += Math.sin(28368) + Math.cos(28369) * 44;
+acc += Math.sin(28369) + Math.cos(28370) * 45;
+acc += Math.sin(28370) + Math.cos(28371) * 46;
+acc += Math.sin(28371) + Math.cos(28372) * 47;
+acc += Math.sin(28372) + Math.cos(28373) * 48;
+acc += Math.sin(28373) + Math.cos(28374) * 49;
+acc += Math.sin(28374) + Math.cos(28375) * 50;
+acc += Math.sin(28375) + Math.cos(28376) * 51;
+acc += Math.sin(28376) + Math.cos(28377) * 52;
+acc += Math.sin(28377) + Math.cos(28378) * 53;
+acc += Math.sin(28378) + Math.cos(28379) * 54;
+acc += Math.sin(28379) + Math.cos(28380) * 55;
+acc += Math.sin(28380) + Math.cos(28381) * 56;
+acc += Math.sin(28381) + Math.cos(28382) * 57;
+acc += Math.sin(28382) + Math.cos(28383) * 58;
+acc += Math.sin(28383) + Math.cos(28384) * 59;
+acc += Math.sin(28384) + Math.cos(28385) * 60;
+acc += Math.sin(28385) + Math.cos(28386) * 61;
+acc += Math.sin(28386) + Math.cos(28387) * 62;
+acc += Math.sin(28387) + Math.cos(28388) * 63;
+acc += Math.sin(28388) + Math.cos(28389) * 64;
+acc += Math.sin(28389) + Math.cos(28390) * 65;
+acc += Math.sin(28390) + Math.cos(28391) * 66;
+acc += Math.sin(28391) + Math.cos(28392) * 67;
+acc += Math.sin(28392) + Math.cos(28393) * 68;
+acc += Math.sin(28393) + Math.cos(28394) * 69;
+acc += Math.sin(28394) + Math.cos(28395) * 70;
+acc += Math.sin(28395) + Math.cos(28396) * 71;
+acc += Math.sin(28396) + Math.cos(28397) * 72;
+acc += Math.sin(28397) + Math.cos(28398) * 73;
+acc += Math.sin(28398) + Math.cos(28399) * 74;
+acc += Math.sin(28399) + Math.cos(28400) * 75;
+acc += Math.sin(28400) + Math.cos(28401) * 76;
+acc += Math.sin(28401) + Math.cos(28402) * 77;
+acc += Math.sin(28402) + Math.cos(28403) * 78;
+acc += Math.sin(28403) + Math.cos(28404) * 79;
+acc += Math.sin(28404) + Math.cos(28405) * 80;
+acc += Math.sin(28405) + Math.cos(28406) * 81;
+acc += Math.sin(28406) + Math.cos(28407) * 82;
+acc += Math.sin(28407) + Math.cos(28408) * 83;
+acc += Math.sin(28408) + Math.cos(28409) * 84;
+acc += Math.sin(28409) + Math.cos(28410) * 85;
+acc += Math.sin(28410) + Math.cos(28411) * 86;
+acc += Math.sin(28411) + Math.cos(28412) * 87;
+acc += Math.sin(28412) + Math.cos(28413) * 88;
+acc += Math.sin(28413) + Math.cos(28414) * 89;
+acc += Math.sin(28414) + Math.cos(28415) * 90;
+acc += Math.sin(28415) + Math.cos(28416) * 91;
+acc += Math.sin(28416) + Math.cos(28417) * 92;
+acc += Math.sin(28417) + Math.cos(28418) * 93;
+acc += Math.sin(28418) + Math.cos(28419) * 94;
+acc += Math.sin(28419) + Math.cos(28420) * 95;
+acc += Math.sin(28420) + Math.cos(28421) * 96;
+acc += Math.sin(28421) + Math.cos(28422) * 0;
+acc += Math.sin(28422) + Math.cos(28423) * 1;
+acc += Math.sin(28423) + Math.cos(28424) * 2;
+acc += Math.sin(28424) + Math.cos(28425) * 3;
+acc += Math.sin(28425) + Math.cos(28426) * 4;
+acc += Math.sin(28426) + Math.cos(28427) * 5;
+acc += Math.sin(28427) + Math.cos(28428) * 6;
+acc += Math.sin(28428) + Math.cos(28429) * 7;
+acc += Math.sin(28429) + Math.cos(28430) * 8;
+acc += Math.sin(28430) + Math.cos(28431) * 9;
+acc += Math.sin(28431) + Math.cos(28432) * 10;
+acc += Math.sin(28432) + Math.cos(28433) * 11;
+acc += Math.sin(28433) + Math.cos(28434) * 12;
+acc += Math.sin(28434) + Math.cos(28435) * 13;
+acc += Math.sin(28435) + Math.cos(28436) * 14;
+acc += Math.sin(28436) + Math.cos(28437) * 15;
+acc += Math.sin(28437) + Math.cos(28438) * 16;
+acc += Math.sin(28438) + Math.cos(28439) * 17;
+acc += Math.sin(28439) + Math.cos(28440) * 18;
+acc += Math.sin(28440) + Math.cos(28441) * 19;
+acc += Math.sin(28441) + Math.cos(28442) * 20;
+acc += Math.sin(28442) + Math.cos(28443) * 21;
+acc += Math.sin(28443) + Math.cos(28444) * 22;
+acc += Math.sin(28444) + Math.cos(28445) * 23;
+acc += Math.sin(28445) + Math.cos(28446) * 24;
+acc += Math.sin(28446) + Math.cos(28447) * 25;
+acc += Math.sin(28447) + Math.cos(28448) * 26;
+acc += Math.sin(28448) + Math.cos(28449) * 27;
+acc += Math.sin(28449) + Math.cos(28450) * 28;
+acc += Math.sin(28450) + Math.cos(28451) * 29;
+acc += Math.sin(28451) + Math.cos(28452) * 30;
+acc += Math.sin(28452) + Math.cos(28453) * 31;
+acc += Math.sin(28453) + Math.cos(28454) * 32;
+acc += Math.sin(28454) + Math.cos(28455) * 33;
+acc += Math.sin(28455) + Math.cos(28456) * 34;
+acc += Math.sin(28456) + Math.cos(28457) * 35;
+acc += Math.sin(28457) + Math.cos(28458) * 36;
+acc += Math.sin(28458) + Math.cos(28459) * 37;
+acc += Math.sin(28459) + Math.cos(28460) * 38;
+acc += Math.sin(28460) + Math.cos(28461) * 39;
+acc += Math.sin(28461) + Math.cos(28462) * 40;
+acc += Math.sin(28462) + Math.cos(28463) * 41;
+acc += Math.sin(28463) + Math.cos(28464) * 42;
+acc += Math.sin(28464) + Math.cos(28465) * 43;
+acc += Math.sin(28465) + Math.cos(28466) * 44;
+acc += Math.sin(28466) + Math.cos(28467) * 45;
+acc += Math.sin(28467) + Math.cos(28468) * 46;
+acc += Math.sin(28468) + Math.cos(28469) * 47;
+acc += Math.sin(28469) + Math.cos(28470) * 48;
+acc += Math.sin(28470) + Math.cos(28471) * 49;
+acc += Math.sin(28471) + Math.cos(28472) * 50;
+acc += Math.sin(28472) + Math.cos(28473) * 51;
+acc += Math.sin(28473) + Math.cos(28474) * 52;
+acc += Math.sin(28474) + Math.cos(28475) * 53;
+acc += Math.sin(28475) + Math.cos(28476) * 54;
+acc += Math.sin(28476) + Math.cos(28477) * 55;
+acc += Math.sin(28477) + Math.cos(28478) * 56;
+acc += Math.sin(28478) + Math.cos(28479) * 57;
+acc += Math.sin(28479) + Math.cos(28480) * 58;
+acc += Math.sin(28480) + Math.cos(28481) * 59;
+acc += Math.sin(28481) + Math.cos(28482) * 60;
+acc += Math.sin(28482) + Math.cos(28483) * 61;
+acc += Math.sin(28483) + Math.cos(28484) * 62;
+acc += Math.sin(28484) + Math.cos(28485) * 63;
+acc += Math.sin(28485) + Math.cos(28486) * 64;
+acc += Math.sin(28486) + Math.cos(28487) * 65;
+acc += Math.sin(28487) + Math.cos(28488) * 66;
+acc += Math.sin(28488) + Math.cos(28489) * 67;
+acc += Math.sin(28489) + Math.cos(28490) * 68;
+acc += Math.sin(28490) + Math.cos(28491) * 69;
+acc += Math.sin(28491) + Math.cos(28492) * 70;
+acc += Math.sin(28492) + Math.cos(28493) * 71;
+acc += Math.sin(28493) + Math.cos(28494) * 72;
+acc += Math.sin(28494) + Math.cos(28495) * 73;
+acc += Math.sin(28495) + Math.cos(28496) * 74;
+acc += Math.sin(28496) + Math.cos(28497) * 75;
+acc += Math.sin(28497) + Math.cos(28498) * 76;
+acc += Math.sin(28498) + Math.cos(28499) * 77;
+acc += Math.sin(28499) + Math.cos(28500) * 78;
+acc += Math.sin(28500) + Math.cos(28501) * 79;
+acc += Math.sin(28501) + Math.cos(28502) * 80;
+acc += Math.sin(28502) + Math.cos(28503) * 81;
+acc += Math.sin(28503) + Math.cos(28504) * 82;
+acc += Math.sin(28504) + Math.cos(28505) * 83;
+acc += Math.sin(28505) + Math.cos(28506) * 84;
+acc += Math.sin(28506) + Math.cos(28507) * 85;
+acc += Math.sin(28507) + Math.cos(28508) * 86;
+acc += Math.sin(28508) + Math.cos(28509) * 87;
+acc += Math.sin(28509) + Math.cos(28510) * 88;
+acc += Math.sin(28510) + Math.cos(28511) * 89;
+acc += Math.sin(28511) + Math.cos(28512) * 90;
+acc += Math.sin(28512) + Math.cos(28513) * 91;
+acc += Math.sin(28513) + Math.cos(28514) * 92;
+acc += Math.sin(28514) + Math.cos(28515) * 93;
+acc += Math.sin(28515) + Math.cos(28516) * 94;
+acc += Math.sin(28516) + Math.cos(28517) * 95;
+acc += Math.sin(28517) + Math.cos(28518) * 96;
+acc += Math.sin(28518) + Math.cos(28519) * 0;
+acc += Math.sin(28519) + Math.cos(28520) * 1;
+acc += Math.sin(28520) + Math.cos(28521) * 2;
+acc += Math.sin(28521) + Math.cos(28522) * 3;
+acc += Math.sin(28522) + Math.cos(28523) * 4;
+acc += Math.sin(28523) + Math.cos(28524) * 5;
+acc += Math.sin(28524) + Math.cos(28525) * 6;
+acc += Math.sin(28525) + Math.cos(28526) * 7;
+acc += Math.sin(28526) + Math.cos(28527) * 8;
+acc += Math.sin(28527) + Math.cos(28528) * 9;
+acc += Math.sin(28528) + Math.cos(28529) * 10;
+acc += Math.sin(28529) + Math.cos(28530) * 11;
+acc += Math.sin(28530) + Math.cos(28531) * 12;
+acc += Math.sin(28531) + Math.cos(28532) * 13;
+acc += Math.sin(28532) + Math.cos(28533) * 14;
+acc += Math.sin(28533) + Math.cos(28534) * 15;
+acc += Math.sin(28534) + Math.cos(28535) * 16;
+acc += Math.sin(28535) + Math.cos(28536) * 17;
+acc += Math.sin(28536) + Math.cos(28537) * 18;
+acc += Math.sin(28537) + Math.cos(28538) * 19;
+acc += Math.sin(28538) + Math.cos(28539) * 20;
+acc += Math.sin(28539) + Math.cos(28540) * 21;
+acc += Math.sin(28540) + Math.cos(28541) * 22;
+acc += Math.sin(28541) + Math.cos(28542) * 23;
+acc += Math.sin(28542) + Math.cos(28543) * 24;
+acc += Math.sin(28543) + Math.cos(28544) * 25;
+acc += Math.sin(28544) + Math.cos(28545) * 26;
+acc += Math.sin(28545) + Math.cos(28546) * 27;
+acc += Math.sin(28546) + Math.cos(28547) * 28;
+acc += Math.sin(28547) + Math.cos(28548) * 29;
+acc += Math.sin(28548) + Math.cos(28549) * 30;
+acc += Math.sin(28549) + Math.cos(28550) * 31;
+acc += Math.sin(28550) + Math.cos(28551) * 32;
+acc += Math.sin(28551) + Math.cos(28552) * 33;
+acc += Math.sin(28552) + Math.cos(28553) * 34;
+acc += Math.sin(28553) + Math.cos(28554) * 35;
+acc += Math.sin(28554) + Math.cos(28555) * 36;
+acc += Math.sin(28555) + Math.cos(28556) * 37;
+acc += Math.sin(28556) + Math.cos(28557) * 38;
+acc += Math.sin(28557) + Math.cos(28558) * 39;
+acc += Math.sin(28558) + Math.cos(28559) * 40;
+acc += Math.sin(28559) + Math.cos(28560) * 41;
+acc += Math.sin(28560) + Math.cos(28561) * 42;
+acc += Math.sin(28561) + Math.cos(28562) * 43;
+acc += Math.sin(28562) + Math.cos(28563) * 44;
+acc += Math.sin(28563) + Math.cos(28564) * 45;
+acc += Math.sin(28564) + Math.cos(28565) * 46;
+acc += Math.sin(28565) + Math.cos(28566) * 47;
+acc += Math.sin(28566) + Math.cos(28567) * 48;
+acc += Math.sin(28567) + Math.cos(28568) * 49;
+acc += Math.sin(28568) + Math.cos(28569) * 50;
+acc += Math.sin(28569) + Math.cos(28570) * 51;
+acc += Math.sin(28570) + Math.cos(28571) * 52;
+acc += Math.sin(28571) + Math.cos(28572) * 53;
+acc += Math.sin(28572) + Math.cos(28573) * 54;
+acc += Math.sin(28573) + Math.cos(28574) * 55;
+acc += Math.sin(28574) + Math.cos(28575) * 56;
+acc += Math.sin(28575) + Math.cos(28576) * 57;
+acc += Math.sin(28576) + Math.cos(28577) * 58;
+acc += Math.sin(28577) + Math.cos(28578) * 59;
+acc += Math.sin(28578) + Math.cos(28579) * 60;
+acc += Math.sin(28579) + Math.cos(28580) * 61;
+acc += Math.sin(28580) + Math.cos(28581) * 62;
+acc += Math.sin(28581) + Math.cos(28582) * 63;
+acc += Math.sin(28582) + Math.cos(28583) * 64;
+acc += Math.sin(28583) + Math.cos(28584) * 65;
+acc += Math.sin(28584) + Math.cos(28585) * 66;
+acc += Math.sin(28585) + Math.cos(28586) * 67;
+acc += Math.sin(28586) + Math.cos(28587) * 68;
+acc += Math.sin(28587) + Math.cos(28588) * 69;
+acc += Math.sin(28588) + Math.cos(28589) * 70;
+acc += Math.sin(28589) + Math.cos(28590) * 71;
+acc += Math.sin(28590) + Math.cos(28591) * 72;
+acc += Math.sin(28591) + Math.cos(28592) * 73;
+acc += Math.sin(28592) + Math.cos(28593) * 74;
+acc += Math.sin(28593) + Math.cos(28594) * 75;
+acc += Math.sin(28594) + Math.cos(28595) * 76;
+acc += Math.sin(28595) + Math.cos(28596) * 77;
+acc += Math.sin(28596) + Math.cos(28597) * 78;
+acc += Math.sin(28597) + Math.cos(28598) * 79;
+acc += Math.sin(28598) + Math.cos(28599) * 80;
+acc += Math.sin(28599) + Math.cos(28600) * 81;
+acc += Math.sin(28600) + Math.cos(28601) * 82;
+acc += Math.sin(28601) + Math.cos(28602) * 83;
+acc += Math.sin(28602) + Math.cos(28603) * 84;
+acc += Math.sin(28603) + Math.cos(28604) * 85;
+acc += Math.sin(28604) + Math.cos(28605) * 86;
+acc += Math.sin(28605) + Math.cos(28606) * 87;
+acc += Math.sin(28606) + Math.cos(28607) * 88;
+acc += Math.sin(28607) + Math.cos(28608) * 89;
+acc += Math.sin(28608) + Math.cos(28609) * 90;
+acc += Math.sin(28609) + Math.cos(28610) * 91;
+acc += Math.sin(28610) + Math.cos(28611) * 92;
+acc += Math.sin(28611) + Math.cos(28612) * 93;
+acc += Math.sin(28612) + Math.cos(28613) * 94;
+acc += Math.sin(28613) + Math.cos(28614) * 95;
+acc += Math.sin(28614) + Math.cos(28615) * 96;
+acc += Math.sin(28615) + Math.cos(28616) * 0;
+acc += Math.sin(28616) + Math.cos(28617) * 1;
+acc += Math.sin(28617) + Math.cos(28618) * 2;
+acc += Math.sin(28618) + Math.cos(28619) * 3;
+acc += Math.sin(28619) + Math.cos(28620) * 4;
+acc += Math.sin(28620) + Math.cos(28621) * 5;
+acc += Math.sin(28621) + Math.cos(28622) * 6;
+acc += Math.sin(28622) + Math.cos(28623) * 7;
+acc += Math.sin(28623) + Math.cos(28624) * 8;
+acc += Math.sin(28624) + Math.cos(28625) * 9;
+acc += Math.sin(28625) + Math.cos(28626) * 10;
+acc += Math.sin(28626) + Math.cos(28627) * 11;
+acc += Math.sin(28627) + Math.cos(28628) * 12;
+acc += Math.sin(28628) + Math.cos(28629) * 13;
+acc += Math.sin(28629) + Math.cos(28630) * 14;
+acc += Math.sin(28630) + Math.cos(28631) * 15;
+acc += Math.sin(28631) + Math.cos(28632) * 16;
+acc += Math.sin(28632) + Math.cos(28633) * 17;
+acc += Math.sin(28633) + Math.cos(28634) * 18;
+acc += Math.sin(28634) + Math.cos(28635) * 19;
+acc += Math.sin(28635) + Math.cos(28636) * 20;
+acc += Math.sin(28636) + Math.cos(28637) * 21;
+acc += Math.sin(28637) + Math.cos(28638) * 22;
+acc += Math.sin(28638) + Math.cos(28639) * 23;
+acc += Math.sin(28639) + Math.cos(28640) * 24;
+acc += Math.sin(28640) + Math.cos(28641) * 25;
+acc += Math.sin(28641) + Math.cos(28642) * 26;
+acc += Math.sin(28642) + Math.cos(28643) * 27;
+acc += Math.sin(28643) + Math.cos(28644) * 28;
+acc += Math.sin(28644) + Math.cos(28645) * 29;
+acc += Math.sin(28645) + Math.cos(28646) * 30;
+acc += Math.sin(28646) + Math.cos(28647) * 31;
+acc += Math.sin(28647) + Math.cos(28648) * 32;
+acc += Math.sin(28648) + Math.cos(28649) * 33;
+acc += Math.sin(28649) + Math.cos(28650) * 34;
+acc += Math.sin(28650) + Math.cos(28651) * 35;
+acc += Math.sin(28651) + Math.cos(28652) * 36;
+acc += Math.sin(28652) + Math.cos(28653) * 37;
+acc += Math.sin(28653) + Math.cos(28654) * 38;
+acc += Math.sin(28654) + Math.cos(28655) * 39;
+acc += Math.sin(28655) + Math.cos(28656) * 40;
+acc += Math.sin(28656) + Math.cos(28657) * 41;
+acc += Math.sin(28657) + Math.cos(28658) * 42;
+acc += Math.sin(28658) + Math.cos(28659) * 43;
+acc += Math.sin(28659) + Math.cos(28660) * 44;
+acc += Math.sin(28660) + Math.cos(28661) * 45;
+acc += Math.sin(28661) + Math.cos(28662) * 46;
+acc += Math.sin(28662) + Math.cos(28663) * 47;
+acc += Math.sin(28663) + Math.cos(28664) * 48;
+acc += Math.sin(28664) + Math.cos(28665) * 49;
+acc += Math.sin(28665) + Math.cos(28666) * 50;
+acc += Math.sin(28666) + Math.cos(28667) * 51;
+acc += Math.sin(28667) + Math.cos(28668) * 52;
+acc += Math.sin(28668) + Math.cos(28669) * 53;
+acc += Math.sin(28669) + Math.cos(28670) * 54;
+acc += Math.sin(28670) + Math.cos(28671) * 55;
+acc += Math.sin(28671) + Math.cos(28672) * 56;
+acc += Math.sin(28672) + Math.cos(28673) * 57;
+acc += Math.sin(28673) + Math.cos(28674) * 58;
+acc += Math.sin(28674) + Math.cos(28675) * 59;
+acc += Math.sin(28675) + Math.cos(28676) * 60;
+acc += Math.sin(28676) + Math.cos(28677) * 61;
+acc += Math.sin(28677) + Math.cos(28678) * 62;
+acc += Math.sin(28678) + Math.cos(28679) * 63;
+acc += Math.sin(28679) + Math.cos(28680) * 64;
+acc += Math.sin(28680) + Math.cos(28681) * 65;
+acc += Math.sin(28681) + Math.cos(28682) * 66;
+acc += Math.sin(28682) + Math.cos(28683) * 67;
+acc += Math.sin(28683) + Math.cos(28684) * 68;
+acc += Math.sin(28684) + Math.cos(28685) * 69;
+acc += Math.sin(28685) + Math.cos(28686) * 70;
+acc += Math.sin(28686) + Math.cos(28687) * 71;
+acc += Math.sin(28687) + Math.cos(28688) * 72;
+acc += Math.sin(28688) + Math.cos(28689) * 73;
+acc += Math.sin(28689) + Math.cos(28690) * 74;
+acc += Math.sin(28690) + Math.cos(28691) * 75;
+acc += Math.sin(28691) + Math.cos(28692) * 76;
+acc += Math.sin(28692) + Math.cos(28693) * 77;
+acc += Math.sin(28693) + Math.cos(28694) * 78;
+acc += Math.sin(28694) + Math.cos(28695) * 79;
+acc += Math.sin(28695) + Math.cos(28696) * 80;
+acc += Math.sin(28696) + Math.cos(28697) * 81;
+acc += Math.sin(28697) + Math.cos(28698) * 82;
+acc += Math.sin(28698) + Math.cos(28699) * 83;
+acc += Math.sin(28699) + Math.cos(28700) * 84;
+acc += Math.sin(28700) + Math.cos(28701) * 85;
+acc += Math.sin(28701) + Math.cos(28702) * 86;
+acc += Math.sin(28702) + Math.cos(28703) * 87;
+acc += Math.sin(28703) + Math.cos(28704) * 88;
+acc += Math.sin(28704) + Math.cos(28705) * 89;
+acc += Math.sin(28705) + Math.cos(28706) * 90;
+acc += Math.sin(28706) + Math.cos(28707) * 91;
+acc += Math.sin(28707) + Math.cos(28708) * 92;
+acc += Math.sin(28708) + Math.cos(28709) * 93;
+acc += Math.sin(28709) + Math.cos(28710) * 94;
+acc += Math.sin(28710) + Math.cos(28711) * 95;
+acc += Math.sin(28711) + Math.cos(28712) * 96;
+acc += Math.sin(28712) + Math.cos(28713) * 0;
+acc += Math.sin(28713) + Math.cos(28714) * 1;
+acc += Math.sin(28714) + Math.cos(28715) * 2;
+acc += Math.sin(28715) + Math.cos(28716) * 3;
+acc += Math.sin(28716) + Math.cos(28717) * 4;
+acc += Math.sin(28717) + Math.cos(28718) * 5;
+acc += Math.sin(28718) + Math.cos(28719) * 6;
+acc += Math.sin(28719) + Math.cos(28720) * 7;
+acc += Math.sin(28720) + Math.cos(28721) * 8;
+acc += Math.sin(28721) + Math.cos(28722) * 9;
+acc += Math.sin(28722) + Math.cos(28723) * 10;
+acc += Math.sin(28723) + Math.cos(28724) * 11;
+acc += Math.sin(28724) + Math.cos(28725) * 12;
+acc += Math.sin(28725) + Math.cos(28726) * 13;
+acc += Math.sin(28726) + Math.cos(28727) * 14;
+acc += Math.sin(28727) + Math.cos(28728) * 15;
+acc += Math.sin(28728) + Math.cos(28729) * 16;
+acc += Math.sin(28729) + Math.cos(28730) * 17;
+acc += Math.sin(28730) + Math.cos(28731) * 18;
+acc += Math.sin(28731) + Math.cos(28732) * 19;
+acc += Math.sin(28732) + Math.cos(28733) * 20;
+acc += Math.sin(28733) + Math.cos(28734) * 21;
+acc += Math.sin(28734) + Math.cos(28735) * 22;
+acc += Math.sin(28735) + Math.cos(28736) * 23;
+acc += Math.sin(28736) + Math.cos(28737) * 24;
+acc += Math.sin(28737) + Math.cos(28738) * 25;
+acc += Math.sin(28738) + Math.cos(28739) * 26;
+acc += Math.sin(28739) + Math.cos(28740) * 27;
+acc += Math.sin(28740) + Math.cos(28741) * 28;
+acc += Math.sin(28741) + Math.cos(28742) * 29;
+acc += Math.sin(28742) + Math.cos(28743) * 30;
+acc += Math.sin(28743) + Math.cos(28744) * 31;
+acc += Math.sin(28744) + Math.cos(28745) * 32;
+acc += Math.sin(28745) + Math.cos(28746) * 33;
+acc += Math.sin(28746) + Math.cos(28747) * 34;
+acc += Math.sin(28747) + Math.cos(28748) * 35;
+acc += Math.sin(28748) + Math.cos(28749) * 36;
+acc += Math.sin(28749) + Math.cos(28750) * 37;
+acc += Math.sin(28750) + Math.cos(28751) * 38;
+acc += Math.sin(28751) + Math.cos(28752) * 39;
+acc += Math.sin(28752) + Math.cos(28753) * 40;
+acc += Math.sin(28753) + Math.cos(28754) * 41;
+acc += Math.sin(28754) + Math.cos(28755) * 42;
+acc += Math.sin(28755) + Math.cos(28756) * 43;
+acc += Math.sin(28756) + Math.cos(28757) * 44;
+acc += Math.sin(28757) + Math.cos(28758) * 45;
+acc += Math.sin(28758) + Math.cos(28759) * 46;
+acc += Math.sin(28759) + Math.cos(28760) * 47;
+acc += Math.sin(28760) + Math.cos(28761) * 48;
+acc += Math.sin(28761) + Math.cos(28762) * 49;
+acc += Math.sin(28762) + Math.cos(28763) * 50;
+acc += Math.sin(28763) + Math.cos(28764) * 51;
+acc += Math.sin(28764) + Math.cos(28765) * 52;
+acc += Math.sin(28765) + Math.cos(28766) * 53;
+acc += Math.sin(28766) + Math.cos(28767) * 54;
+acc += Math.sin(28767) + Math.cos(28768) * 55;
+acc += Math.sin(28768) + Math.cos(28769) * 56;
+acc += Math.sin(28769) + Math.cos(28770) * 57;
+acc += Math.sin(28770) + Math.cos(28771) * 58;
+acc += Math.sin(28771) + Math.cos(28772) * 59;
+acc += Math.sin(28772) + Math.cos(28773) * 60;
+acc += Math.sin(28773) + Math.cos(28774) * 61;
+acc += Math.sin(28774) + Math.cos(28775) * 62;
+acc += Math.sin(28775) + Math.cos(28776) * 63;
+acc += Math.sin(28776) + Math.cos(28777) * 64;
+acc += Math.sin(28777) + Math.cos(28778) * 65;
+acc += Math.sin(28778) + Math.cos(28779) * 66;
+acc += Math.sin(28779) + Math.cos(28780) * 67;
+acc += Math.sin(28780) + Math.cos(28781) * 68;
+acc += Math.sin(28781) + Math.cos(28782) * 69;
+acc += Math.sin(28782) + Math.cos(28783) * 70;
+acc += Math.sin(28783) + Math.cos(28784) * 71;
+acc += Math.sin(28784) + Math.cos(28785) * 72;
+acc += Math.sin(28785) + Math.cos(28786) * 73;
+acc += Math.sin(28786) + Math.cos(28787) * 74;
+acc += Math.sin(28787) + Math.cos(28788) * 75;
+acc += Math.sin(28788) + Math.cos(28789) * 76;
+acc += Math.sin(28789) + Math.cos(28790) * 77;
+acc += Math.sin(28790) + Math.cos(28791) * 78;
+acc += Math.sin(28791) + Math.cos(28792) * 79;
+acc += Math.sin(28792) + Math.cos(28793) * 80;
+acc += Math.sin(28793) + Math.cos(28794) * 81;
+acc += Math.sin(28794) + Math.cos(28795) * 82;
+acc += Math.sin(28795) + Math.cos(28796) * 83;
+acc += Math.sin(28796) + Math.cos(28797) * 84;
+acc += Math.sin(28797) + Math.cos(28798) * 85;
+acc += Math.sin(28798) + Math.cos(28799) * 86;
+acc += Math.sin(28799) + Math.cos(28800) * 87;
+acc += Math.sin(28800) + Math.cos(28801) * 88;
+acc += Math.sin(28801) + Math.cos(28802) * 89;
+acc += Math.sin(28802) + Math.cos(28803) * 90;
+acc += Math.sin(28803) + Math.cos(28804) * 91;
+acc += Math.sin(28804) + Math.cos(28805) * 92;
+acc += Math.sin(28805) + Math.cos(28806) * 93;
+acc += Math.sin(28806) + Math.cos(28807) * 94;
+acc += Math.sin(28807) + Math.cos(28808) * 95;
+acc += Math.sin(28808) + Math.cos(28809) * 96;
+acc += Math.sin(28809) + Math.cos(28810) * 0;
+acc += Math.sin(28810) + Math.cos(28811) * 1;
+acc += Math.sin(28811) + Math.cos(28812) * 2;
+acc += Math.sin(28812) + Math.cos(28813) * 3;
+acc += Math.sin(28813) + Math.cos(28814) * 4;
+acc += Math.sin(28814) + Math.cos(28815) * 5;
+acc += Math.sin(28815) + Math.cos(28816) * 6;
+acc += Math.sin(28816) + Math.cos(28817) * 7;
+acc += Math.sin(28817) + Math.cos(28818) * 8;
+acc += Math.sin(28818) + Math.cos(28819) * 9;
+acc += Math.sin(28819) + Math.cos(28820) * 10;
+acc += Math.sin(28820) + Math.cos(28821) * 11;
+acc += Math.sin(28821) + Math.cos(28822) * 12;
+acc += Math.sin(28822) + Math.cos(28823) * 13;
+acc += Math.sin(28823) + Math.cos(28824) * 14;
+acc += Math.sin(28824) + Math.cos(28825) * 15;
+acc += Math.sin(28825) + Math.cos(28826) * 16;
+acc += Math.sin(28826) + Math.cos(28827) * 17;
+acc += Math.sin(28827) + Math.cos(28828) * 18;
+acc += Math.sin(28828) + Math.cos(28829) * 19;
+acc += Math.sin(28829) + Math.cos(28830) * 20;
+acc += Math.sin(28830) + Math.cos(28831) * 21;
+acc += Math.sin(28831) + Math.cos(28832) * 22;
+acc += Math.sin(28832) + Math.cos(28833) * 23;
+acc += Math.sin(28833) + Math.cos(28834) * 24;
+acc += Math.sin(28834) + Math.cos(28835) * 25;
+acc += Math.sin(28835) + Math.cos(28836) * 26;
+acc += Math.sin(28836) + Math.cos(28837) * 27;
+acc += Math.sin(28837) + Math.cos(28838) * 28;
+acc += Math.sin(28838) + Math.cos(28839) * 29;
+acc += Math.sin(28839) + Math.cos(28840) * 30;
+acc += Math.sin(28840) + Math.cos(28841) * 31;
+acc += Math.sin(28841) + Math.cos(28842) * 32;
+acc += Math.sin(28842) + Math.cos(28843) * 33;
+acc += Math.sin(28843) + Math.cos(28844) * 34;
+acc += Math.sin(28844) + Math.cos(28845) * 35;
+acc += Math.sin(28845) + Math.cos(28846) * 36;
+acc += Math.sin(28846) + Math.cos(28847) * 37;
+acc += Math.sin(28847) + Math.cos(28848) * 38;
+acc += Math.sin(28848) + Math.cos(28849) * 39;
+acc += Math.sin(28849) + Math.cos(28850) * 40;
+acc += Math.sin(28850) + Math.cos(28851) * 41;
+acc += Math.sin(28851) + Math.cos(28852) * 42;
+acc += Math.sin(28852) + Math.cos(28853) * 43;
+acc += Math.sin(28853) + Math.cos(28854) * 44;
+acc += Math.sin(28854) + Math.cos(28855) * 45;
+acc += Math.sin(28855) + Math.cos(28856) * 46;
+acc += Math.sin(28856) + Math.cos(28857) * 47;
+acc += Math.sin(28857) + Math.cos(28858) * 48;
+acc += Math.sin(28858) + Math.cos(28859) * 49;
+acc += Math.sin(28859) + Math.cos(28860) * 50;
+acc += Math.sin(28860) + Math.cos(28861) * 51;
+acc += Math.sin(28861) + Math.cos(28862) * 52;
+acc += Math.sin(28862) + Math.cos(28863) * 53;
+acc += Math.sin(28863) + Math.cos(28864) * 54;
+acc += Math.sin(28864) + Math.cos(28865) * 55;
+acc += Math.sin(28865) + Math.cos(28866) * 56;
+acc += Math.sin(28866) + Math.cos(28867) * 57;
+acc += Math.sin(28867) + Math.cos(28868) * 58;
+acc += Math.sin(28868) + Math.cos(28869) * 59;
+acc += Math.sin(28869) + Math.cos(28870) * 60;
+acc += Math.sin(28870) + Math.cos(28871) * 61;
+acc += Math.sin(28871) + Math.cos(28872) * 62;
+acc += Math.sin(28872) + Math.cos(28873) * 63;
+acc += Math.sin(28873) + Math.cos(28874) * 64;
+acc += Math.sin(28874) + Math.cos(28875) * 65;
+acc += Math.sin(28875) + Math.cos(28876) * 66;
+acc += Math.sin(28876) + Math.cos(28877) * 67;
+acc += Math.sin(28877) + Math.cos(28878) * 68;
+acc += Math.sin(28878) + Math.cos(28879) * 69;
+acc += Math.sin(28879) + Math.cos(28880) * 70;
+acc += Math.sin(28880) + Math.cos(28881) * 71;
+acc += Math.sin(28881) + Math.cos(28882) * 72;
+acc += Math.sin(28882) + Math.cos(28883) * 73;
+acc += Math.sin(28883) + Math.cos(28884) * 74;
+acc += Math.sin(28884) + Math.cos(28885) * 75;
+acc += Math.sin(28885) + Math.cos(28886) * 76;
+acc += Math.sin(28886) + Math.cos(28887) * 77;
+acc += Math.sin(28887) + Math.cos(28888) * 78;
+acc += Math.sin(28888) + Math.cos(28889) * 79;
+acc += Math.sin(28889) + Math.cos(28890) * 80;
+acc += Math.sin(28890) + Math.cos(28891) * 81;
+acc += Math.sin(28891) + Math.cos(28892) * 82;
+acc += Math.sin(28892) + Math.cos(28893) * 83;
+acc += Math.sin(28893) + Math.cos(28894) * 84;
+acc += Math.sin(28894) + Math.cos(28895) * 85;
+acc += Math.sin(28895) + Math.cos(28896) * 86;
+acc += Math.sin(28896) + Math.cos(28897) * 87;
+acc += Math.sin(28897) + Math.cos(28898) * 88;
+acc += Math.sin(28898) + Math.cos(28899) * 89;
+acc += Math.sin(28899) + Math.cos(28900) * 90;
+acc += Math.sin(28900) + Math.cos(28901) * 91;
+acc += Math.sin(28901) + Math.cos(28902) * 92;
+acc += Math.sin(28902) + Math.cos(28903) * 93;
+acc += Math.sin(28903) + Math.cos(28904) * 94;
+acc += Math.sin(28904) + Math.cos(28905) * 95;
+acc += Math.sin(28905) + Math.cos(28906) * 96;
+acc += Math.sin(28906) + Math.cos(28907) * 0;
+acc += Math.sin(28907) + Math.cos(28908) * 1;
+acc += Math.sin(28908) + Math.cos(28909) * 2;
+acc += Math.sin(28909) + Math.cos(28910) * 3;
+acc += Math.sin(28910) + Math.cos(28911) * 4;
+acc += Math.sin(28911) + Math.cos(28912) * 5;
+acc += Math.sin(28912) + Math.cos(28913) * 6;
+acc += Math.sin(28913) + Math.cos(28914) * 7;
+acc += Math.sin(28914) + Math.cos(28915) * 8;
+acc += Math.sin(28915) + Math.cos(28916) * 9;
+acc += Math.sin(28916) + Math.cos(28917) * 10;
+acc += Math.sin(28917) + Math.cos(28918) * 11;
+acc += Math.sin(28918) + Math.cos(28919) * 12;
+acc += Math.sin(28919) + Math.cos(28920) * 13;
+acc += Math.sin(28920) + Math.cos(28921) * 14;
+acc += Math.sin(28921) + Math.cos(28922) * 15;
+acc += Math.sin(28922) + Math.cos(28923) * 16;
+acc += Math.sin(28923) + Math.cos(28924) * 17;
+acc += Math.sin(28924) + Math.cos(28925) * 18;
+acc += Math.sin(28925) + Math.cos(28926) * 19;
+acc += Math.sin(28926) + Math.cos(28927) * 20;
+acc += Math.sin(28927) + Math.cos(28928) * 21;
+acc += Math.sin(28928) + Math.cos(28929) * 22;
+acc += Math.sin(28929) + Math.cos(28930) * 23;
+acc += Math.sin(28930) + Math.cos(28931) * 24;
+acc += Math.sin(28931) + Math.cos(28932) * 25;
+acc += Math.sin(28932) + Math.cos(28933) * 26;
+acc += Math.sin(28933) + Math.cos(28934) * 27;
+acc += Math.sin(28934) + Math.cos(28935) * 28;
+acc += Math.sin(28935) + Math.cos(28936) * 29;
+acc += Math.sin(28936) + Math.cos(28937) * 30;
+acc += Math.sin(28937) + Math.cos(28938) * 31;
+acc += Math.sin(28938) + Math.cos(28939) * 32;
+acc += Math.sin(28939) + Math.cos(28940) * 33;
+acc += Math.sin(28940) + Math.cos(28941) * 34;
+acc += Math.sin(28941) + Math.cos(28942) * 35;
+acc += Math.sin(28942) + Math.cos(28943) * 36;
+acc += Math.sin(28943) + Math.cos(28944) * 37;
+acc += Math.sin(28944) + Math.cos(28945) * 38;
+acc += Math.sin(28945) + Math.cos(28946) * 39;
+acc += Math.sin(28946) + Math.cos(28947) * 40;
+acc += Math.sin(28947) + Math.cos(28948) * 41;
+acc += Math.sin(28948) + Math.cos(28949) * 42;
+acc += Math.sin(28949) + Math.cos(28950) * 43;
+acc += Math.sin(28950) + Math.cos(28951) * 44;
+acc += Math.sin(28951) + Math.cos(28952) * 45;
+acc += Math.sin(28952) + Math.cos(28953) * 46;
+acc += Math.sin(28953) + Math.cos(28954) * 47;
+acc += Math.sin(28954) + Math.cos(28955) * 48;
+acc += Math.sin(28955) + Math.cos(28956) * 49;
+acc += Math.sin(28956) + Math.cos(28957) * 50;
+acc += Math.sin(28957) + Math.cos(28958) * 51;
+acc += Math.sin(28958) + Math.cos(28959) * 52;
+acc += Math.sin(28959) + Math.cos(28960) * 53;
+acc += Math.sin(28960) + Math.cos(28961) * 54;
+acc += Math.sin(28961) + Math.cos(28962) * 55;
+acc += Math.sin(28962) + Math.cos(28963) * 56;
+acc += Math.sin(28963) + Math.cos(28964) * 57;
+acc += Math.sin(28964) + Math.cos(28965) * 58;
+acc += Math.sin(28965) + Math.cos(28966) * 59;
+acc += Math.sin(28966) + Math.cos(28967) * 60;
+acc += Math.sin(28967) + Math.cos(28968) * 61;
+acc += Math.sin(28968) + Math.cos(28969) * 62;
+acc += Math.sin(28969) + Math.cos(28970) * 63;
+acc += Math.sin(28970) + Math.cos(28971) * 64;
+acc += Math.sin(28971) + Math.cos(28972) * 65;
+acc += Math.sin(28972) + Math.cos(28973) * 66;
+acc += Math.sin(28973) + Math.cos(28974) * 67;
+acc += Math.sin(28974) + Math.cos(28975) * 68;
+acc += Math.sin(28975) + Math.cos(28976) * 69;
+acc += Math.sin(28976) + Math.cos(28977) * 70;
+acc += Math.sin(28977) + Math.cos(28978) * 71;
+acc += Math.sin(28978) + Math.cos(28979) * 72;
+acc += Math.sin(28979) + Math.cos(28980) * 73;
+acc += Math.sin(28980) + Math.cos(28981) * 74;
+acc += Math.sin(28981) + Math.cos(28982) * 75;
+acc += Math.sin(28982) + Math.cos(28983) * 76;
+acc += Math.sin(28983) + Math.cos(28984) * 77;
+acc += Math.sin(28984) + Math.cos(28985) * 78;
+acc += Math.sin(28985) + Math.cos(28986) * 79;
+acc += Math.sin(28986) + Math.cos(28987) * 80;
+acc += Math.sin(28987) + Math.cos(28988) * 81;
+acc += Math.sin(28988) + Math.cos(28989) * 82;
+acc += Math.sin(28989) + Math.cos(28990) * 83;
+acc += Math.sin(28990) + Math.cos(28991) * 84;
+acc += Math.sin(28991) + Math.cos(28992) * 85;
+acc += Math.sin(28992) + Math.cos(28993) * 86;
+acc += Math.sin(28993) + Math.cos(28994) * 87;
+acc += Math.sin(28994) + Math.cos(28995) * 88;
+acc += Math.sin(28995) + Math.cos(28996) * 89;
+acc += Math.sin(28996) + Math.cos(28997) * 90;
+acc += Math.sin(28997) + Math.cos(28998) * 91;
+acc += Math.sin(28998) + Math.cos(28999) * 92;
+acc += Math.sin(28999) + Math.cos(29000) * 93;
+acc += Math.sin(29000) + Math.cos(29001) * 94;
+acc += Math.sin(29001) + Math.cos(29002) * 95;
+acc += Math.sin(29002) + Math.cos(29003) * 96;
+acc += Math.sin(29003) + Math.cos(29004) * 0;
+acc += Math.sin(29004) + Math.cos(29005) * 1;
+acc += Math.sin(29005) + Math.cos(29006) * 2;
+acc += Math.sin(29006) + Math.cos(29007) * 3;
+acc += Math.sin(29007) + Math.cos(29008) * 4;
+acc += Math.sin(29008) + Math.cos(29009) * 5;
+acc += Math.sin(29009) + Math.cos(29010) * 6;
+acc += Math.sin(29010) + Math.cos(29011) * 7;
+acc += Math.sin(29011) + Math.cos(29012) * 8;
+acc += Math.sin(29012) + Math.cos(29013) * 9;
+acc += Math.sin(29013) + Math.cos(29014) * 10;
+acc += Math.sin(29014) + Math.cos(29015) * 11;
+acc += Math.sin(29015) + Math.cos(29016) * 12;
+acc += Math.sin(29016) + Math.cos(29017) * 13;
+acc += Math.sin(29017) + Math.cos(29018) * 14;
+acc += Math.sin(29018) + Math.cos(29019) * 15;
+acc += Math.sin(29019) + Math.cos(29020) * 16;
+acc += Math.sin(29020) + Math.cos(29021) * 17;
+acc += Math.sin(29021) + Math.cos(29022) * 18;
+acc += Math.sin(29022) + Math.cos(29023) * 19;
+acc += Math.sin(29023) + Math.cos(29024) * 20;
+acc += Math.sin(29024) + Math.cos(29025) * 21;
+acc += Math.sin(29025) + Math.cos(29026) * 22;
+acc += Math.sin(29026) + Math.cos(29027) * 23;
+acc += Math.sin(29027) + Math.cos(29028) * 24;
+acc += Math.sin(29028) + Math.cos(29029) * 25;
+acc += Math.sin(29029) + Math.cos(29030) * 26;
+acc += Math.sin(29030) + Math.cos(29031) * 27;
+acc += Math.sin(29031) + Math.cos(29032) * 28;
+acc += Math.sin(29032) + Math.cos(29033) * 29;
+acc += Math.sin(29033) + Math.cos(29034) * 30;
+acc += Math.sin(29034) + Math.cos(29035) * 31;
+acc += Math.sin(29035) + Math.cos(29036) * 32;
+acc += Math.sin(29036) + Math.cos(29037) * 33;
+acc += Math.sin(29037) + Math.cos(29038) * 34;
+acc += Math.sin(29038) + Math.cos(29039) * 35;
+acc += Math.sin(29039) + Math.cos(29040) * 36;
+acc += Math.sin(29040) + Math.cos(29041) * 37;
+acc += Math.sin(29041) + Math.cos(29042) * 38;
+acc += Math.sin(29042) + Math.cos(29043) * 39;
+acc += Math.sin(29043) + Math.cos(29044) * 40;
+acc += Math.sin(29044) + Math.cos(29045) * 41;
+acc += Math.sin(29045) + Math.cos(29046) * 42;
+acc += Math.sin(29046) + Math.cos(29047) * 43;
+acc += Math.sin(29047) + Math.cos(29048) * 44;
+acc += Math.sin(29048) + Math.cos(29049) * 45;
+acc += Math.sin(29049) + Math.cos(29050) * 46;
+acc += Math.sin(29050) + Math.cos(29051) * 47;
+acc += Math.sin(29051) + Math.cos(29052) * 48;
+acc += Math.sin(29052) + Math.cos(29053) * 49;
+acc += Math.sin(29053) + Math.cos(29054) * 50;
+acc += Math.sin(29054) + Math.cos(29055) * 51;
+acc += Math.sin(29055) + Math.cos(29056) * 52;
+acc += Math.sin(29056) + Math.cos(29057) * 53;
+acc += Math.sin(29057) + Math.cos(29058) * 54;
+acc += Math.sin(29058) + Math.cos(29059) * 55;
+acc += Math.sin(29059) + Math.cos(29060) * 56;
+acc += Math.sin(29060) + Math.cos(29061) * 57;
+acc += Math.sin(29061) + Math.cos(29062) * 58;
+acc += Math.sin(29062) + Math.cos(29063) * 59;
+acc += Math.sin(29063) + Math.cos(29064) * 60;
+acc += Math.sin(29064) + Math.cos(29065) * 61;
+acc += Math.sin(29065) + Math.cos(29066) * 62;
+acc += Math.sin(29066) + Math.cos(29067) * 63;
+acc += Math.sin(29067) + Math.cos(29068) * 64;
+acc += Math.sin(29068) + Math.cos(29069) * 65;
+acc += Math.sin(29069) + Math.cos(29070) * 66;
+acc += Math.sin(29070) + Math.cos(29071) * 67;
+acc += Math.sin(29071) + Math.cos(29072) * 68;
+acc += Math.sin(29072) + Math.cos(29073) * 69;
+acc += Math.sin(29073) + Math.cos(29074) * 70;
+acc += Math.sin(29074) + Math.cos(29075) * 71;
+acc += Math.sin(29075) + Math.cos(29076) * 72;
+acc += Math.sin(29076) + Math.cos(29077) * 73;
+acc += Math.sin(29077) + Math.cos(29078) * 74;
+acc += Math.sin(29078) + Math.cos(29079) * 75;
+acc += Math.sin(29079) + Math.cos(29080) * 76;
+acc += Math.sin(29080) + Math.cos(29081) * 77;
+acc += Math.sin(29081) + Math.cos(29082) * 78;
+acc += Math.sin(29082) + Math.cos(29083) * 79;
+acc += Math.sin(29083) + Math.cos(29084) * 80;
+acc += Math.sin(29084) + Math.cos(29085) * 81;
+acc += Math.sin(29085) + Math.cos(29086) * 82;
+acc += Math.sin(29086) + Math.cos(29087) * 83;
+acc += Math.sin(29087) + Math.cos(29088) * 84;
+acc += Math.sin(29088) + Math.cos(29089) * 85;
+acc += Math.sin(29089) + Math.cos(29090) * 86;
+acc += Math.sin(29090) + Math.cos(29091) * 87;
+acc += Math.sin(29091) + Math.cos(29092) * 88;
+acc += Math.sin(29092) + Math.cos(29093) * 89;
+acc += Math.sin(29093) + Math.cos(29094) * 90;
+acc += Math.sin(29094) + Math.cos(29095) * 91;
+acc += Math.sin(29095) + Math.cos(29096) * 92;
+acc += Math.sin(29096) + Math.cos(29097) * 93;
+acc += Math.sin(29097) + Math.cos(29098) * 94;
+acc += Math.sin(29098) + Math.cos(29099) * 95;
+acc += Math.sin(29099) + Math.cos(29100) * 96;
+acc += Math.sin(29100) + Math.cos(29101) * 0;
+acc += Math.sin(29101) + Math.cos(29102) * 1;
+acc += Math.sin(29102) + Math.cos(29103) * 2;
+acc += Math.sin(29103) + Math.cos(29104) * 3;
+acc += Math.sin(29104) + Math.cos(29105) * 4;
+acc += Math.sin(29105) + Math.cos(29106) * 5;
+acc += Math.sin(29106) + Math.cos(29107) * 6;
+acc += Math.sin(29107) + Math.cos(29108) * 7;
+acc += Math.sin(29108) + Math.cos(29109) * 8;
+acc += Math.sin(29109) + Math.cos(29110) * 9;
+acc += Math.sin(29110) + Math.cos(29111) * 10;
+acc += Math.sin(29111) + Math.cos(29112) * 11;
+acc += Math.sin(29112) + Math.cos(29113) * 12;
+acc += Math.sin(29113) + Math.cos(29114) * 13;
+acc += Math.sin(29114) + Math.cos(29115) * 14;
+acc += Math.sin(29115) + Math.cos(29116) * 15;
+acc += Math.sin(29116) + Math.cos(29117) * 16;
+acc += Math.sin(29117) + Math.cos(29118) * 17;
+acc += Math.sin(29118) + Math.cos(29119) * 18;
+acc += Math.sin(29119) + Math.cos(29120) * 19;
+acc += Math.sin(29120) + Math.cos(29121) * 20;
+acc += Math.sin(29121) + Math.cos(29122) * 21;
+acc += Math.sin(29122) + Math.cos(29123) * 22;
+acc += Math.sin(29123) + Math.cos(29124) * 23;
+acc += Math.sin(29124) + Math.cos(29125) * 24;
+acc += Math.sin(29125) + Math.cos(29126) * 25;
+acc += Math.sin(29126) + Math.cos(29127) * 26;
+acc += Math.sin(29127) + Math.cos(29128) * 27;
+acc += Math.sin(29128) + Math.cos(29129) * 28;
+acc += Math.sin(29129) + Math.cos(29130) * 29;
+acc += Math.sin(29130) + Math.cos(29131) * 30;
+acc += Math.sin(29131) + Math.cos(29132) * 31;
+acc += Math.sin(29132) + Math.cos(29133) * 32;
+acc += Math.sin(29133) + Math.cos(29134) * 33;
+acc += Math.sin(29134) + Math.cos(29135) * 34;
+acc += Math.sin(29135) + Math.cos(29136) * 35;
+acc += Math.sin(29136) + Math.cos(29137) * 36;
+acc += Math.sin(29137) + Math.cos(29138) * 37;
+acc += Math.sin(29138) + Math.cos(29139) * 38;
+acc += Math.sin(29139) + Math.cos(29140) * 39;
+acc += Math.sin(29140) + Math.cos(29141) * 40;
+acc += Math.sin(29141) + Math.cos(29142) * 41;
+acc += Math.sin(29142) + Math.cos(29143) * 42;
+acc += Math.sin(29143) + Math.cos(29144) * 43;
+acc += Math.sin(29144) + Math.cos(29145) * 44;
+acc += Math.sin(29145) + Math.cos(29146) * 45;
+acc += Math.sin(29146) + Math.cos(29147) * 46;
+acc += Math.sin(29147) + Math.cos(29148) * 47;
+acc += Math.sin(29148) + Math.cos(29149) * 48;
+acc += Math.sin(29149) + Math.cos(29150) * 49;
+acc += Math.sin(29150) + Math.cos(29151) * 50;
+acc += Math.sin(29151) + Math.cos(29152) * 51;
+acc += Math.sin(29152) + Math.cos(29153) * 52;
+acc += Math.sin(29153) + Math.cos(29154) * 53;
+acc += Math.sin(29154) + Math.cos(29155) * 54;
+acc += Math.sin(29155) + Math.cos(29156) * 55;
+acc += Math.sin(29156) + Math.cos(29157) * 56;
+acc += Math.sin(29157) + Math.cos(29158) * 57;
+acc += Math.sin(29158) + Math.cos(29159) * 58;
+acc += Math.sin(29159) + Math.cos(29160) * 59;
+acc += Math.sin(29160) + Math.cos(29161) * 60;
+acc += Math.sin(29161) + Math.cos(29162) * 61;
+acc += Math.sin(29162) + Math.cos(29163) * 62;
+acc += Math.sin(29163) + Math.cos(29164) * 63;
+acc += Math.sin(29164) + Math.cos(29165) * 64;
+acc += Math.sin(29165) + Math.cos(29166) * 65;
+acc += Math.sin(29166) + Math.cos(29167) * 66;
+acc += Math.sin(29167) + Math.cos(29168) * 67;
+acc += Math.sin(29168) + Math.cos(29169) * 68;
+acc += Math.sin(29169) + Math.cos(29170) * 69;
+acc += Math.sin(29170) + Math.cos(29171) * 70;
+acc += Math.sin(29171) + Math.cos(29172) * 71;
+acc += Math.sin(29172) + Math.cos(29173) * 72;
+acc += Math.sin(29173) + Math.cos(29174) * 73;
+acc += Math.sin(29174) + Math.cos(29175) * 74;
+acc += Math.sin(29175) + Math.cos(29176) * 75;
+acc += Math.sin(29176) + Math.cos(29177) * 76;
+acc += Math.sin(29177) + Math.cos(29178) * 77;
+acc += Math.sin(29178) + Math.cos(29179) * 78;
+acc += Math.sin(29179) + Math.cos(29180) * 79;
+acc += Math.sin(29180) + Math.cos(29181) * 80;
+acc += Math.sin(29181) + Math.cos(29182) * 81;
+acc += Math.sin(29182) + Math.cos(29183) * 82;
+acc += Math.sin(29183) + Math.cos(29184) * 83;
+acc += Math.sin(29184) + Math.cos(29185) * 84;
+acc += Math.sin(29185) + Math.cos(29186) * 85;
+acc += Math.sin(29186) + Math.cos(29187) * 86;
+acc += Math.sin(29187) + Math.cos(29188) * 87;
+acc += Math.sin(29188) + Math.cos(29189) * 88;
+acc += Math.sin(29189) + Math.cos(29190) * 89;
+acc += Math.sin(29190) + Math.cos(29191) * 90;
+acc += Math.sin(29191) + Math.cos(29192) * 91;
+acc += Math.sin(29192) + Math.cos(29193) * 92;
+acc += Math.sin(29193) + Math.cos(29194) * 93;
+acc += Math.sin(29194) + Math.cos(29195) * 94;
+acc += Math.sin(29195) + Math.cos(29196) * 95;
+acc += Math.sin(29196) + Math.cos(29197) * 96;
+acc += Math.sin(29197) + Math.cos(29198) * 0;
+acc += Math.sin(29198) + Math.cos(29199) * 1;
+acc += Math.sin(29199) + Math.cos(29200) * 2;
+acc += Math.sin(29200) + Math.cos(29201) * 3;
+acc += Math.sin(29201) + Math.cos(29202) * 4;
+acc += Math.sin(29202) + Math.cos(29203) * 5;
+acc += Math.sin(29203) + Math.cos(29204) * 6;
+acc += Math.sin(29204) + Math.cos(29205) * 7;
+acc += Math.sin(29205) + Math.cos(29206) * 8;
+acc += Math.sin(29206) + Math.cos(29207) * 9;
+acc += Math.sin(29207) + Math.cos(29208) * 10;
+acc += Math.sin(29208) + Math.cos(29209) * 11;
+acc += Math.sin(29209) + Math.cos(29210) * 12;
+acc += Math.sin(29210) + Math.cos(29211) * 13;
+acc += Math.sin(29211) + Math.cos(29212) * 14;
+acc += Math.sin(29212) + Math.cos(29213) * 15;
+acc += Math.sin(29213) + Math.cos(29214) * 16;
+acc += Math.sin(29214) + Math.cos(29215) * 17;
+acc += Math.sin(29215) + Math.cos(29216) * 18;
+acc += Math.sin(29216) + Math.cos(29217) * 19;
+acc += Math.sin(29217) + Math.cos(29218) * 20;
+acc += Math.sin(29218) + Math.cos(29219) * 21;
+acc += Math.sin(29219) + Math.cos(29220) * 22;
+acc += Math.sin(29220) + Math.cos(29221) * 23;
+acc += Math.sin(29221) + Math.cos(29222) * 24;
+acc += Math.sin(29222) + Math.cos(29223) * 25;
+acc += Math.sin(29223) + Math.cos(29224) * 26;
+acc += Math.sin(29224) + Math.cos(29225) * 27;
+acc += Math.sin(29225) + Math.cos(29226) * 28;
+acc += Math.sin(29226) + Math.cos(29227) * 29;
+acc += Math.sin(29227) + Math.cos(29228) * 30;
+acc += Math.sin(29228) + Math.cos(29229) * 31;
+acc += Math.sin(29229) + Math.cos(29230) * 32;
+acc += Math.sin(29230) + Math.cos(29231) * 33;
+acc += Math.sin(29231) + Math.cos(29232) * 34;
+acc += Math.sin(29232) + Math.cos(29233) * 35;
+acc += Math.sin(29233) + Math.cos(29234) * 36;
+acc += Math.sin(29234) + Math.cos(29235) * 37;
+acc += Math.sin(29235) + Math.cos(29236) * 38;
+acc += Math.sin(29236) + Math.cos(29237) * 39;
+acc += Math.sin(29237) + Math.cos(29238) * 40;
+acc += Math.sin(29238) + Math.cos(29239) * 41;
+acc += Math.sin(29239) + Math.cos(29240) * 42;
+acc += Math.sin(29240) + Math.cos(29241) * 43;
+acc += Math.sin(29241) + Math.cos(29242) * 44;
+acc += Math.sin(29242) + Math.cos(29243) * 45;
+acc += Math.sin(29243) + Math.cos(29244) * 46;
+acc += Math.sin(29244) + Math.cos(29245) * 47;
+acc += Math.sin(29245) + Math.cos(29246) * 48;
+acc += Math.sin(29246) + Math.cos(29247) * 49;
+acc += Math.sin(29247) + Math.cos(29248) * 50;
+acc += Math.sin(29248) + Math.cos(29249) * 51;
+acc += Math.sin(29249) + Math.cos(29250) * 52;
+acc += Math.sin(29250) + Math.cos(29251) * 53;
+acc += Math.sin(29251) + Math.cos(29252) * 54;
+acc += Math.sin(29252) + Math.cos(29253) * 55;
+acc += Math.sin(29253) + Math.cos(29254) * 56;
+acc += Math.sin(29254) + Math.cos(29255) * 57;
+acc += Math.sin(29255) + Math.cos(29256) * 58;
+acc += Math.sin(29256) + Math.cos(29257) * 59;
+acc += Math.sin(29257) + Math.cos(29258) * 60;
+acc += Math.sin(29258) + Math.cos(29259) * 61;
+acc += Math.sin(29259) + Math.cos(29260) * 62;
+acc += Math.sin(29260) + Math.cos(29261) * 63;
+acc += Math.sin(29261) + Math.cos(29262) * 64;
+acc += Math.sin(29262) + Math.cos(29263) * 65;
+acc += Math.sin(29263) + Math.cos(29264) * 66;
+acc += Math.sin(29264) + Math.cos(29265) * 67;
+acc += Math.sin(29265) + Math.cos(29266) * 68;
+acc += Math.sin(29266) + Math.cos(29267) * 69;
+acc += Math.sin(29267) + Math.cos(29268) * 70;
+acc += Math.sin(29268) + Math.cos(29269) * 71;
+acc += Math.sin(29269) + Math.cos(29270) * 72;
+acc += Math.sin(29270) + Math.cos(29271) * 73;
+acc += Math.sin(29271) + Math.cos(29272) * 74;
+acc += Math.sin(29272) + Math.cos(29273) * 75;
+acc += Math.sin(29273) + Math.cos(29274) * 76;
+acc += Math.sin(29274) + Math.cos(29275) * 77;
+acc += Math.sin(29275) + Math.cos(29276) * 78;
+acc += Math.sin(29276) + Math.cos(29277) * 79;
+acc += Math.sin(29277) + Math.cos(29278) * 80;
+acc += Math.sin(29278) + Math.cos(29279) * 81;
+acc += Math.sin(29279) + Math.cos(29280) * 82;
+acc += Math.sin(29280) + Math.cos(29281) * 83;
+acc += Math.sin(29281) + Math.cos(29282) * 84;
+acc += Math.sin(29282) + Math.cos(29283) * 85;
+acc += Math.sin(29283) + Math.cos(29284) * 86;
+acc += Math.sin(29284) + Math.cos(29285) * 87;
+acc += Math.sin(29285) + Math.cos(29286) * 88;
+acc += Math.sin(29286) + Math.cos(29287) * 89;
+acc += Math.sin(29287) + Math.cos(29288) * 90;
+acc += Math.sin(29288) + Math.cos(29289) * 91;
+acc += Math.sin(29289) + Math.cos(29290) * 92;
+acc += Math.sin(29290) + Math.cos(29291) * 93;
+acc += Math.sin(29291) + Math.cos(29292) * 94;
+acc += Math.sin(29292) + Math.cos(29293) * 95;
+acc += Math.sin(29293) + Math.cos(29294) * 96;
+acc += Math.sin(29294) + Math.cos(29295) * 0;
+acc += Math.sin(29295) + Math.cos(29296) * 1;
+acc += Math.sin(29296) + Math.cos(29297) * 2;
+acc += Math.sin(29297) + Math.cos(29298) * 3;
+acc += Math.sin(29298) + Math.cos(29299) * 4;
+acc += Math.sin(29299) + Math.cos(29300) * 5;
+acc += Math.sin(29300) + Math.cos(29301) * 6;
+acc += Math.sin(29301) + Math.cos(29302) * 7;
+acc += Math.sin(29302) + Math.cos(29303) * 8;
+acc += Math.sin(29303) + Math.cos(29304) * 9;
+acc += Math.sin(29304) + Math.cos(29305) * 10;
+acc += Math.sin(29305) + Math.cos(29306) * 11;
+acc += Math.sin(29306) + Math.cos(29307) * 12;
+acc += Math.sin(29307) + Math.cos(29308) * 13;
+acc += Math.sin(29308) + Math.cos(29309) * 14;
+acc += Math.sin(29309) + Math.cos(29310) * 15;
+acc += Math.sin(29310) + Math.cos(29311) * 16;
+acc += Math.sin(29311) + Math.cos(29312) * 17;
+acc += Math.sin(29312) + Math.cos(29313) * 18;
+acc += Math.sin(29313) + Math.cos(29314) * 19;
+acc += Math.sin(29314) + Math.cos(29315) * 20;
+acc += Math.sin(29315) + Math.cos(29316) * 21;
+acc += Math.sin(29316) + Math.cos(29317) * 22;
+acc += Math.sin(29317) + Math.cos(29318) * 23;
+acc += Math.sin(29318) + Math.cos(29319) * 24;
+acc += Math.sin(29319) + Math.cos(29320) * 25;
+acc += Math.sin(29320) + Math.cos(29321) * 26;
+acc += Math.sin(29321) + Math.cos(29322) * 27;
+acc += Math.sin(29322) + Math.cos(29323) * 28;
+acc += Math.sin(29323) + Math.cos(29324) * 29;
+acc += Math.sin(29324) + Math.cos(29325) * 30;
+acc += Math.sin(29325) + Math.cos(29326) * 31;
+acc += Math.sin(29326) + Math.cos(29327) * 32;
+acc += Math.sin(29327) + Math.cos(29328) * 33;
+acc += Math.sin(29328) + Math.cos(29329) * 34;
+acc += Math.sin(29329) + Math.cos(29330) * 35;
+acc += Math.sin(29330) + Math.cos(29331) * 36;
+acc += Math.sin(29331) + Math.cos(29332) * 37;
+acc += Math.sin(29332) + Math.cos(29333) * 38;
+acc += Math.sin(29333) + Math.cos(29334) * 39;
+acc += Math.sin(29334) + Math.cos(29335) * 40;
+acc += Math.sin(29335) + Math.cos(29336) * 41;
+acc += Math.sin(29336) + Math.cos(29337) * 42;
+acc += Math.sin(29337) + Math.cos(29338) * 43;
+acc += Math.sin(29338) + Math.cos(29339) * 44;
+acc += Math.sin(29339) + Math.cos(29340) * 45;
+acc += Math.sin(29340) + Math.cos(29341) * 46;
+acc += Math.sin(29341) + Math.cos(29342) * 47;
+acc += Math.sin(29342) + Math.cos(29343) * 48;
+acc += Math.sin(29343) + Math.cos(29344) * 49;
+acc += Math.sin(29344) + Math.cos(29345) * 50;
+acc += Math.sin(29345) + Math.cos(29346) * 51;
+acc += Math.sin(29346) + Math.cos(29347) * 52;
+acc += Math.sin(29347) + Math.cos(29348) * 53;
+acc += Math.sin(29348) + Math.cos(29349) * 54;
+acc += Math.sin(29349) + Math.cos(29350) * 55;
+acc += Math.sin(29350) + Math.cos(29351) * 56;
+acc += Math.sin(29351) + Math.cos(29352) * 57;
+acc += Math.sin(29352) + Math.cos(29353) * 58;
+acc += Math.sin(29353) + Math.cos(29354) * 59;
+acc += Math.sin(29354) + Math.cos(29355) * 60;
+acc += Math.sin(29355) + Math.cos(29356) * 61;
+acc += Math.sin(29356) + Math.cos(29357) * 62;
+acc += Math.sin(29357) + Math.cos(29358) * 63;
+acc += Math.sin(29358) + Math.cos(29359) * 64;
+acc += Math.sin(29359) + Math.cos(29360) * 65;
+acc += Math.sin(29360) + Math.cos(29361) * 66;
+acc += Math.sin(29361) + Math.cos(29362) * 67;
+acc += Math.sin(29362) + Math.cos(29363) * 68;
+acc += Math.sin(29363) + Math.cos(29364) * 69;
+acc += Math.sin(29364) + Math.cos(29365) * 70;
+acc += Math.sin(29365) + Math.cos(29366) * 71;
+acc += Math.sin(29366) + Math.cos(29367) * 72;
+acc += Math.sin(29367) + Math.cos(29368) * 73;
+acc += Math.sin(29368) + Math.cos(29369) * 74;
+acc += Math.sin(29369) + Math.cos(29370) * 75;
+acc += Math.sin(29370) + Math.cos(29371) * 76;
+acc += Math.sin(29371) + Math.cos(29372) * 77;
+acc += Math.sin(29372) + Math.cos(29373) * 78;
+acc += Math.sin(29373) + Math.cos(29374) * 79;
+acc += Math.sin(29374) + Math.cos(29375) * 80;
+acc += Math.sin(29375) + Math.cos(29376) * 81;
+acc += Math.sin(29376) + Math.cos(29377) * 82;
+acc += Math.sin(29377) + Math.cos(29378) * 83;
+acc += Math.sin(29378) + Math.cos(29379) * 84;
+acc += Math.sin(29379) + Math.cos(29380) * 85;
+acc += Math.sin(29380) + Math.cos(29381) * 86;
+acc += Math.sin(29381) + Math.cos(29382) * 87;
+acc += Math.sin(29382) + Math.cos(29383) * 88;
+acc += Math.sin(29383) + Math.cos(29384) * 89;
+acc += Math.sin(29384) + Math.cos(29385) * 90;
+acc += Math.sin(29385) + Math.cos(29386) * 91;
+acc += Math.sin(29386) + Math.cos(29387) * 92;
+acc += Math.sin(29387) + Math.cos(29388) * 93;
+acc += Math.sin(29388) + Math.cos(29389) * 94;
+acc += Math.sin(29389) + Math.cos(29390) * 95;
+acc += Math.sin(29390) + Math.cos(29391) * 96;
+acc += Math.sin(29391) + Math.cos(29392) * 0;
+acc += Math.sin(29392) + Math.cos(29393) * 1;
+acc += Math.sin(29393) + Math.cos(29394) * 2;
+acc += Math.sin(29394) + Math.cos(29395) * 3;
+acc += Math.sin(29395) + Math.cos(29396) * 4;
+acc += Math.sin(29396) + Math.cos(29397) * 5;
+acc += Math.sin(29397) + Math.cos(29398) * 6;
+acc += Math.sin(29398) + Math.cos(29399) * 7;
+acc += Math.sin(29399) + Math.cos(29400) * 8;
+acc += Math.sin(29400) + Math.cos(29401) * 9;
+acc += Math.sin(29401) + Math.cos(29402) * 10;
+acc += Math.sin(29402) + Math.cos(29403) * 11;
+acc += Math.sin(29403) + Math.cos(29404) * 12;
+acc += Math.sin(29404) + Math.cos(29405) * 13;
+acc += Math.sin(29405) + Math.cos(29406) * 14;
+acc += Math.sin(29406) + Math.cos(29407) * 15;
+acc += Math.sin(29407) + Math.cos(29408) * 16;
+acc += Math.sin(29408) + Math.cos(29409) * 17;
+acc += Math.sin(29409) + Math.cos(29410) * 18;
+acc += Math.sin(29410) + Math.cos(29411) * 19;
+acc += Math.sin(29411) + Math.cos(29412) * 20;
+acc += Math.sin(29412) + Math.cos(29413) * 21;
+acc += Math.sin(29413) + Math.cos(29414) * 22;
+acc += Math.sin(29414) + Math.cos(29415) * 23;
+acc += Math.sin(29415) + Math.cos(29416) * 24;
+acc += Math.sin(29416) + Math.cos(29417) * 25;
+acc += Math.sin(29417) + Math.cos(29418) * 26;
+acc += Math.sin(29418) + Math.cos(29419) * 27;
+acc += Math.sin(29419) + Math.cos(29420) * 28;
+acc += Math.sin(29420) + Math.cos(29421) * 29;
+acc += Math.sin(29421) + Math.cos(29422) * 30;
+acc += Math.sin(29422) + Math.cos(29423) * 31;
+acc += Math.sin(29423) + Math.cos(29424) * 32;
+acc += Math.sin(29424) + Math.cos(29425) * 33;
+acc += Math.sin(29425) + Math.cos(29426) * 34;
+acc += Math.sin(29426) + Math.cos(29427) * 35;
+acc += Math.sin(29427) + Math.cos(29428) * 36;
+acc += Math.sin(29428) + Math.cos(29429) * 37;
+acc += Math.sin(29429) + Math.cos(29430) * 38;
+acc += Math.sin(29430) + Math.cos(29431) * 39;
+acc += Math.sin(29431) + Math.cos(29432) * 40;
+acc += Math.sin(29432) + Math.cos(29433) * 41;
+acc += Math.sin(29433) + Math.cos(29434) * 42;
+acc += Math.sin(29434) + Math.cos(29435) * 43;
+acc += Math.sin(29435) + Math.cos(29436) * 44;
+acc += Math.sin(29436) + Math.cos(29437) * 45;
+acc += Math.sin(29437) + Math.cos(29438) * 46;
+acc += Math.sin(29438) + Math.cos(29439) * 47;
+acc += Math.sin(29439) + Math.cos(29440) * 48;
+acc += Math.sin(29440) + Math.cos(29441) * 49;
+acc += Math.sin(29441) + Math.cos(29442) * 50;
+acc += Math.sin(29442) + Math.cos(29443) * 51;
+acc += Math.sin(29443) + Math.cos(29444) * 52;
+acc += Math.sin(29444) + Math.cos(29445) * 53;
+acc += Math.sin(29445) + Math.cos(29446) * 54;
+acc += Math.sin(29446) + Math.cos(29447) * 55;
+acc += Math.sin(29447) + Math.cos(29448) * 56;
+acc += Math.sin(29448) + Math.cos(29449) * 57;
+acc += Math.sin(29449) + Math.cos(29450) * 58;
+acc += Math.sin(29450) + Math.cos(29451) * 59;
+acc += Math.sin(29451) + Math.cos(29452) * 60;
+acc += Math.sin(29452) + Math.cos(29453) * 61;
+acc += Math.sin(29453) + Math.cos(29454) * 62;
+acc += Math.sin(29454) + Math.cos(29455) * 63;
+acc += Math.sin(29455) + Math.cos(29456) * 64;
+acc += Math.sin(29456) + Math.cos(29457) * 65;
+acc += Math.sin(29457) + Math.cos(29458) * 66;
+acc += Math.sin(29458) + Math.cos(29459) * 67;
+acc += Math.sin(29459) + Math.cos(29460) * 68;
+acc += Math.sin(29460) + Math.cos(29461) * 69;
+acc += Math.sin(29461) + Math.cos(29462) * 70;
+acc += Math.sin(29462) + Math.cos(29463) * 71;
+acc += Math.sin(29463) + Math.cos(29464) * 72;
+acc += Math.sin(29464) + Math.cos(29465) * 73;
+acc += Math.sin(29465) + Math.cos(29466) * 74;
+acc += Math.sin(29466) + Math.cos(29467) * 75;
+acc += Math.sin(29467) + Math.cos(29468) * 76;
+acc += Math.sin(29468) + Math.cos(29469) * 77;
+acc += Math.sin(29469) + Math.cos(29470) * 78;
+acc += Math.sin(29470) + Math.cos(29471) * 79;
+acc += Math.sin(29471) + Math.cos(29472) * 80;
+acc += Math.sin(29472) + Math.cos(29473) * 81;
+acc += Math.sin(29473) + Math.cos(29474) * 82;
+acc += Math.sin(29474) + Math.cos(29475) * 83;
+acc += Math.sin(29475) + Math.cos(29476) * 84;
+acc += Math.sin(29476) + Math.cos(29477) * 85;
+acc += Math.sin(29477) + Math.cos(29478) * 86;
+acc += Math.sin(29478) + Math.cos(29479) * 87;
+acc += Math.sin(29479) + Math.cos(29480) * 88;
+acc += Math.sin(29480) + Math.cos(29481) * 89;
+acc += Math.sin(29481) + Math.cos(29482) * 90;
+acc += Math.sin(29482) + Math.cos(29483) * 91;
+acc += Math.sin(29483) + Math.cos(29484) * 92;
+acc += Math.sin(29484) + Math.cos(29485) * 93;
+acc += Math.sin(29485) + Math.cos(29486) * 94;
+acc += Math.sin(29486) + Math.cos(29487) * 95;
+acc += Math.sin(29487) + Math.cos(29488) * 96;
+acc += Math.sin(29488) + Math.cos(29489) * 0;
+acc += Math.sin(29489) + Math.cos(29490) * 1;
+acc += Math.sin(29490) + Math.cos(29491) * 2;
+acc += Math.sin(29491) + Math.cos(29492) * 3;
+acc += Math.sin(29492) + Math.cos(29493) * 4;
+acc += Math.sin(29493) + Math.cos(29494) * 5;
+acc += Math.sin(29494) + Math.cos(29495) * 6;
+acc += Math.sin(29495) + Math.cos(29496) * 7;
+acc += Math.sin(29496) + Math.cos(29497) * 8;
+acc += Math.sin(29497) + Math.cos(29498) * 9;
+acc += Math.sin(29498) + Math.cos(29499) * 10;
+acc += Math.sin(29499) + Math.cos(29500) * 11;
+acc += Math.sin(29500) + Math.cos(29501) * 12;
+acc += Math.sin(29501) + Math.cos(29502) * 13;
+acc += Math.sin(29502) + Math.cos(29503) * 14;
+acc += Math.sin(29503) + Math.cos(29504) * 15;
+acc += Math.sin(29504) + Math.cos(29505) * 16;
+acc += Math.sin(29505) + Math.cos(29506) * 17;
+acc += Math.sin(29506) + Math.cos(29507) * 18;
+acc += Math.sin(29507) + Math.cos(29508) * 19;
+acc += Math.sin(29508) + Math.cos(29509) * 20;
+acc += Math.sin(29509) + Math.cos(29510) * 21;
+acc += Math.sin(29510) + Math.cos(29511) * 22;
+acc += Math.sin(29511) + Math.cos(29512) * 23;
+acc += Math.sin(29512) + Math.cos(29513) * 24;
+acc += Math.sin(29513) + Math.cos(29514) * 25;
+acc += Math.sin(29514) + Math.cos(29515) * 26;
+acc += Math.sin(29515) + Math.cos(29516) * 27;
+acc += Math.sin(29516) + Math.cos(29517) * 28;
+acc += Math.sin(29517) + Math.cos(29518) * 29;
+acc += Math.sin(29518) + Math.cos(29519) * 30;
+acc += Math.sin(29519) + Math.cos(29520) * 31;
+acc += Math.sin(29520) + Math.cos(29521) * 32;
+acc += Math.sin(29521) + Math.cos(29522) * 33;
+acc += Math.sin(29522) + Math.cos(29523) * 34;
+acc += Math.sin(29523) + Math.cos(29524) * 35;
+acc += Math.sin(29524) + Math.cos(29525) * 36;
+acc += Math.sin(29525) + Math.cos(29526) * 37;
+acc += Math.sin(29526) + Math.cos(29527) * 38;
+acc += Math.sin(29527) + Math.cos(29528) * 39;
+acc += Math.sin(29528) + Math.cos(29529) * 40;
+acc += Math.sin(29529) + Math.cos(29530) * 41;
+acc += Math.sin(29530) + Math.cos(29531) * 42;
+acc += Math.sin(29531) + Math.cos(29532) * 43;
+acc += Math.sin(29532) + Math.cos(29533) * 44;
+acc += Math.sin(29533) + Math.cos(29534) * 45;
+acc += Math.sin(29534) + Math.cos(29535) * 46;
+acc += Math.sin(29535) + Math.cos(29536) * 47;
+acc += Math.sin(29536) + Math.cos(29537) * 48;
+acc += Math.sin(29537) + Math.cos(29538) * 49;
+acc += Math.sin(29538) + Math.cos(29539) * 50;
+acc += Math.sin(29539) + Math.cos(29540) * 51;
+acc += Math.sin(29540) + Math.cos(29541) * 52;
+acc += Math.sin(29541) + Math.cos(29542) * 53;
+acc += Math.sin(29542) + Math.cos(29543) * 54;
+acc += Math.sin(29543) + Math.cos(29544) * 55;
+acc += Math.sin(29544) + Math.cos(29545) * 56;
+acc += Math.sin(29545) + Math.cos(29546) * 57;
+acc += Math.sin(29546) + Math.cos(29547) * 58;
+acc += Math.sin(29547) + Math.cos(29548) * 59;
+acc += Math.sin(29548) + Math.cos(29549) * 60;
+acc += Math.sin(29549) + Math.cos(29550) * 61;
+acc += Math.sin(29550) + Math.cos(29551) * 62;
+acc += Math.sin(29551) + Math.cos(29552) * 63;
+acc += Math.sin(29552) + Math.cos(29553) * 64;
+acc += Math.sin(29553) + Math.cos(29554) * 65;
+acc += Math.sin(29554) + Math.cos(29555) * 66;
+acc += Math.sin(29555) + Math.cos(29556) * 67;
+acc += Math.sin(29556) + Math.cos(29557) * 68;
+acc += Math.sin(29557) + Math.cos(29558) * 69;
+acc += Math.sin(29558) + Math.cos(29559) * 70;
+acc += Math.sin(29559) + Math.cos(29560) * 71;
+acc += Math.sin(29560) + Math.cos(29561) * 72;
+acc += Math.sin(29561) + Math.cos(29562) * 73;
+acc += Math.sin(29562) + Math.cos(29563) * 74;
+acc += Math.sin(29563) + Math.cos(29564) * 75;
+acc += Math.sin(29564) + Math.cos(29565) * 76;
+acc += Math.sin(29565) + Math.cos(29566) * 77;
+acc += Math.sin(29566) + Math.cos(29567) * 78;
+acc += Math.sin(29567) + Math.cos(29568) * 79;
+acc += Math.sin(29568) + Math.cos(29569) * 80;
+acc += Math.sin(29569) + Math.cos(29570) * 81;
+acc += Math.sin(29570) + Math.cos(29571) * 82;
+acc += Math.sin(29571) + Math.cos(29572) * 83;
+acc += Math.sin(29572) + Math.cos(29573) * 84;
+acc += Math.sin(29573) + Math.cos(29574) * 85;
+acc += Math.sin(29574) + Math.cos(29575) * 86;
+acc += Math.sin(29575) + Math.cos(29576) * 87;
+acc += Math.sin(29576) + Math.cos(29577) * 88;
+acc += Math.sin(29577) + Math.cos(29578) * 89;
+acc += Math.sin(29578) + Math.cos(29579) * 90;
+acc += Math.sin(29579) + Math.cos(29580) * 91;
+acc += Math.sin(29580) + Math.cos(29581) * 92;
+acc += Math.sin(29581) + Math.cos(29582) * 93;
+acc += Math.sin(29582) + Math.cos(29583) * 94;
+acc += Math.sin(29583) + Math.cos(29584) * 95;
+acc += Math.sin(29584) + Math.cos(29585) * 96;
+acc += Math.sin(29585) + Math.cos(29586) * 0;
+acc += Math.sin(29586) + Math.cos(29587) * 1;
+acc += Math.sin(29587) + Math.cos(29588) * 2;
+acc += Math.sin(29588) + Math.cos(29589) * 3;
+acc += Math.sin(29589) + Math.cos(29590) * 4;
+acc += Math.sin(29590) + Math.cos(29591) * 5;
+acc += Math.sin(29591) + Math.cos(29592) * 6;
+acc += Math.sin(29592) + Math.cos(29593) * 7;
+acc += Math.sin(29593) + Math.cos(29594) * 8;
+acc += Math.sin(29594) + Math.cos(29595) * 9;
+acc += Math.sin(29595) + Math.cos(29596) * 10;
+acc += Math.sin(29596) + Math.cos(29597) * 11;
+acc += Math.sin(29597) + Math.cos(29598) * 12;
+acc += Math.sin(29598) + Math.cos(29599) * 13;
+acc += Math.sin(29599) + Math.cos(29600) * 14;
+acc += Math.sin(29600) + Math.cos(29601) * 15;
+acc += Math.sin(29601) + Math.cos(29602) * 16;
+acc += Math.sin(29602) + Math.cos(29603) * 17;
+acc += Math.sin(29603) + Math.cos(29604) * 18;
+acc += Math.sin(29604) + Math.cos(29605) * 19;
+acc += Math.sin(29605) + Math.cos(29606) * 20;
+acc += Math.sin(29606) + Math.cos(29607) * 21;
+acc += Math.sin(29607) + Math.cos(29608) * 22;
+acc += Math.sin(29608) + Math.cos(29609) * 23;
+acc += Math.sin(29609) + Math.cos(29610) * 24;
+acc += Math.sin(29610) + Math.cos(29611) * 25;
+acc += Math.sin(29611) + Math.cos(29612) * 26;
+acc += Math.sin(29612) + Math.cos(29613) * 27;
+acc += Math.sin(29613) + Math.cos(29614) * 28;
+acc += Math.sin(29614) + Math.cos(29615) * 29;
+acc += Math.sin(29615) + Math.cos(29616) * 30;
+acc += Math.sin(29616) + Math.cos(29617) * 31;
+acc += Math.sin(29617) + Math.cos(29618) * 32;
+acc += Math.sin(29618) + Math.cos(29619) * 33;
+acc += Math.sin(29619) + Math.cos(29620) * 34;
+acc += Math.sin(29620) + Math.cos(29621) * 35;
+acc += Math.sin(29621) + Math.cos(29622) * 36;
+acc += Math.sin(29622) + Math.cos(29623) * 37;
+acc += Math.sin(29623) + Math.cos(29624) * 38;
+acc += Math.sin(29624) + Math.cos(29625) * 39;
+acc += Math.sin(29625) + Math.cos(29626) * 40;
+acc += Math.sin(29626) + Math.cos(29627) * 41;
+acc += Math.sin(29627) + Math.cos(29628) * 42;
+acc += Math.sin(29628) + Math.cos(29629) * 43;
+acc += Math.sin(29629) + Math.cos(29630) * 44;
+acc += Math.sin(29630) + Math.cos(29631) * 45;
+acc += Math.sin(29631) + Math.cos(29632) * 46;
+acc += Math.sin(29632) + Math.cos(29633) * 47;
+acc += Math.sin(29633) + Math.cos(29634) * 48;
+acc += Math.sin(29634) + Math.cos(29635) * 49;
+acc += Math.sin(29635) + Math.cos(29636) * 50;
+acc += Math.sin(29636) + Math.cos(29637) * 51;
+acc += Math.sin(29637) + Math.cos(29638) * 52;
+acc += Math.sin(29638) + Math.cos(29639) * 53;
+acc += Math.sin(29639) + Math.cos(29640) * 54;
+acc += Math.sin(29640) + Math.cos(29641) * 55;
+acc += Math.sin(29641) + Math.cos(29642) * 56;
+acc += Math.sin(29642) + Math.cos(29643) * 57;
+acc += Math.sin(29643) + Math.cos(29644) * 58;
+acc += Math.sin(29644) + Math.cos(29645) * 59;
+acc += Math.sin(29645) + Math.cos(29646) * 60;
+acc += Math.sin(29646) + Math.cos(29647) * 61;
+acc += Math.sin(29647) + Math.cos(29648) * 62;
+acc += Math.sin(29648) + Math.cos(29649) * 63;
+acc += Math.sin(29649) + Math.cos(29650) * 64;
+acc += Math.sin(29650) + Math.cos(29651) * 65;
+acc += Math.sin(29651) + Math.cos(29652) * 66;
+acc += Math.sin(29652) + Math.cos(29653) * 67;
+acc += Math.sin(29653) + Math.cos(29654) * 68;
+acc += Math.sin(29654) + Math.cos(29655) * 69;
+acc += Math.sin(29655) + Math.cos(29656) * 70;
+acc += Math.sin(29656) + Math.cos(29657) * 71;
+acc += Math.sin(29657) + Math.cos(29658) * 72;
+acc += Math.sin(29658) + Math.cos(29659) * 73;
+acc += Math.sin(29659) + Math.cos(29660) * 74;
+acc += Math.sin(29660) + Math.cos(29661) * 75;
+acc += Math.sin(29661) + Math.cos(29662) * 76;
+acc += Math.sin(29662) + Math.cos(29663) * 77;
+acc += Math.sin(29663) + Math.cos(29664) * 78;
+acc += Math.sin(29664) + Math.cos(29665) * 79;
+acc += Math.sin(29665) + Math.cos(29666) * 80;
+acc += Math.sin(29666) + Math.cos(29667) * 81;
+acc += Math.sin(29667) + Math.cos(29668) * 82;
+acc += Math.sin(29668) + Math.cos(29669) * 83;
+acc += Math.sin(29669) + Math.cos(29670) * 84;
+acc += Math.sin(29670) + Math.cos(29671) * 85;
+acc += Math.sin(29671) + Math.cos(29672) * 86;
+acc += Math.sin(29672) + Math.cos(29673) * 87;
+acc += Math.sin(29673) + Math.cos(29674) * 88;
+acc += Math.sin(29674) + Math.cos(29675) * 89;
+acc += Math.sin(29675) + Math.cos(29676) * 90;
+acc += Math.sin(29676) + Math.cos(29677) * 91;
+acc += Math.sin(29677) + Math.cos(29678) * 92;
+acc += Math.sin(29678) + Math.cos(29679) * 93;
+acc += Math.sin(29679) + Math.cos(29680) * 94;
+acc += Math.sin(29680) + Math.cos(29681) * 95;
+acc += Math.sin(29681) + Math.cos(29682) * 96;
+acc += Math.sin(29682) + Math.cos(29683) * 0;
+acc += Math.sin(29683) + Math.cos(29684) * 1;
+acc += Math.sin(29684) + Math.cos(29685) * 2;
+acc += Math.sin(29685) + Math.cos(29686) * 3;
+acc += Math.sin(29686) + Math.cos(29687) * 4;
+acc += Math.sin(29687) + Math.cos(29688) * 5;
+acc += Math.sin(29688) + Math.cos(29689) * 6;
+acc += Math.sin(29689) + Math.cos(29690) * 7;
+acc += Math.sin(29690) + Math.cos(29691) * 8;
+acc += Math.sin(29691) + Math.cos(29692) * 9;
+acc += Math.sin(29692) + Math.cos(29693) * 10;
+acc += Math.sin(29693) + Math.cos(29694) * 11;
+acc += Math.sin(29694) + Math.cos(29695) * 12;
+acc += Math.sin(29695) + Math.cos(29696) * 13;
+acc += Math.sin(29696) + Math.cos(29697) * 14;
+acc += Math.sin(29697) + Math.cos(29698) * 15;
+acc += Math.sin(29698) + Math.cos(29699) * 16;
+acc += Math.sin(29699) + Math.cos(29700) * 17;
+acc += Math.sin(29700) + Math.cos(29701) * 18;
+acc += Math.sin(29701) + Math.cos(29702) * 19;
+acc += Math.sin(29702) + Math.cos(29703) * 20;
+acc += Math.sin(29703) + Math.cos(29704) * 21;
+acc += Math.sin(29704) + Math.cos(29705) * 22;
+acc += Math.sin(29705) + Math.cos(29706) * 23;
+acc += Math.sin(29706) + Math.cos(29707) * 24;
+acc += Math.sin(29707) + Math.cos(29708) * 25;
+acc += Math.sin(29708) + Math.cos(29709) * 26;
+acc += Math.sin(29709) + Math.cos(29710) * 27;
+acc += Math.sin(29710) + Math.cos(29711) * 28;
+acc += Math.sin(29711) + Math.cos(29712) * 29;
+acc += Math.sin(29712) + Math.cos(29713) * 30;
+acc += Math.sin(29713) + Math.cos(29714) * 31;
+acc += Math.sin(29714) + Math.cos(29715) * 32;
+acc += Math.sin(29715) + Math.cos(29716) * 33;
+acc += Math.sin(29716) + Math.cos(29717) * 34;
+acc += Math.sin(29717) + Math.cos(29718) * 35;
+acc += Math.sin(29718) + Math.cos(29719) * 36;
+acc += Math.sin(29719) + Math.cos(29720) * 37;
+acc += Math.sin(29720) + Math.cos(29721) * 38;
+acc += Math.sin(29721) + Math.cos(29722) * 39;
+acc += Math.sin(29722) + Math.cos(29723) * 40;
+acc += Math.sin(29723) + Math.cos(29724) * 41;
+acc += Math.sin(29724) + Math.cos(29725) * 42;
+acc += Math.sin(29725) + Math.cos(29726) * 43;
+acc += Math.sin(29726) + Math.cos(29727) * 44;
+acc += Math.sin(29727) + Math.cos(29728) * 45;
+acc += Math.sin(29728) + Math.cos(29729) * 46;
+acc += Math.sin(29729) + Math.cos(29730) * 47;
+acc += Math.sin(29730) + Math.cos(29731) * 48;
+acc += Math.sin(29731) + Math.cos(29732) * 49;
+acc += Math.sin(29732) + Math.cos(29733) * 50;
+acc += Math.sin(29733) + Math.cos(29734) * 51;
+acc += Math.sin(29734) + Math.cos(29735) * 52;
+acc += Math.sin(29735) + Math.cos(29736) * 53;
+acc += Math.sin(29736) + Math.cos(29737) * 54;
+acc += Math.sin(29737) + Math.cos(29738) * 55;
+acc += Math.sin(29738) + Math.cos(29739) * 56;
+acc += Math.sin(29739) + Math.cos(29740) * 57;
+acc += Math.sin(29740) + Math.cos(29741) * 58;
+acc += Math.sin(29741) + Math.cos(29742) * 59;
+acc += Math.sin(29742) + Math.cos(29743) * 60;
+acc += Math.sin(29743) + Math.cos(29744) * 61;
+acc += Math.sin(29744) + Math.cos(29745) * 62;
+acc += Math.sin(29745) + Math.cos(29746) * 63;
+acc += Math.sin(29746) + Math.cos(29747) * 64;
+acc += Math.sin(29747) + Math.cos(29748) * 65;
+acc += Math.sin(29748) + Math.cos(29749) * 66;
+acc += Math.sin(29749) + Math.cos(29750) * 67;
+acc += Math.sin(29750) + Math.cos(29751) * 68;
+acc += Math.sin(29751) + Math.cos(29752) * 69;
+acc += Math.sin(29752) + Math.cos(29753) * 70;
+acc += Math.sin(29753) + Math.cos(29754) * 71;
+acc += Math.sin(29754) + Math.cos(29755) * 72;
+acc += Math.sin(29755) + Math.cos(29756) * 73;
+acc += Math.sin(29756) + Math.cos(29757) * 74;
+acc += Math.sin(29757) + Math.cos(29758) * 75;
+acc += Math.sin(29758) + Math.cos(29759) * 76;
+acc += Math.sin(29759) + Math.cos(29760) * 77;
+acc += Math.sin(29760) + Math.cos(29761) * 78;
+acc += Math.sin(29761) + Math.cos(29762) * 79;
+acc += Math.sin(29762) + Math.cos(29763) * 80;
+acc += Math.sin(29763) + Math.cos(29764) * 81;
+acc += Math.sin(29764) + Math.cos(29765) * 82;
+acc += Math.sin(29765) + Math.cos(29766) * 83;
+acc += Math.sin(29766) + Math.cos(29767) * 84;
+acc += Math.sin(29767) + Math.cos(29768) * 85;
+acc += Math.sin(29768) + Math.cos(29769) * 86;
+acc += Math.sin(29769) + Math.cos(29770) * 87;
+acc += Math.sin(29770) + Math.cos(29771) * 88;
+acc += Math.sin(29771) + Math.cos(29772) * 89;
+acc += Math.sin(29772) + Math.cos(29773) * 90;
+acc += Math.sin(29773) + Math.cos(29774) * 91;
+acc += Math.sin(29774) + Math.cos(29775) * 92;
+acc += Math.sin(29775) + Math.cos(29776) * 93;
+acc += Math.sin(29776) + Math.cos(29777) * 94;
+acc += Math.sin(29777) + Math.cos(29778) * 95;
+acc += Math.sin(29778) + Math.cos(29779) * 96;
+acc += Math.sin(29779) + Math.cos(29780) * 0;
+acc += Math.sin(29780) + Math.cos(29781) * 1;
+acc += Math.sin(29781) + Math.cos(29782) * 2;
+acc += Math.sin(29782) + Math.cos(29783) * 3;
+acc += Math.sin(29783) + Math.cos(29784) * 4;
+acc += Math.sin(29784) + Math.cos(29785) * 5;
+acc += Math.sin(29785) + Math.cos(29786) * 6;
+acc += Math.sin(29786) + Math.cos(29787) * 7;
+acc += Math.sin(29787) + Math.cos(29788) * 8;
+acc += Math.sin(29788) + Math.cos(29789) * 9;
+acc += Math.sin(29789) + Math.cos(29790) * 10;
+acc += Math.sin(29790) + Math.cos(29791) * 11;
+acc += Math.sin(29791) + Math.cos(29792) * 12;
+acc += Math.sin(29792) + Math.cos(29793) * 13;
+acc += Math.sin(29793) + Math.cos(29794) * 14;
+acc += Math.sin(29794) + Math.cos(29795) * 15;
+acc += Math.sin(29795) + Math.cos(29796) * 16;
+acc += Math.sin(29796) + Math.cos(29797) * 17;
+acc += Math.sin(29797) + Math.cos(29798) * 18;
+acc += Math.sin(29798) + Math.cos(29799) * 19;
+acc += Math.sin(29799) + Math.cos(29800) * 20;
+acc += Math.sin(29800) + Math.cos(29801) * 21;
+acc += Math.sin(29801) + Math.cos(29802) * 22;
+acc += Math.sin(29802) + Math.cos(29803) * 23;
+acc += Math.sin(29803) + Math.cos(29804) * 24;
+acc += Math.sin(29804) + Math.cos(29805) * 25;
+acc += Math.sin(29805) + Math.cos(29806) * 26;
+acc += Math.sin(29806) + Math.cos(29807) * 27;
+acc += Math.sin(29807) + Math.cos(29808) * 28;
+acc += Math.sin(29808) + Math.cos(29809) * 29;
+acc += Math.sin(29809) + Math.cos(29810) * 30;
+acc += Math.sin(29810) + Math.cos(29811) * 31;
+acc += Math.sin(29811) + Math.cos(29812) * 32;
+acc += Math.sin(29812) + Math.cos(29813) * 33;
+acc += Math.sin(29813) + Math.cos(29814) * 34;
+acc += Math.sin(29814) + Math.cos(29815) * 35;
+acc += Math.sin(29815) + Math.cos(29816) * 36;
+acc += Math.sin(29816) + Math.cos(29817) * 37;
+acc += Math.sin(29817) + Math.cos(29818) * 38;
+acc += Math.sin(29818) + Math.cos(29819) * 39;
+acc += Math.sin(29819) + Math.cos(29820) * 40;
+acc += Math.sin(29820) + Math.cos(29821) * 41;
+acc += Math.sin(29821) + Math.cos(29822) * 42;
+acc += Math.sin(29822) + Math.cos(29823) * 43;
+acc += Math.sin(29823) + Math.cos(29824) * 44;
+acc += Math.sin(29824) + Math.cos(29825) * 45;
+acc += Math.sin(29825) + Math.cos(29826) * 46;
+acc += Math.sin(29826) + Math.cos(29827) * 47;
+acc += Math.sin(29827) + Math.cos(29828) * 48;
+acc += Math.sin(29828) + Math.cos(29829) * 49;
+acc += Math.sin(29829) + Math.cos(29830) * 50;
+acc += Math.sin(29830) + Math.cos(29831) * 51;
+acc += Math.sin(29831) + Math.cos(29832) * 52;
+acc += Math.sin(29832) + Math.cos(29833) * 53;
+acc += Math.sin(29833) + Math.cos(29834) * 54;
+acc += Math.sin(29834) + Math.cos(29835) * 55;
+acc += Math.sin(29835) + Math.cos(29836) * 56;
+acc += Math.sin(29836) + Math.cos(29837) * 57;
+acc += Math.sin(29837) + Math.cos(29838) * 58;
+acc += Math.sin(29838) + Math.cos(29839) * 59;
+acc += Math.sin(29839) + Math.cos(29840) * 60;
+acc += Math.sin(29840) + Math.cos(29841) * 61;
+acc += Math.sin(29841) + Math.cos(29842) * 62;
+acc += Math.sin(29842) + Math.cos(29843) * 63;
+acc += Math.sin(29843) + Math.cos(29844) * 64;
+acc += Math.sin(29844) + Math.cos(29845) * 65;
+acc += Math.sin(29845) + Math.cos(29846) * 66;
+acc += Math.sin(29846) + Math.cos(29847) * 67;
+acc += Math.sin(29847) + Math.cos(29848) * 68;
+acc += Math.sin(29848) + Math.cos(29849) * 69;
+acc += Math.sin(29849) + Math.cos(29850) * 70;
+acc += Math.sin(29850) + Math.cos(29851) * 71;
+acc += Math.sin(29851) + Math.cos(29852) * 72;
+acc += Math.sin(29852) + Math.cos(29853) * 73;
+acc += Math.sin(29853) + Math.cos(29854) * 74;
+acc += Math.sin(29854) + Math.cos(29855) * 75;
+acc += Math.sin(29855) + Math.cos(29856) * 76;
+acc += Math.sin(29856) + Math.cos(29857) * 77;
+acc += Math.sin(29857) + Math.cos(29858) * 78;
+acc += Math.sin(29858) + Math.cos(29859) * 79;
+acc += Math.sin(29859) + Math.cos(29860) * 80;
+acc += Math.sin(29860) + Math.cos(29861) * 81;
+acc += Math.sin(29861) + Math.cos(29862) * 82;
+acc += Math.sin(29862) + Math.cos(29863) * 83;
+acc += Math.sin(29863) + Math.cos(29864) * 84;
+acc += Math.sin(29864) + Math.cos(29865) * 85;
+acc += Math.sin(29865) + Math.cos(29866) * 86;
+acc += Math.sin(29866) + Math.cos(29867) * 87;
+acc += Math.sin(29867) + Math.cos(29868) * 88;
+acc += Math.sin(29868) + Math.cos(29869) * 89;
+acc += Math.sin(29869) + Math.cos(29870) * 90;
+acc += Math.sin(29870) + Math.cos(29871) * 91;
+acc += Math.sin(29871) + Math.cos(29872) * 92;
+acc += Math.sin(29872) + Math.cos(29873) * 93;
+acc += Math.sin(29873) + Math.cos(29874) * 94;
+acc += Math.sin(29874) + Math.cos(29875) * 95;
+acc += Math.sin(29875) + Math.cos(29876) * 96;
+acc += Math.sin(29876) + Math.cos(29877) * 0;
+acc += Math.sin(29877) + Math.cos(29878) * 1;
+acc += Math.sin(29878) + Math.cos(29879) * 2;
+acc += Math.sin(29879) + Math.cos(29880) * 3;
+acc += Math.sin(29880) + Math.cos(29881) * 4;
+acc += Math.sin(29881) + Math.cos(29882) * 5;
+acc += Math.sin(29882) + Math.cos(29883) * 6;
+acc += Math.sin(29883) + Math.cos(29884) * 7;
+acc += Math.sin(29884) + Math.cos(29885) * 8;
+acc += Math.sin(29885) + Math.cos(29886) * 9;
+acc += Math.sin(29886) + Math.cos(29887) * 10;
+acc += Math.sin(29887) + Math.cos(29888) * 11;
+acc += Math.sin(29888) + Math.cos(29889) * 12;
+acc += Math.sin(29889) + Math.cos(29890) * 13;
+acc += Math.sin(29890) + Math.cos(29891) * 14;
+acc += Math.sin(29891) + Math.cos(29892) * 15;
+acc += Math.sin(29892) + Math.cos(29893) * 16;
+acc += Math.sin(29893) + Math.cos(29894) * 17;
+acc += Math.sin(29894) + Math.cos(29895) * 18;
+acc += Math.sin(29895) + Math.cos(29896) * 19;
+acc += Math.sin(29896) + Math.cos(29897) * 20;
+acc += Math.sin(29897) + Math.cos(29898) * 21;
+acc += Math.sin(29898) + Math.cos(29899) * 22;
+acc += Math.sin(29899) + Math.cos(29900) * 23;
+acc += Math.sin(29900) + Math.cos(29901) * 24;
+acc += Math.sin(29901) + Math.cos(29902) * 25;
+acc += Math.sin(29902) + Math.cos(29903) * 26;
+acc += Math.sin(29903) + Math.cos(29904) * 27;
+acc += Math.sin(29904) + Math.cos(29905) * 28;
+acc += Math.sin(29905) + Math.cos(29906) * 29;
+acc += Math.sin(29906) + Math.cos(29907) * 30;
+acc += Math.sin(29907) + Math.cos(29908) * 31;
+acc += Math.sin(29908) + Math.cos(29909) * 32;
+acc += Math.sin(29909) + Math.cos(29910) * 33;
+acc += Math.sin(29910) + Math.cos(29911) * 34;
+acc += Math.sin(29911) + Math.cos(29912) * 35;
+acc += Math.sin(29912) + Math.cos(29913) * 36;
+acc += Math.sin(29913) + Math.cos(29914) * 37;
+acc += Math.sin(29914) + Math.cos(29915) * 38;
+acc += Math.sin(29915) + Math.cos(29916) * 39;
+acc += Math.sin(29916) + Math.cos(29917) * 40;
+acc += Math.sin(29917) + Math.cos(29918) * 41;
+acc += Math.sin(29918) + Math.cos(29919) * 42;
+acc += Math.sin(29919) + Math.cos(29920) * 43;
+acc += Math.sin(29920) + Math.cos(29921) * 44;
+acc += Math.sin(29921) + Math.cos(29922) * 45;
+acc += Math.sin(29922) + Math.cos(29923) * 46;
+acc += Math.sin(29923) + Math.cos(29924) * 47;
+acc += Math.sin(29924) + Math.cos(29925) * 48;
+acc += Math.sin(29925) + Math.cos(29926) * 49;
+acc += Math.sin(29926) + Math.cos(29927) * 50;
+acc += Math.sin(29927) + Math.cos(29928) * 51;
+acc += Math.sin(29928) + Math.cos(29929) * 52;
+acc += Math.sin(29929) + Math.cos(29930) * 53;
+acc += Math.sin(29930) + Math.cos(29931) * 54;
+acc += Math.sin(29931) + Math.cos(29932) * 55;
+acc += Math.sin(29932) + Math.cos(29933) * 56;
+acc += Math.sin(29933) + Math.cos(29934) * 57;
+acc += Math.sin(29934) + Math.cos(29935) * 58;
+acc += Math.sin(29935) + Math.cos(29936) * 59;
+acc += Math.sin(29936) + Math.cos(29937) * 60;
+acc += Math.sin(29937) + Math.cos(29938) * 61;
+acc += Math.sin(29938) + Math.cos(29939) * 62;
+acc += Math.sin(29939) + Math.cos(29940) * 63;
+acc += Math.sin(29940) + Math.cos(29941) * 64;
+acc += Math.sin(29941) + Math.cos(29942) * 65;
+acc += Math.sin(29942) + Math.cos(29943) * 66;
+acc += Math.sin(29943) + Math.cos(29944) * 67;
+acc += Math.sin(29944) + Math.cos(29945) * 68;
+acc += Math.sin(29945) + Math.cos(29946) * 69;
+acc += Math.sin(29946) + Math.cos(29947) * 70;
+acc += Math.sin(29947) + Math.cos(29948) * 71;
+acc += Math.sin(29948) + Math.cos(29949) * 72;
+acc += Math.sin(29949) + Math.cos(29950) * 73;
+acc += Math.sin(29950) + Math.cos(29951) * 74;
+acc += Math.sin(29951) + Math.cos(29952) * 75;
+acc += Math.sin(29952) + Math.cos(29953) * 76;
+acc += Math.sin(29953) + Math.cos(29954) * 77;
+acc += Math.sin(29954) + Math.cos(29955) * 78;
+acc += Math.sin(29955) + Math.cos(29956) * 79;
+acc += Math.sin(29956) + Math.cos(29957) * 80;
+acc += Math.sin(29957) + Math.cos(29958) * 81;
+acc += Math.sin(29958) + Math.cos(29959) * 82;
+acc += Math.sin(29959) + Math.cos(29960) * 83;
+acc += Math.sin(29960) + Math.cos(29961) * 84;
+acc += Math.sin(29961) + Math.cos(29962) * 85;
+acc += Math.sin(29962) + Math.cos(29963) * 86;
+acc += Math.sin(29963) + Math.cos(29964) * 87;
+acc += Math.sin(29964) + Math.cos(29965) * 88;
+acc += Math.sin(29965) + Math.cos(29966) * 89;
+acc += Math.sin(29966) + Math.cos(29967) * 90;
+acc += Math.sin(29967) + Math.cos(29968) * 91;
+acc += Math.sin(29968) + Math.cos(29969) * 92;
+acc += Math.sin(29969) + Math.cos(29970) * 93;
+acc += Math.sin(29970) + Math.cos(29971) * 94;
+acc += Math.sin(29971) + Math.cos(29972) * 95;
+acc += Math.sin(29972) + Math.cos(29973) * 96;
+acc += Math.sin(29973) + Math.cos(29974) * 0;
+acc += Math.sin(29974) + Math.cos(29975) * 1;
+acc += Math.sin(29975) + Math.cos(29976) * 2;
+acc += Math.sin(29976) + Math.cos(29977) * 3;
+acc += Math.sin(29977) + Math.cos(29978) * 4;
+acc += Math.sin(29978) + Math.cos(29979) * 5;
+acc += Math.sin(29979) + Math.cos(29980) * 6;
+acc += Math.sin(29980) + Math.cos(29981) * 7;
+acc += Math.sin(29981) + Math.cos(29982) * 8;
+acc += Math.sin(29982) + Math.cos(29983) * 9;
+acc += Math.sin(29983) + Math.cos(29984) * 10;
+acc += Math.sin(29984) + Math.cos(29985) * 11;
+acc += Math.sin(29985) + Math.cos(29986) * 12;
+acc += Math.sin(29986) + Math.cos(29987) * 13;
+acc += Math.sin(29987) + Math.cos(29988) * 14;
+acc += Math.sin(29988) + Math.cos(29989) * 15;
+acc += Math.sin(29989) + Math.cos(29990) * 16;
+acc += Math.sin(29990) + Math.cos(29991) * 17;
+acc += Math.sin(29991) + Math.cos(29992) * 18;
+acc += Math.sin(29992) + Math.cos(29993) * 19;
+acc += Math.sin(29993) + Math.cos(29994) * 20;
+acc += Math.sin(29994) + Math.cos(29995) * 21;
+acc += Math.sin(29995) + Math.cos(29996) * 22;
+acc += Math.sin(29996) + Math.cos(29997) * 23;
+acc += Math.sin(29997) + Math.cos(29998) * 24;
+acc += Math.sin(29998) + Math.cos(29999) * 25;
+acc += Math.sin(29999) + Math.cos(30000) * 26;
+acc += Math.sin(30000) + Math.cos(30001) * 27;
+acc += Math.sin(30001) + Math.cos(30002) * 28;
+acc += Math.sin(30002) + Math.cos(30003) * 29;
+acc += Math.sin(30003) + Math.cos(30004) * 30;
+acc += Math.sin(30004) + Math.cos(30005) * 31;
+acc += Math.sin(30005) + Math.cos(30006) * 32;
+acc += Math.sin(30006) + Math.cos(30007) * 33;
+acc += Math.sin(30007) + Math.cos(30008) * 34;
+acc += Math.sin(30008) + Math.cos(30009) * 35;
+acc += Math.sin(30009) + Math.cos(30010) * 36;
+acc += Math.sin(30010) + Math.cos(30011) * 37;
+acc += Math.sin(30011) + Math.cos(30012) * 38;
+acc += Math.sin(30012) + Math.cos(30013) * 39;
+acc += Math.sin(30013) + Math.cos(30014) * 40;
+acc += Math.sin(30014) + Math.cos(30015) * 41;
+acc += Math.sin(30015) + Math.cos(30016) * 42;
+acc += Math.sin(30016) + Math.cos(30017) * 43;
+acc += Math.sin(30017) + Math.cos(30018) * 44;
+acc += Math.sin(30018) + Math.cos(30019) * 45;
+acc += Math.sin(30019) + Math.cos(30020) * 46;
+acc += Math.sin(30020) + Math.cos(30021) * 47;
+acc += Math.sin(30021) + Math.cos(30022) * 48;
+acc += Math.sin(30022) + Math.cos(30023) * 49;
+acc += Math.sin(30023) + Math.cos(30024) * 50;
+acc += Math.sin(30024) + Math.cos(30025) * 51;
+acc += Math.sin(30025) + Math.cos(30026) * 52;
+acc += Math.sin(30026) + Math.cos(30027) * 53;
+acc += Math.sin(30027) + Math.cos(30028) * 54;
+acc += Math.sin(30028) + Math.cos(30029) * 55;
+acc += Math.sin(30029) + Math.cos(30030) * 56;
+acc += Math.sin(30030) + Math.cos(30031) * 57;
+acc += Math.sin(30031) + Math.cos(30032) * 58;
+acc += Math.sin(30032) + Math.cos(30033) * 59;
+acc += Math.sin(30033) + Math.cos(30034) * 60;
+acc += Math.sin(30034) + Math.cos(30035) * 61;
+acc += Math.sin(30035) + Math.cos(30036) * 62;
+acc += Math.sin(30036) + Math.cos(30037) * 63;
+acc += Math.sin(30037) + Math.cos(30038) * 64;
+acc += Math.sin(30038) + Math.cos(30039) * 65;
+acc += Math.sin(30039) + Math.cos(30040) * 66;
+acc += Math.sin(30040) + Math.cos(30041) * 67;
+acc += Math.sin(30041) + Math.cos(30042) * 68;
+acc += Math.sin(30042) + Math.cos(30043) * 69;
+acc += Math.sin(30043) + Math.cos(30044) * 70;
+acc += Math.sin(30044) + Math.cos(30045) * 71;
+acc += Math.sin(30045) + Math.cos(30046) * 72;
+acc += Math.sin(30046) + Math.cos(30047) * 73;
+acc += Math.sin(30047) + Math.cos(30048) * 74;
+acc += Math.sin(30048) + Math.cos(30049) * 75;
+acc += Math.sin(30049) + Math.cos(30050) * 76;
+acc += Math.sin(30050) + Math.cos(30051) * 77;
+acc += Math.sin(30051) + Math.cos(30052) * 78;
+acc += Math.sin(30052) + Math.cos(30053) * 79;
+acc += Math.sin(30053) + Math.cos(30054) * 80;
+acc += Math.sin(30054) + Math.cos(30055) * 81;
+acc += Math.sin(30055) + Math.cos(30056) * 82;
+acc += Math.sin(30056) + Math.cos(30057) * 83;
+acc += Math.sin(30057) + Math.cos(30058) * 84;
+acc += Math.sin(30058) + Math.cos(30059) * 85;
+acc += Math.sin(30059) + Math.cos(30060) * 86;
+acc += Math.sin(30060) + Math.cos(30061) * 87;
+acc += Math.sin(30061) + Math.cos(30062) * 88;
+acc += Math.sin(30062) + Math.cos(30063) * 89;
+acc += Math.sin(30063) + Math.cos(30064) * 90;
+acc += Math.sin(30064) + Math.cos(30065) * 91;
+acc += Math.sin(30065) + Math.cos(30066) * 92;
+acc += Math.sin(30066) + Math.cos(30067) * 93;
+acc += Math.sin(30067) + Math.cos(30068) * 94;
+acc += Math.sin(30068) + Math.cos(30069) * 95;
+acc += Math.sin(30069) + Math.cos(30070) * 96;
+acc += Math.sin(30070) + Math.cos(30071) * 0;
+acc += Math.sin(30071) + Math.cos(30072) * 1;
+acc += Math.sin(30072) + Math.cos(30073) * 2;
+acc += Math.sin(30073) + Math.cos(30074) * 3;
+acc += Math.sin(30074) + Math.cos(30075) * 4;
+acc += Math.sin(30075) + Math.cos(30076) * 5;
+acc += Math.sin(30076) + Math.cos(30077) * 6;
+acc += Math.sin(30077) + Math.cos(30078) * 7;
+acc += Math.sin(30078) + Math.cos(30079) * 8;
+acc += Math.sin(30079) + Math.cos(30080) * 9;
+acc += Math.sin(30080) + Math.cos(30081) * 10;
+acc += Math.sin(30081) + Math.cos(30082) * 11;
+acc += Math.sin(30082) + Math.cos(30083) * 12;
+acc += Math.sin(30083) + Math.cos(30084) * 13;
+acc += Math.sin(30084) + Math.cos(30085) * 14;
+acc += Math.sin(30085) + Math.cos(30086) * 15;
+acc += Math.sin(30086) + Math.cos(30087) * 16;
+acc += Math.sin(30087) + Math.cos(30088) * 17;
+acc += Math.sin(30088) + Math.cos(30089) * 18;
+acc += Math.sin(30089) + Math.cos(30090) * 19;
+acc += Math.sin(30090) + Math.cos(30091) * 20;
+acc += Math.sin(30091) + Math.cos(30092) * 21;
+acc += Math.sin(30092) + Math.cos(30093) * 22;
+acc += Math.sin(30093) + Math.cos(30094) * 23;
+acc += Math.sin(30094) + Math.cos(30095) * 24;
+acc += Math.sin(30095) + Math.cos(30096) * 25;
+acc += Math.sin(30096) + Math.cos(30097) * 26;
+acc += Math.sin(30097) + Math.cos(30098) * 27;
+acc += Math.sin(30098) + Math.cos(30099) * 28;
+acc += Math.sin(30099) + Math.cos(30100) * 29;
+acc += Math.sin(30100) + Math.cos(30101) * 30;
+acc += Math.sin(30101) + Math.cos(30102) * 31;
+acc += Math.sin(30102) + Math.cos(30103) * 32;
+acc += Math.sin(30103) + Math.cos(30104) * 33;
+acc += Math.sin(30104) + Math.cos(30105) * 34;
+acc += Math.sin(30105) + Math.cos(30106) * 35;
+acc += Math.sin(30106) + Math.cos(30107) * 36;
+acc += Math.sin(30107) + Math.cos(30108) * 37;
+acc += Math.sin(30108) + Math.cos(30109) * 38;
+acc += Math.sin(30109) + Math.cos(30110) * 39;
+acc += Math.sin(30110) + Math.cos(30111) * 40;
+acc += Math.sin(30111) + Math.cos(30112) * 41;
+acc += Math.sin(30112) + Math.cos(30113) * 42;
+acc += Math.sin(30113) + Math.cos(30114) * 43;
+acc += Math.sin(30114) + Math.cos(30115) * 44;
+acc += Math.sin(30115) + Math.cos(30116) * 45;
+acc += Math.sin(30116) + Math.cos(30117) * 46;
+acc += Math.sin(30117) + Math.cos(30118) * 47;
+acc += Math.sin(30118) + Math.cos(30119) * 48;
+acc += Math.sin(30119) + Math.cos(30120) * 49;
+acc += Math.sin(30120) + Math.cos(30121) * 50;
+acc += Math.sin(30121) + Math.cos(30122) * 51;
+acc += Math.sin(30122) + Math.cos(30123) * 52;
+acc += Math.sin(30123) + Math.cos(30124) * 53;
+acc += Math.sin(30124) + Math.cos(30125) * 54;
+acc += Math.sin(30125) + Math.cos(30126) * 55;
+acc += Math.sin(30126) + Math.cos(30127) * 56;
+acc += Math.sin(30127) + Math.cos(30128) * 57;
+acc += Math.sin(30128) + Math.cos(30129) * 58;
+acc += Math.sin(30129) + Math.cos(30130) * 59;
+acc += Math.sin(30130) + Math.cos(30131) * 60;
+acc += Math.sin(30131) + Math.cos(30132) * 61;
+acc += Math.sin(30132) + Math.cos(30133) * 62;
+acc += Math.sin(30133) + Math.cos(30134) * 63;
+acc += Math.sin(30134) + Math.cos(30135) * 64;
+acc += Math.sin(30135) + Math.cos(30136) * 65;
+acc += Math.sin(30136) + Math.cos(30137) * 66;
+acc += Math.sin(30137) + Math.cos(30138) * 67;
+acc += Math.sin(30138) + Math.cos(30139) * 68;
+acc += Math.sin(30139) + Math.cos(30140) * 69;
+acc += Math.sin(30140) + Math.cos(30141) * 70;
+acc += Math.sin(30141) + Math.cos(30142) * 71;
+acc += Math.sin(30142) + Math.cos(30143) * 72;
+acc += Math.sin(30143) + Math.cos(30144) * 73;
+acc += Math.sin(30144) + Math.cos(30145) * 74;
+acc += Math.sin(30145) + Math.cos(30146) * 75;
+acc += Math.sin(30146) + Math.cos(30147) * 76;
+acc += Math.sin(30147) + Math.cos(30148) * 77;
+acc += Math.sin(30148) + Math.cos(30149) * 78;
+acc += Math.sin(30149) + Math.cos(30150) * 79;
+acc += Math.sin(30150) + Math.cos(30151) * 80;
+acc += Math.sin(30151) + Math.cos(30152) * 81;
+acc += Math.sin(30152) + Math.cos(30153) * 82;
+acc += Math.sin(30153) + Math.cos(30154) * 83;
+acc += Math.sin(30154) + Math.cos(30155) * 84;
+acc += Math.sin(30155) + Math.cos(30156) * 85;
+acc += Math.sin(30156) + Math.cos(30157) * 86;
+acc += Math.sin(30157) + Math.cos(30158) * 87;
+acc += Math.sin(30158) + Math.cos(30159) * 88;
+acc += Math.sin(30159) + Math.cos(30160) * 89;
+acc += Math.sin(30160) + Math.cos(30161) * 90;
+acc += Math.sin(30161) + Math.cos(30162) * 91;
+acc += Math.sin(30162) + Math.cos(30163) * 92;
+acc += Math.sin(30163) + Math.cos(30164) * 93;
+acc += Math.sin(30164) + Math.cos(30165) * 94;
+acc += Math.sin(30165) + Math.cos(30166) * 95;
+acc += Math.sin(30166) + Math.cos(30167) * 96;
+acc += Math.sin(30167) + Math.cos(30168) * 0;
+acc += Math.sin(30168) + Math.cos(30169) * 1;
+acc += Math.sin(30169) + Math.cos(30170) * 2;
+acc += Math.sin(30170) + Math.cos(30171) * 3;
+acc += Math.sin(30171) + Math.cos(30172) * 4;
+acc += Math.sin(30172) + Math.cos(30173) * 5;
+acc += Math.sin(30173) + Math.cos(30174) * 6;
+acc += Math.sin(30174) + Math.cos(30175) * 7;
+acc += Math.sin(30175) + Math.cos(30176) * 8;
+acc += Math.sin(30176) + Math.cos(30177) * 9;
+acc += Math.sin(30177) + Math.cos(30178) * 10;
+acc += Math.sin(30178) + Math.cos(30179) * 11;
+acc += Math.sin(30179) + Math.cos(30180) * 12;
+acc += Math.sin(30180) + Math.cos(30181) * 13;
+acc += Math.sin(30181) + Math.cos(30182) * 14;
+acc += Math.sin(30182) + Math.cos(30183) * 15;
+acc += Math.sin(30183) + Math.cos(30184) * 16;
+acc += Math.sin(30184) + Math.cos(30185) * 17;
+acc += Math.sin(30185) + Math.cos(30186) * 18;
+acc += Math.sin(30186) + Math.cos(30187) * 19;
+acc += Math.sin(30187) + Math.cos(30188) * 20;
+acc += Math.sin(30188) + Math.cos(30189) * 21;
+acc += Math.sin(30189) + Math.cos(30190) * 22;
+acc += Math.sin(30190) + Math.cos(30191) * 23;
+acc += Math.sin(30191) + Math.cos(30192) * 24;
+acc += Math.sin(30192) + Math.cos(30193) * 25;
+acc += Math.sin(30193) + Math.cos(30194) * 26;
+acc += Math.sin(30194) + Math.cos(30195) * 27;
+acc += Math.sin(30195) + Math.cos(30196) * 28;
+acc += Math.sin(30196) + Math.cos(30197) * 29;
+acc += Math.sin(30197) + Math.cos(30198) * 30;
+acc += Math.sin(30198) + Math.cos(30199) * 31;
+acc += Math.sin(30199) + Math.cos(30200) * 32;
+acc += Math.sin(30200) + Math.cos(30201) * 33;
+acc += Math.sin(30201) + Math.cos(30202) * 34;
+acc += Math.sin(30202) + Math.cos(30203) * 35;
+acc += Math.sin(30203) + Math.cos(30204) * 36;
+acc += Math.sin(30204) + Math.cos(30205) * 37;
+acc += Math.sin(30205) + Math.cos(30206) * 38;
+acc += Math.sin(30206) + Math.cos(30207) * 39;
+acc += Math.sin(30207) + Math.cos(30208) * 40;
+acc += Math.sin(30208) + Math.cos(30209) * 41;
+acc += Math.sin(30209) + Math.cos(30210) * 42;
+acc += Math.sin(30210) + Math.cos(30211) * 43;
+acc += Math.sin(30211) + Math.cos(30212) * 44;
+acc += Math.sin(30212) + Math.cos(30213) * 45;
+acc += Math.sin(30213) + Math.cos(30214) * 46;
+acc += Math.sin(30214) + Math.cos(30215) * 47;
+acc += Math.sin(30215) + Math.cos(30216) * 48;
+acc += Math.sin(30216) + Math.cos(30217) * 49;
+acc += Math.sin(30217) + Math.cos(30218) * 50;
+acc += Math.sin(30218) + Math.cos(30219) * 51;
+acc += Math.sin(30219) + Math.cos(30220) * 52;
+acc += Math.sin(30220) + Math.cos(30221) * 53;
+acc += Math.sin(30221) + Math.cos(30222) * 54;
+acc += Math.sin(30222) + Math.cos(30223) * 55;
+acc += Math.sin(30223) + Math.cos(30224) * 56;
+acc += Math.sin(30224) + Math.cos(30225) * 57;
+acc += Math.sin(30225) + Math.cos(30226) * 58;
+acc += Math.sin(30226) + Math.cos(30227) * 59;
+acc += Math.sin(30227) + Math.cos(30228) * 60;
+acc += Math.sin(30228) + Math.cos(30229) * 61;
+acc += Math.sin(30229) + Math.cos(30230) * 62;
+acc += Math.sin(30230) + Math.cos(30231) * 63;
+acc += Math.sin(30231) + Math.cos(30232) * 64;
+acc += Math.sin(30232) + Math.cos(30233) * 65;
+acc += Math.sin(30233) + Math.cos(30234) * 66;
+acc += Math.sin(30234) + Math.cos(30235) * 67;
+acc += Math.sin(30235) + Math.cos(30236) * 68;
+acc += Math.sin(30236) + Math.cos(30237) * 69;
+acc += Math.sin(30237) + Math.cos(30238) * 70;
+acc += Math.sin(30238) + Math.cos(30239) * 71;
+acc += Math.sin(30239) + Math.cos(30240) * 72;
+acc += Math.sin(30240) + Math.cos(30241) * 73;
+acc += Math.sin(30241) + Math.cos(30242) * 74;
+acc += Math.sin(30242) + Math.cos(30243) * 75;
+acc += Math.sin(30243) + Math.cos(30244) * 76;
+acc += Math.sin(30244) + Math.cos(30245) * 77;
+acc += Math.sin(30245) + Math.cos(30246) * 78;
+acc += Math.sin(30246) + Math.cos(30247) * 79;
+acc += Math.sin(30247) + Math.cos(30248) * 80;
+acc += Math.sin(30248) + Math.cos(30249) * 81;
+acc += Math.sin(30249) + Math.cos(30250) * 82;
+acc += Math.sin(30250) + Math.cos(30251) * 83;
+acc += Math.sin(30251) + Math.cos(30252) * 84;
+acc += Math.sin(30252) + Math.cos(30253) * 85;
+acc += Math.sin(30253) + Math.cos(30254) * 86;
+acc += Math.sin(30254) + Math.cos(30255) * 87;
+acc += Math.sin(30255) + Math.cos(30256) * 88;
+acc += Math.sin(30256) + Math.cos(30257) * 89;
+acc += Math.sin(30257) + Math.cos(30258) * 90;
+acc += Math.sin(30258) + Math.cos(30259) * 91;
+acc += Math.sin(30259) + Math.cos(30260) * 92;
+acc += Math.sin(30260) + Math.cos(30261) * 93;
+acc += Math.sin(30261) + Math.cos(30262) * 94;
+acc += Math.sin(30262) + Math.cos(30263) * 95;
+acc += Math.sin(30263) + Math.cos(30264) * 96;
+acc += Math.sin(30264) + Math.cos(30265) * 0;
+acc += Math.sin(30265) + Math.cos(30266) * 1;
+acc += Math.sin(30266) + Math.cos(30267) * 2;
+acc += Math.sin(30267) + Math.cos(30268) * 3;
+acc += Math.sin(30268) + Math.cos(30269) * 4;
+acc += Math.sin(30269) + Math.cos(30270) * 5;
+acc += Math.sin(30270) + Math.cos(30271) * 6;
+acc += Math.sin(30271) + Math.cos(30272) * 7;
+acc += Math.sin(30272) + Math.cos(30273) * 8;
+acc += Math.sin(30273) + Math.cos(30274) * 9;
+acc += Math.sin(30274) + Math.cos(30275) * 10;
+acc += Math.sin(30275) + Math.cos(30276) * 11;
+acc += Math.sin(30276) + Math.cos(30277) * 12;
+acc += Math.sin(30277) + Math.cos(30278) * 13;
+acc += Math.sin(30278) + Math.cos(30279) * 14;
+acc += Math.sin(30279) + Math.cos(30280) * 15;
+acc += Math.sin(30280) + Math.cos(30281) * 16;
+acc += Math.sin(30281) + Math.cos(30282) * 17;
+acc += Math.sin(30282) + Math.cos(30283) * 18;
+acc += Math.sin(30283) + Math.cos(30284) * 19;
+acc += Math.sin(30284) + Math.cos(30285) * 20;
+acc += Math.sin(30285) + Math.cos(30286) * 21;
+acc += Math.sin(30286) + Math.cos(30287) * 22;
+acc += Math.sin(30287) + Math.cos(30288) * 23;
+acc += Math.sin(30288) + Math.cos(30289) * 24;
+acc += Math.sin(30289) + Math.cos(30290) * 25;
+acc += Math.sin(30290) + Math.cos(30291) * 26;
+acc += Math.sin(30291) + Math.cos(30292) * 27;
+acc += Math.sin(30292) + Math.cos(30293) * 28;
+acc += Math.sin(30293) + Math.cos(30294) * 29;
+acc += Math.sin(30294) + Math.cos(30295) * 30;
+acc += Math.sin(30295) + Math.cos(30296) * 31;
+acc += Math.sin(30296) + Math.cos(30297) * 32;
+acc += Math.sin(30297) + Math.cos(30298) * 33;
+acc += Math.sin(30298) + Math.cos(30299) * 34;
+acc += Math.sin(30299) + Math.cos(30300) * 35;
+acc += Math.sin(30300) + Math.cos(30301) * 36;
+acc += Math.sin(30301) + Math.cos(30302) * 37;
+acc += Math.sin(30302) + Math.cos(30303) * 38;
+acc += Math.sin(30303) + Math.cos(30304) * 39;
+acc += Math.sin(30304) + Math.cos(30305) * 40;
+acc += Math.sin(30305) + Math.cos(30306) * 41;
+acc += Math.sin(30306) + Math.cos(30307) * 42;
+acc += Math.sin(30307) + Math.cos(30308) * 43;
+acc += Math.sin(30308) + Math.cos(30309) * 44;
+acc += Math.sin(30309) + Math.cos(30310) * 45;
+acc += Math.sin(30310) + Math.cos(30311) * 46;
+acc += Math.sin(30311) + Math.cos(30312) * 47;
+acc += Math.sin(30312) + Math.cos(30313) * 48;
+acc += Math.sin(30313) + Math.cos(30314) * 49;
+acc += Math.sin(30314) + Math.cos(30315) * 50;
+acc += Math.sin(30315) + Math.cos(30316) * 51;
+acc += Math.sin(30316) + Math.cos(30317) * 52;
+acc += Math.sin(30317) + Math.cos(30318) * 53;
+acc += Math.sin(30318) + Math.cos(30319) * 54;
+acc += Math.sin(30319) + Math.cos(30320) * 55;
+acc += Math.sin(30320) + Math.cos(30321) * 56;
+acc += Math.sin(30321) + Math.cos(30322) * 57;
+acc += Math.sin(30322) + Math.cos(30323) * 58;
+acc += Math.sin(30323) + Math.cos(30324) * 59;
+acc += Math.sin(30324) + Math.cos(30325) * 60;
+acc += Math.sin(30325) + Math.cos(30326) * 61;
+acc += Math.sin(30326) + Math.cos(30327) * 62;
+acc += Math.sin(30327) + Math.cos(30328) * 63;
+acc += Math.sin(30328) + Math.cos(30329) * 64;
+acc += Math.sin(30329) + Math.cos(30330) * 65;
+acc += Math.sin(30330) + Math.cos(30331) * 66;
+acc += Math.sin(30331) + Math.cos(30332) * 67;
+acc += Math.sin(30332) + Math.cos(30333) * 68;
+acc += Math.sin(30333) + Math.cos(30334) * 69;
+acc += Math.sin(30334) + Math.cos(30335) * 70;
+acc += Math.sin(30335) + Math.cos(30336) * 71;
+acc += Math.sin(30336) + Math.cos(30337) * 72;
+acc += Math.sin(30337) + Math.cos(30338) * 73;
+acc += Math.sin(30338) + Math.cos(30339) * 74;
+acc += Math.sin(30339) + Math.cos(30340) * 75;
+acc += Math.sin(30340) + Math.cos(30341) * 76;
+acc += Math.sin(30341) + Math.cos(30342) * 77;
+acc += Math.sin(30342) + Math.cos(30343) * 78;
+acc += Math.sin(30343) + Math.cos(30344) * 79;
+acc += Math.sin(30344) + Math.cos(30345) * 80;
+acc += Math.sin(30345) + Math.cos(30346) * 81;
+acc += Math.sin(30346) + Math.cos(30347) * 82;
+acc += Math.sin(30347) + Math.cos(30348) * 83;
+acc += Math.sin(30348) + Math.cos(30349) * 84;
+acc += Math.sin(30349) + Math.cos(30350) * 85;
+acc += Math.sin(30350) + Math.cos(30351) * 86;
+acc += Math.sin(30351) + Math.cos(30352) * 87;
+acc += Math.sin(30352) + Math.cos(30353) * 88;
+acc += Math.sin(30353) + Math.cos(30354) * 89;
+acc += Math.sin(30354) + Math.cos(30355) * 90;
+acc += Math.sin(30355) + Math.cos(30356) * 91;
+acc += Math.sin(30356) + Math.cos(30357) * 92;
+acc += Math.sin(30357) + Math.cos(30358) * 93;
+acc += Math.sin(30358) + Math.cos(30359) * 94;
+acc += Math.sin(30359) + Math.cos(30360) * 95;
+acc += Math.sin(30360) + Math.cos(30361) * 96;
+acc += Math.sin(30361) + Math.cos(30362) * 0;
+acc += Math.sin(30362) + Math.cos(30363) * 1;
+acc += Math.sin(30363) + Math.cos(30364) * 2;
+acc += Math.sin(30364) + Math.cos(30365) * 3;
+acc += Math.sin(30365) + Math.cos(30366) * 4;
+acc += Math.sin(30366) + Math.cos(30367) * 5;
+acc += Math.sin(30367) + Math.cos(30368) * 6;
+acc += Math.sin(30368) + Math.cos(30369) * 7;
+acc += Math.sin(30369) + Math.cos(30370) * 8;
+acc += Math.sin(30370) + Math.cos(30371) * 9;
+acc += Math.sin(30371) + Math.cos(30372) * 10;
+acc += Math.sin(30372) + Math.cos(30373) * 11;
+acc += Math.sin(30373) + Math.cos(30374) * 12;
+acc += Math.sin(30374) + Math.cos(30375) * 13;
+acc += Math.sin(30375) + Math.cos(30376) * 14;
+acc += Math.sin(30376) + Math.cos(30377) * 15;
+acc += Math.sin(30377) + Math.cos(30378) * 16;
+acc += Math.sin(30378) + Math.cos(30379) * 17;
+acc += Math.sin(30379) + Math.cos(30380) * 18;
+acc += Math.sin(30380) + Math.cos(30381) * 19;
+acc += Math.sin(30381) + Math.cos(30382) * 20;
+acc += Math.sin(30382) + Math.cos(30383) * 21;
+acc += Math.sin(30383) + Math.cos(30384) * 22;
+acc += Math.sin(30384) + Math.cos(30385) * 23;
+acc += Math.sin(30385) + Math.cos(30386) * 24;
+acc += Math.sin(30386) + Math.cos(30387) * 25;
+acc += Math.sin(30387) + Math.cos(30388) * 26;
+acc += Math.sin(30388) + Math.cos(30389) * 27;
+acc += Math.sin(30389) + Math.cos(30390) * 28;
+acc += Math.sin(30390) + Math.cos(30391) * 29;
+acc += Math.sin(30391) + Math.cos(30392) * 30;
+acc += Math.sin(30392) + Math.cos(30393) * 31;
+acc += Math.sin(30393) + Math.cos(30394) * 32;
+acc += Math.sin(30394) + Math.cos(30395) * 33;
+acc += Math.sin(30395) + Math.cos(30396) * 34;
+acc += Math.sin(30396) + Math.cos(30397) * 35;
+acc += Math.sin(30397) + Math.cos(30398) * 36;
+acc += Math.sin(30398) + Math.cos(30399) * 37;
+acc += Math.sin(30399) + Math.cos(30400) * 38;
+acc += Math.sin(30400) + Math.cos(30401) * 39;
+acc += Math.sin(30401) + Math.cos(30402) * 40;
+acc += Math.sin(30402) + Math.cos(30403) * 41;
+acc += Math.sin(30403) + Math.cos(30404) * 42;
+acc += Math.sin(30404) + Math.cos(30405) * 43;
+acc += Math.sin(30405) + Math.cos(30406) * 44;
+acc += Math.sin(30406) + Math.cos(30407) * 45;
+acc += Math.sin(30407) + Math.cos(30408) * 46;
+acc += Math.sin(30408) + Math.cos(30409) * 47;
+acc += Math.sin(30409) + Math.cos(30410) * 48;
+acc += Math.sin(30410) + Math.cos(30411) * 49;
+acc += Math.sin(30411) + Math.cos(30412) * 50;
+acc += Math.sin(30412) + Math.cos(30413) * 51;
+acc += Math.sin(30413) + Math.cos(30414) * 52;
+acc += Math.sin(30414) + Math.cos(30415) * 53;
+acc += Math.sin(30415) + Math.cos(30416) * 54;
+acc += Math.sin(30416) + Math.cos(30417) * 55;
+acc += Math.sin(30417) + Math.cos(30418) * 56;
+acc += Math.sin(30418) + Math.cos(30419) * 57;
+acc += Math.sin(30419) + Math.cos(30420) * 58;
+acc += Math.sin(30420) + Math.cos(30421) * 59;
+acc += Math.sin(30421) + Math.cos(30422) * 60;
+acc += Math.sin(30422) + Math.cos(30423) * 61;
+acc += Math.sin(30423) + Math.cos(30424) * 62;
+acc += Math.sin(30424) + Math.cos(30425) * 63;
+acc += Math.sin(30425) + Math.cos(30426) * 64;
+acc += Math.sin(30426) + Math.cos(30427) * 65;
+acc += Math.sin(30427) + Math.cos(30428) * 66;
+acc += Math.sin(30428) + Math.cos(30429) * 67;
+acc += Math.sin(30429) + Math.cos(30430) * 68;
+acc += Math.sin(30430) + Math.cos(30431) * 69;
+acc += Math.sin(30431) + Math.cos(30432) * 70;
+acc += Math.sin(30432) + Math.cos(30433) * 71;
+acc += Math.sin(30433) + Math.cos(30434) * 72;
+acc += Math.sin(30434) + Math.cos(30435) * 73;
+acc += Math.sin(30435) + Math.cos(30436) * 74;
+acc += Math.sin(30436) + Math.cos(30437) * 75;
+acc += Math.sin(30437) + Math.cos(30438) * 76;
+acc += Math.sin(30438) + Math.cos(30439) * 77;
+acc += Math.sin(30439) + Math.cos(30440) * 78;
+acc += Math.sin(30440) + Math.cos(30441) * 79;
+acc += Math.sin(30441) + Math.cos(30442) * 80;
+acc += Math.sin(30442) + Math.cos(30443) * 81;
+acc += Math.sin(30443) + Math.cos(30444) * 82;
+acc += Math.sin(30444) + Math.cos(30445) * 83;
+acc += Math.sin(30445) + Math.cos(30446) * 84;
+acc += Math.sin(30446) + Math.cos(30447) * 85;
+acc += Math.sin(30447) + Math.cos(30448) * 86;
+acc += Math.sin(30448) + Math.cos(30449) * 87;
+acc += Math.sin(30449) + Math.cos(30450) * 88;
+acc += Math.sin(30450) + Math.cos(30451) * 89;
+acc += Math.sin(30451) + Math.cos(30452) * 90;
+acc += Math.sin(30452) + Math.cos(30453) * 91;
+acc += Math.sin(30453) + Math.cos(30454) * 92;
+acc += Math.sin(30454) + Math.cos(30455) * 93;
+acc += Math.sin(30455) + Math.cos(30456) * 94;
+acc += Math.sin(30456) + Math.cos(30457) * 95;
+acc += Math.sin(30457) + Math.cos(30458) * 96;
+acc += Math.sin(30458) + Math.cos(30459) * 0;
+acc += Math.sin(30459) + Math.cos(30460) * 1;
+acc += Math.sin(30460) + Math.cos(30461) * 2;
+acc += Math.sin(30461) + Math.cos(30462) * 3;
+acc += Math.sin(30462) + Math.cos(30463) * 4;
+acc += Math.sin(30463) + Math.cos(30464) * 5;
+acc += Math.sin(30464) + Math.cos(30465) * 6;
+acc += Math.sin(30465) + Math.cos(30466) * 7;
+acc += Math.sin(30466) + Math.cos(30467) * 8;
+acc += Math.sin(30467) + Math.cos(30468) * 9;
+acc += Math.sin(30468) + Math.cos(30469) * 10;
+acc += Math.sin(30469) + Math.cos(30470) * 11;
+acc += Math.sin(30470) + Math.cos(30471) * 12;
+acc += Math.sin(30471) + Math.cos(30472) * 13;
+acc += Math.sin(30472) + Math.cos(30473) * 14;
+acc += Math.sin(30473) + Math.cos(30474) * 15;
+acc += Math.sin(30474) + Math.cos(30475) * 16;
+acc += Math.sin(30475) + Math.cos(30476) * 17;
+acc += Math.sin(30476) + Math.cos(30477) * 18;
+acc += Math.sin(30477) + Math.cos(30478) * 19;
+acc += Math.sin(30478) + Math.cos(30479) * 20;
+acc += Math.sin(30479) + Math.cos(30480) * 21;
+acc += Math.sin(30480) + Math.cos(30481) * 22;
+acc += Math.sin(30481) + Math.cos(30482) * 23;
+acc += Math.sin(30482) + Math.cos(30483) * 24;
+acc += Math.sin(30483) + Math.cos(30484) * 25;
+acc += Math.sin(30484) + Math.cos(30485) * 26;
+acc += Math.sin(30485) + Math.cos(30486) * 27;
+acc += Math.sin(30486) + Math.cos(30487) * 28;
+acc += Math.sin(30487) + Math.cos(30488) * 29;
+acc += Math.sin(30488) + Math.cos(30489) * 30;
+acc += Math.sin(30489) + Math.cos(30490) * 31;
+acc += Math.sin(30490) + Math.cos(30491) * 32;
+acc += Math.sin(30491) + Math.cos(30492) * 33;
+acc += Math.sin(30492) + Math.cos(30493) * 34;
+acc += Math.sin(30493) + Math.cos(30494) * 35;
+acc += Math.sin(30494) + Math.cos(30495) * 36;
+acc += Math.sin(30495) + Math.cos(30496) * 37;
+acc += Math.sin(30496) + Math.cos(30497) * 38;
+acc += Math.sin(30497) + Math.cos(30498) * 39;
+acc += Math.sin(30498) + Math.cos(30499) * 40;
+acc += Math.sin(30499) + Math.cos(30500) * 41;
+acc += Math.sin(30500) + Math.cos(30501) * 42;
+acc += Math.sin(30501) + Math.cos(30502) * 43;
+acc += Math.sin(30502) + Math.cos(30503) * 44;
+acc += Math.sin(30503) + Math.cos(30504) * 45;
+acc += Math.sin(30504) + Math.cos(30505) * 46;
+acc += Math.sin(30505) + Math.cos(30506) * 47;
+acc += Math.sin(30506) + Math.cos(30507) * 48;
+acc += Math.sin(30507) + Math.cos(30508) * 49;
+acc += Math.sin(30508) + Math.cos(30509) * 50;
+acc += Math.sin(30509) + Math.cos(30510) * 51;
+acc += Math.sin(30510) + Math.cos(30511) * 52;
+acc += Math.sin(30511) + Math.cos(30512) * 53;
+acc += Math.sin(30512) + Math.cos(30513) * 54;
+acc += Math.sin(30513) + Math.cos(30514) * 55;
+acc += Math.sin(30514) + Math.cos(30515) * 56;
+acc += Math.sin(30515) + Math.cos(30516) * 57;
+acc += Math.sin(30516) + Math.cos(30517) * 58;
+acc += Math.sin(30517) + Math.cos(30518) * 59;
+acc += Math.sin(30518) + Math.cos(30519) * 60;
+acc += Math.sin(30519) + Math.cos(30520) * 61;
+acc += Math.sin(30520) + Math.cos(30521) * 62;
+acc += Math.sin(30521) + Math.cos(30522) * 63;
+acc += Math.sin(30522) + Math.cos(30523) * 64;
+acc += Math.sin(30523) + Math.cos(30524) * 65;
+acc += Math.sin(30524) + Math.cos(30525) * 66;
+acc += Math.sin(30525) + Math.cos(30526) * 67;
+acc += Math.sin(30526) + Math.cos(30527) * 68;
+acc += Math.sin(30527) + Math.cos(30528) * 69;
+acc += Math.sin(30528) + Math.cos(30529) * 70;
+acc += Math.sin(30529) + Math.cos(30530) * 71;
+acc += Math.sin(30530) + Math.cos(30531) * 72;
+acc += Math.sin(30531) + Math.cos(30532) * 73;
+acc += Math.sin(30532) + Math.cos(30533) * 74;
+acc += Math.sin(30533) + Math.cos(30534) * 75;
+acc += Math.sin(30534) + Math.cos(30535) * 76;
+acc += Math.sin(30535) + Math.cos(30536) * 77;
+acc += Math.sin(30536) + Math.cos(30537) * 78;
+acc += Math.sin(30537) + Math.cos(30538) * 79;
+acc += Math.sin(30538) + Math.cos(30539) * 80;
+acc += Math.sin(30539) + Math.cos(30540) * 81;
+acc += Math.sin(30540) + Math.cos(30541) * 82;
+acc += Math.sin(30541) + Math.cos(30542) * 83;
+acc += Math.sin(30542) + Math.cos(30543) * 84;
+acc += Math.sin(30543) + Math.cos(30544) * 85;
+acc += Math.sin(30544) + Math.cos(30545) * 86;
+acc += Math.sin(30545) + Math.cos(30546) * 87;
+acc += Math.sin(30546) + Math.cos(30547) * 88;
+acc += Math.sin(30547) + Math.cos(30548) * 89;
+acc += Math.sin(30548) + Math.cos(30549) * 90;
+acc += Math.sin(30549) + Math.cos(30550) * 91;
+acc += Math.sin(30550) + Math.cos(30551) * 92;
+acc += Math.sin(30551) + Math.cos(30552) * 93;
+acc += Math.sin(30552) + Math.cos(30553) * 94;
+acc += Math.sin(30553) + Math.cos(30554) * 95;
+acc += Math.sin(30554) + Math.cos(30555) * 96;
+acc += Math.sin(30555) + Math.cos(30556) * 0;
+acc += Math.sin(30556) + Math.cos(30557) * 1;
+acc += Math.sin(30557) + Math.cos(30558) * 2;
+acc += Math.sin(30558) + Math.cos(30559) * 3;
+acc += Math.sin(30559) + Math.cos(30560) * 4;
+acc += Math.sin(30560) + Math.cos(30561) * 5;
+acc += Math.sin(30561) + Math.cos(30562) * 6;
+acc += Math.sin(30562) + Math.cos(30563) * 7;
+acc += Math.sin(30563) + Math.cos(30564) * 8;
+acc += Math.sin(30564) + Math.cos(30565) * 9;
+acc += Math.sin(30565) + Math.cos(30566) * 10;
+acc += Math.sin(30566) + Math.cos(30567) * 11;
+acc += Math.sin(30567) + Math.cos(30568) * 12;
+acc += Math.sin(30568) + Math.cos(30569) * 13;
+acc += Math.sin(30569) + Math.cos(30570) * 14;
+acc += Math.sin(30570) + Math.cos(30571) * 15;
+acc += Math.sin(30571) + Math.cos(30572) * 16;
+acc += Math.sin(30572) + Math.cos(30573) * 17;
+acc += Math.sin(30573) + Math.cos(30574) * 18;
+acc += Math.sin(30574) + Math.cos(30575) * 19;
+acc += Math.sin(30575) + Math.cos(30576) * 20;
+acc += Math.sin(30576) + Math.cos(30577) * 21;
+acc += Math.sin(30577) + Math.cos(30578) * 22;
+acc += Math.sin(30578) + Math.cos(30579) * 23;
+acc += Math.sin(30579) + Math.cos(30580) * 24;
+acc += Math.sin(30580) + Math.cos(30581) * 25;
+acc += Math.sin(30581) + Math.cos(30582) * 26;
+acc += Math.sin(30582) + Math.cos(30583) * 27;
+acc += Math.sin(30583) + Math.cos(30584) * 28;
+acc += Math.sin(30584) + Math.cos(30585) * 29;
+acc += Math.sin(30585) + Math.cos(30586) * 30;
+acc += Math.sin(30586) + Math.cos(30587) * 31;
+acc += Math.sin(30587) + Math.cos(30588) * 32;
+acc += Math.sin(30588) + Math.cos(30589) * 33;
+acc += Math.sin(30589) + Math.cos(30590) * 34;
+acc += Math.sin(30590) + Math.cos(30591) * 35;
+acc += Math.sin(30591) + Math.cos(30592) * 36;
+acc += Math.sin(30592) + Math.cos(30593) * 37;
+acc += Math.sin(30593) + Math.cos(30594) * 38;
+acc += Math.sin(30594) + Math.cos(30595) * 39;
+acc += Math.sin(30595) + Math.cos(30596) * 40;
+acc += Math.sin(30596) + Math.cos(30597) * 41;
+acc += Math.sin(30597) + Math.cos(30598) * 42;
+acc += Math.sin(30598) + Math.cos(30599) * 43;
+acc += Math.sin(30599) + Math.cos(30600) * 44;
+acc += Math.sin(30600) + Math.cos(30601) * 45;
+acc += Math.sin(30601) + Math.cos(30602) * 46;
+acc += Math.sin(30602) + Math.cos(30603) * 47;
+acc += Math.sin(30603) + Math.cos(30604) * 48;
+acc += Math.sin(30604) + Math.cos(30605) * 49;
+acc += Math.sin(30605) + Math.cos(30606) * 50;
+acc += Math.sin(30606) + Math.cos(30607) * 51;
+acc += Math.sin(30607) + Math.cos(30608) * 52;
+acc += Math.sin(30608) + Math.cos(30609) * 53;
+acc += Math.sin(30609) + Math.cos(30610) * 54;
+acc += Math.sin(30610) + Math.cos(30611) * 55;
+acc += Math.sin(30611) + Math.cos(30612) * 56;
+acc += Math.sin(30612) + Math.cos(30613) * 57;
+acc += Math.sin(30613) + Math.cos(30614) * 58;
+acc += Math.sin(30614) + Math.cos(30615) * 59;
+acc += Math.sin(30615) + Math.cos(30616) * 60;
+acc += Math.sin(30616) + Math.cos(30617) * 61;
+acc += Math.sin(30617) + Math.cos(30618) * 62;
+acc += Math.sin(30618) + Math.cos(30619) * 63;
+acc += Math.sin(30619) + Math.cos(30620) * 64;
+acc += Math.sin(30620) + Math.cos(30621) * 65;
+acc += Math.sin(30621) + Math.cos(30622) * 66;
+acc += Math.sin(30622) + Math.cos(30623) * 67;
+acc += Math.sin(30623) + Math.cos(30624) * 68;
+acc += Math.sin(30624) + Math.cos(30625) * 69;
+acc += Math.sin(30625) + Math.cos(30626) * 70;
+acc += Math.sin(30626) + Math.cos(30627) * 71;
+acc += Math.sin(30627) + Math.cos(30628) * 72;
+acc += Math.sin(30628) + Math.cos(30629) * 73;
+acc += Math.sin(30629) + Math.cos(30630) * 74;
+acc += Math.sin(30630) + Math.cos(30631) * 75;
+acc += Math.sin(30631) + Math.cos(30632) * 76;
+acc += Math.sin(30632) + Math.cos(30633) * 77;
+acc += Math.sin(30633) + Math.cos(30634) * 78;
+acc += Math.sin(30634) + Math.cos(30635) * 79;
+acc += Math.sin(30635) + Math.cos(30636) * 80;
+acc += Math.sin(30636) + Math.cos(30637) * 81;
+acc += Math.sin(30637) + Math.cos(30638) * 82;
+acc += Math.sin(30638) + Math.cos(30639) * 83;
+acc += Math.sin(30639) + Math.cos(30640) * 84;
+acc += Math.sin(30640) + Math.cos(30641) * 85;
+acc += Math.sin(30641) + Math.cos(30642) * 86;
+acc += Math.sin(30642) + Math.cos(30643) * 87;
+acc += Math.sin(30643) + Math.cos(30644) * 88;
+acc += Math.sin(30644) + Math.cos(30645) * 89;
+acc += Math.sin(30645) + Math.cos(30646) * 90;
+acc += Math.sin(30646) + Math.cos(30647) * 91;
+acc += Math.sin(30647) + Math.cos(30648) * 92;
+acc += Math.sin(30648) + Math.cos(30649) * 93;
+acc += Math.sin(30649) + Math.cos(30650) * 94;
+acc += Math.sin(30650) + Math.cos(30651) * 95;
+acc += Math.sin(30651) + Math.cos(30652) * 96;
+acc += Math.sin(30652) + Math.cos(30653) * 0;
+acc += Math.sin(30653) + Math.cos(30654) * 1;
+acc += Math.sin(30654) + Math.cos(30655) * 2;
+acc += Math.sin(30655) + Math.cos(30656) * 3;
+acc += Math.sin(30656) + Math.cos(30657) * 4;
+acc += Math.sin(30657) + Math.cos(30658) * 5;
+acc += Math.sin(30658) + Math.cos(30659) * 6;
+acc += Math.sin(30659) + Math.cos(30660) * 7;
+acc += Math.sin(30660) + Math.cos(30661) * 8;
+acc += Math.sin(30661) + Math.cos(30662) * 9;
+acc += Math.sin(30662) + Math.cos(30663) * 10;
+acc += Math.sin(30663) + Math.cos(30664) * 11;
+acc += Math.sin(30664) + Math.cos(30665) * 12;
+acc += Math.sin(30665) + Math.cos(30666) * 13;
+acc += Math.sin(30666) + Math.cos(30667) * 14;
+acc += Math.sin(30667) + Math.cos(30668) * 15;
+acc += Math.sin(30668) + Math.cos(30669) * 16;
+acc += Math.sin(30669) + Math.cos(30670) * 17;
+acc += Math.sin(30670) + Math.cos(30671) * 18;
+acc += Math.sin(30671) + Math.cos(30672) * 19;
+acc += Math.sin(30672) + Math.cos(30673) * 20;
+acc += Math.sin(30673) + Math.cos(30674) * 21;
+acc += Math.sin(30674) + Math.cos(30675) * 22;
+acc += Math.sin(30675) + Math.cos(30676) * 23;
+acc += Math.sin(30676) + Math.cos(30677) * 24;
+acc += Math.sin(30677) + Math.cos(30678) * 25;
+acc += Math.sin(30678) + Math.cos(30679) * 26;
+acc += Math.sin(30679) + Math.cos(30680) * 27;
+acc += Math.sin(30680) + Math.cos(30681) * 28;
+acc += Math.sin(30681) + Math.cos(30682) * 29;
+acc += Math.sin(30682) + Math.cos(30683) * 30;
+acc += Math.sin(30683) + Math.cos(30684) * 31;
+acc += Math.sin(30684) + Math.cos(30685) * 32;
+acc += Math.sin(30685) + Math.cos(30686) * 33;
+acc += Math.sin(30686) + Math.cos(30687) * 34;
+acc += Math.sin(30687) + Math.cos(30688) * 35;
+acc += Math.sin(30688) + Math.cos(30689) * 36;
+acc += Math.sin(30689) + Math.cos(30690) * 37;
+acc += Math.sin(30690) + Math.cos(30691) * 38;
+acc += Math.sin(30691) + Math.cos(30692) * 39;
+acc += Math.sin(30692) + Math.cos(30693) * 40;
+acc += Math.sin(30693) + Math.cos(30694) * 41;
+acc += Math.sin(30694) + Math.cos(30695) * 42;
+acc += Math.sin(30695) + Math.cos(30696) * 43;
+acc += Math.sin(30696) + Math.cos(30697) * 44;
+acc += Math.sin(30697) + Math.cos(30698) * 45;
+acc += Math.sin(30698) + Math.cos(30699) * 46;
+acc += Math.sin(30699) + Math.cos(30700) * 47;
+acc += Math.sin(30700) + Math.cos(30701) * 48;
+acc += Math.sin(30701) + Math.cos(30702) * 49;
+acc += Math.sin(30702) + Math.cos(30703) * 50;
+acc += Math.sin(30703) + Math.cos(30704) * 51;
+acc += Math.sin(30704) + Math.cos(30705) * 52;
+acc += Math.sin(30705) + Math.cos(30706) * 53;
+acc += Math.sin(30706) + Math.cos(30707) * 54;
+acc += Math.sin(30707) + Math.cos(30708) * 55;
+acc += Math.sin(30708) + Math.cos(30709) * 56;
+acc += Math.sin(30709) + Math.cos(30710) * 57;
+acc += Math.sin(30710) + Math.cos(30711) * 58;
+acc += Math.sin(30711) + Math.cos(30712) * 59;
+acc += Math.sin(30712) + Math.cos(30713) * 60;
+acc += Math.sin(30713) + Math.cos(30714) * 61;
+acc += Math.sin(30714) + Math.cos(30715) * 62;
+acc += Math.sin(30715) + Math.cos(30716) * 63;
+acc += Math.sin(30716) + Math.cos(30717) * 64;
+acc += Math.sin(30717) + Math.cos(30718) * 65;
+acc += Math.sin(30718) + Math.cos(30719) * 66;
+acc += Math.sin(30719) + Math.cos(30720) * 67;
+acc += Math.sin(30720) + Math.cos(30721) * 68;
+acc += Math.sin(30721) + Math.cos(30722) * 69;
+acc += Math.sin(30722) + Math.cos(30723) * 70;
+acc += Math.sin(30723) + Math.cos(30724) * 71;
+acc += Math.sin(30724) + Math.cos(30725) * 72;
+acc += Math.sin(30725) + Math.cos(30726) * 73;
+acc += Math.sin(30726) + Math.cos(30727) * 74;
+acc += Math.sin(30727) + Math.cos(30728) * 75;
+acc += Math.sin(30728) + Math.cos(30729) * 76;
+acc += Math.sin(30729) + Math.cos(30730) * 77;
+acc += Math.sin(30730) + Math.cos(30731) * 78;
+acc += Math.sin(30731) + Math.cos(30732) * 79;
+acc += Math.sin(30732) + Math.cos(30733) * 80;
+acc += Math.sin(30733) + Math.cos(30734) * 81;
+acc += Math.sin(30734) + Math.cos(30735) * 82;
+acc += Math.sin(30735) + Math.cos(30736) * 83;
+acc += Math.sin(30736) + Math.cos(30737) * 84;
+acc += Math.sin(30737) + Math.cos(30738) * 85;
+acc += Math.sin(30738) + Math.cos(30739) * 86;
+acc += Math.sin(30739) + Math.cos(30740) * 87;
+acc += Math.sin(30740) + Math.cos(30741) * 88;
+acc += Math.sin(30741) + Math.cos(30742) * 89;
+acc += Math.sin(30742) + Math.cos(30743) * 90;
+acc += Math.sin(30743) + Math.cos(30744) * 91;
+acc += Math.sin(30744) + Math.cos(30745) * 92;
+acc += Math.sin(30745) + Math.cos(30746) * 93;
+acc += Math.sin(30746) + Math.cos(30747) * 94;
+acc += Math.sin(30747) + Math.cos(30748) * 95;
+acc += Math.sin(30748) + Math.cos(30749) * 96;
+acc += Math.sin(30749) + Math.cos(30750) * 0;
+acc += Math.sin(30750) + Math.cos(30751) * 1;
+acc += Math.sin(30751) + Math.cos(30752) * 2;
+acc += Math.sin(30752) + Math.cos(30753) * 3;
+acc += Math.sin(30753) + Math.cos(30754) * 4;
+acc += Math.sin(30754) + Math.cos(30755) * 5;
+acc += Math.sin(30755) + Math.cos(30756) * 6;
+acc += Math.sin(30756) + Math.cos(30757) * 7;
+acc += Math.sin(30757) + Math.cos(30758) * 8;
+acc += Math.sin(30758) + Math.cos(30759) * 9;
+acc += Math.sin(30759) + Math.cos(30760) * 10;
+acc += Math.sin(30760) + Math.cos(30761) * 11;
+acc += Math.sin(30761) + Math.cos(30762) * 12;
+acc += Math.sin(30762) + Math.cos(30763) * 13;
+acc += Math.sin(30763) + Math.cos(30764) * 14;
+acc += Math.sin(30764) + Math.cos(30765) * 15;
+acc += Math.sin(30765) + Math.cos(30766) * 16;
+acc += Math.sin(30766) + Math.cos(30767) * 17;
+acc += Math.sin(30767) + Math.cos(30768) * 18;
+acc += Math.sin(30768) + Math.cos(30769) * 19;
+acc += Math.sin(30769) + Math.cos(30770) * 20;
+acc += Math.sin(30770) + Math.cos(30771) * 21;
+acc += Math.sin(30771) + Math.cos(30772) * 22;
+acc += Math.sin(30772) + Math.cos(30773) * 23;
+acc += Math.sin(30773) + Math.cos(30774) * 24;
+acc += Math.sin(30774) + Math.cos(30775) * 25;
+acc += Math.sin(30775) + Math.cos(30776) * 26;
+acc += Math.sin(30776) + Math.cos(30777) * 27;
+acc += Math.sin(30777) + Math.cos(30778) * 28;
+acc += Math.sin(30778) + Math.cos(30779) * 29;
+acc += Math.sin(30779) + Math.cos(30780) * 30;
+acc += Math.sin(30780) + Math.cos(30781) * 31;
+acc += Math.sin(30781) + Math.cos(30782) * 32;
+acc += Math.sin(30782) + Math.cos(30783) * 33;
+acc += Math.sin(30783) + Math.cos(30784) * 34;
+acc += Math.sin(30784) + Math.cos(30785) * 35;
+acc += Math.sin(30785) + Math.cos(30786) * 36;
+acc += Math.sin(30786) + Math.cos(30787) * 37;
+acc += Math.sin(30787) + Math.cos(30788) * 38;
+acc += Math.sin(30788) + Math.cos(30789) * 39;
+acc += Math.sin(30789) + Math.cos(30790) * 40;
+acc += Math.sin(30790) + Math.cos(30791) * 41;
+acc += Math.sin(30791) + Math.cos(30792) * 42;
+acc += Math.sin(30792) + Math.cos(30793) * 43;
+acc += Math.sin(30793) + Math.cos(30794) * 44;
+acc += Math.sin(30794) + Math.cos(30795) * 45;
+acc += Math.sin(30795) + Math.cos(30796) * 46;
+acc += Math.sin(30796) + Math.cos(30797) * 47;
+acc += Math.sin(30797) + Math.cos(30798) * 48;
+acc += Math.sin(30798) + Math.cos(30799) * 49;
+acc += Math.sin(30799) + Math.cos(30800) * 50;
+acc += Math.sin(30800) + Math.cos(30801) * 51;
+acc += Math.sin(30801) + Math.cos(30802) * 52;
+acc += Math.sin(30802) + Math.cos(30803) * 53;
+acc += Math.sin(30803) + Math.cos(30804) * 54;
+acc += Math.sin(30804) + Math.cos(30805) * 55;
+acc += Math.sin(30805) + Math.cos(30806) * 56;
+acc += Math.sin(30806) + Math.cos(30807) * 57;
+acc += Math.sin(30807) + Math.cos(30808) * 58;
+acc += Math.sin(30808) + Math.cos(30809) * 59;
+acc += Math.sin(30809) + Math.cos(30810) * 60;
+acc += Math.sin(30810) + Math.cos(30811) * 61;
+acc += Math.sin(30811) + Math.cos(30812) * 62;
+acc += Math.sin(30812) + Math.cos(30813) * 63;
+acc += Math.sin(30813) + Math.cos(30814) * 64;
+acc += Math.sin(30814) + Math.cos(30815) * 65;
+acc += Math.sin(30815) + Math.cos(30816) * 66;
+acc += Math.sin(30816) + Math.cos(30817) * 67;
+acc += Math.sin(30817) + Math.cos(30818) * 68;
+acc += Math.sin(30818) + Math.cos(30819) * 69;
+acc += Math.sin(30819) + Math.cos(30820) * 70;
+acc += Math.sin(30820) + Math.cos(30821) * 71;
+acc += Math.sin(30821) + Math.cos(30822) * 72;
+acc += Math.sin(30822) + Math.cos(30823) * 73;
+acc += Math.sin(30823) + Math.cos(30824) * 74;
+acc += Math.sin(30824) + Math.cos(30825) * 75;
+acc += Math.sin(30825) + Math.cos(30826) * 76;
+acc += Math.sin(30826) + Math.cos(30827) * 77;
+acc += Math.sin(30827) + Math.cos(30828) * 78;
+acc += Math.sin(30828) + Math.cos(30829) * 79;
+acc += Math.sin(30829) + Math.cos(30830) * 80;
+acc += Math.sin(30830) + Math.cos(30831) * 81;
+acc += Math.sin(30831) + Math.cos(30832) * 82;
+acc += Math.sin(30832) + Math.cos(30833) * 83;
+acc += Math.sin(30833) + Math.cos(30834) * 84;
+acc += Math.sin(30834) + Math.cos(30835) * 85;
+acc += Math.sin(30835) + Math.cos(30836) * 86;
+acc += Math.sin(30836) + Math.cos(30837) * 87;
+acc += Math.sin(30837) + Math.cos(30838) * 88;
+acc += Math.sin(30838) + Math.cos(30839) * 89;
+acc += Math.sin(30839) + Math.cos(30840) * 90;
+acc += Math.sin(30840) + Math.cos(30841) * 91;
+acc += Math.sin(30841) + Math.cos(30842) * 92;
+acc += Math.sin(30842) + Math.cos(30843) * 93;
+acc += Math.sin(30843) + Math.cos(30844) * 94;
+acc += Math.sin(30844) + Math.cos(30845) * 95;
+acc += Math.sin(30845) + Math.cos(30846) * 96;
+acc += Math.sin(30846) + Math.cos(30847) * 0;
+acc += Math.sin(30847) + Math.cos(30848) * 1;
+acc += Math.sin(30848) + Math.cos(30849) * 2;
+acc += Math.sin(30849) + Math.cos(30850) * 3;
+acc += Math.sin(30850) + Math.cos(30851) * 4;
+acc += Math.sin(30851) + Math.cos(30852) * 5;
+acc += Math.sin(30852) + Math.cos(30853) * 6;
+acc += Math.sin(30853) + Math.cos(30854) * 7;
+acc += Math.sin(30854) + Math.cos(30855) * 8;
+acc += Math.sin(30855) + Math.cos(30856) * 9;
+acc += Math.sin(30856) + Math.cos(30857) * 10;
+acc += Math.sin(30857) + Math.cos(30858) * 11;
+acc += Math.sin(30858) + Math.cos(30859) * 12;
+acc += Math.sin(30859) + Math.cos(30860) * 13;
+acc += Math.sin(30860) + Math.cos(30861) * 14;
+acc += Math.sin(30861) + Math.cos(30862) * 15;
+acc += Math.sin(30862) + Math.cos(30863) * 16;
+acc += Math.sin(30863) + Math.cos(30864) * 17;
+acc += Math.sin(30864) + Math.cos(30865) * 18;
+acc += Math.sin(30865) + Math.cos(30866) * 19;
+acc += Math.sin(30866) + Math.cos(30867) * 20;
+acc += Math.sin(30867) + Math.cos(30868) * 21;
+acc += Math.sin(30868) + Math.cos(30869) * 22;
+acc += Math.sin(30869) + Math.cos(30870) * 23;
+acc += Math.sin(30870) + Math.cos(30871) * 24;
+acc += Math.sin(30871) + Math.cos(30872) * 25;
+acc += Math.sin(30872) + Math.cos(30873) * 26;
+acc += Math.sin(30873) + Math.cos(30874) * 27;
+acc += Math.sin(30874) + Math.cos(30875) * 28;
+acc += Math.sin(30875) + Math.cos(30876) * 29;
+acc += Math.sin(30876) + Math.cos(30877) * 30;
+acc += Math.sin(30877) + Math.cos(30878) * 31;
+acc += Math.sin(30878) + Math.cos(30879) * 32;
+acc += Math.sin(30879) + Math.cos(30880) * 33;
+acc += Math.sin(30880) + Math.cos(30881) * 34;
+acc += Math.sin(30881) + Math.cos(30882) * 35;
+acc += Math.sin(30882) + Math.cos(30883) * 36;
+acc += Math.sin(30883) + Math.cos(30884) * 37;
+acc += Math.sin(30884) + Math.cos(30885) * 38;
+acc += Math.sin(30885) + Math.cos(30886) * 39;
+acc += Math.sin(30886) + Math.cos(30887) * 40;
+acc += Math.sin(30887) + Math.cos(30888) * 41;
+acc += Math.sin(30888) + Math.cos(30889) * 42;
+acc += Math.sin(30889) + Math.cos(30890) * 43;
+acc += Math.sin(30890) + Math.cos(30891) * 44;
+acc += Math.sin(30891) + Math.cos(30892) * 45;
+acc += Math.sin(30892) + Math.cos(30893) * 46;
+acc += Math.sin(30893) + Math.cos(30894) * 47;
+acc += Math.sin(30894) + Math.cos(30895) * 48;
+acc += Math.sin(30895) + Math.cos(30896) * 49;
+acc += Math.sin(30896) + Math.cos(30897) * 50;
+acc += Math.sin(30897) + Math.cos(30898) * 51;
+acc += Math.sin(30898) + Math.cos(30899) * 52;
+acc += Math.sin(30899) + Math.cos(30900) * 53;
+acc += Math.sin(30900) + Math.cos(30901) * 54;
+acc += Math.sin(30901) + Math.cos(30902) * 55;
+acc += Math.sin(30902) + Math.cos(30903) * 56;
+acc += Math.sin(30903) + Math.cos(30904) * 57;
+acc += Math.sin(30904) + Math.cos(30905) * 58;
+acc += Math.sin(30905) + Math.cos(30906) * 59;
+acc += Math.sin(30906) + Math.cos(30907) * 60;
+acc += Math.sin(30907) + Math.cos(30908) * 61;
+acc += Math.sin(30908) + Math.cos(30909) * 62;
+acc += Math.sin(30909) + Math.cos(30910) * 63;
+acc += Math.sin(30910) + Math.cos(30911) * 64;
+acc += Math.sin(30911) + Math.cos(30912) * 65;
+acc += Math.sin(30912) + Math.cos(30913) * 66;
+acc += Math.sin(30913) + Math.cos(30914) * 67;
+acc += Math.sin(30914) + Math.cos(30915) * 68;
+acc += Math.sin(30915) + Math.cos(30916) * 69;
+acc += Math.sin(30916) + Math.cos(30917) * 70;
+acc += Math.sin(30917) + Math.cos(30918) * 71;
+acc += Math.sin(30918) + Math.cos(30919) * 72;
+acc += Math.sin(30919) + Math.cos(30920) * 73;
+acc += Math.sin(30920) + Math.cos(30921) * 74;
+acc += Math.sin(30921) + Math.cos(30922) * 75;
+acc += Math.sin(30922) + Math.cos(30923) * 76;
+acc += Math.sin(30923) + Math.cos(30924) * 77;
+acc += Math.sin(30924) + Math.cos(30925) * 78;
+acc += Math.sin(30925) + Math.cos(30926) * 79;
+acc += Math.sin(30926) + Math.cos(30927) * 80;
+acc += Math.sin(30927) + Math.cos(30928) * 81;
+acc += Math.sin(30928) + Math.cos(30929) * 82;
+acc += Math.sin(30929) + Math.cos(30930) * 83;
+acc += Math.sin(30930) + Math.cos(30931) * 84;
+acc += Math.sin(30931) + Math.cos(30932) * 85;
+acc += Math.sin(30932) + Math.cos(30933) * 86;
+acc += Math.sin(30933) + Math.cos(30934) * 87;
+acc += Math.sin(30934) + Math.cos(30935) * 88;
+acc += Math.sin(30935) + Math.cos(30936) * 89;
+acc += Math.sin(30936) + Math.cos(30937) * 90;
+acc += Math.sin(30937) + Math.cos(30938) * 91;
+acc += Math.sin(30938) + Math.cos(30939) * 92;
+acc += Math.sin(30939) + Math.cos(30940) * 93;
+acc += Math.sin(30940) + Math.cos(30941) * 94;
+acc += Math.sin(30941) + Math.cos(30942) * 95;
+acc += Math.sin(30942) + Math.cos(30943) * 96;
+acc += Math.sin(30943) + Math.cos(30944) * 0;
+acc += Math.sin(30944) + Math.cos(30945) * 1;
+acc += Math.sin(30945) + Math.cos(30946) * 2;
+acc += Math.sin(30946) + Math.cos(30947) * 3;
+acc += Math.sin(30947) + Math.cos(30948) * 4;
+acc += Math.sin(30948) + Math.cos(30949) * 5;
+acc += Math.sin(30949) + Math.cos(30950) * 6;
+acc += Math.sin(30950) + Math.cos(30951) * 7;
+acc += Math.sin(30951) + Math.cos(30952) * 8;
+acc += Math.sin(30952) + Math.cos(30953) * 9;
+acc += Math.sin(30953) + Math.cos(30954) * 10;
+acc += Math.sin(30954) + Math.cos(30955) * 11;
+acc += Math.sin(30955) + Math.cos(30956) * 12;
+acc += Math.sin(30956) + Math.cos(30957) * 13;
+acc += Math.sin(30957) + Math.cos(30958) * 14;
+acc += Math.sin(30958) + Math.cos(30959) * 15;
+acc += Math.sin(30959) + Math.cos(30960) * 16;
+acc += Math.sin(30960) + Math.cos(30961) * 17;
+acc += Math.sin(30961) + Math.cos(30962) * 18;
+acc += Math.sin(30962) + Math.cos(30963) * 19;
+acc += Math.sin(30963) + Math.cos(30964) * 20;
+acc += Math.sin(30964) + Math.cos(30965) * 21;
+acc += Math.sin(30965) + Math.cos(30966) * 22;
+acc += Math.sin(30966) + Math.cos(30967) * 23;
+acc += Math.sin(30967) + Math.cos(30968) * 24;
+acc += Math.sin(30968) + Math.cos(30969) * 25;
+acc += Math.sin(30969) + Math.cos(30970) * 26;
+acc += Math.sin(30970) + Math.cos(30971) * 27;
+acc += Math.sin(30971) + Math.cos(30972) * 28;
+acc += Math.sin(30972) + Math.cos(30973) * 29;
+acc += Math.sin(30973) + Math.cos(30974) * 30;
+acc += Math.sin(30974) + Math.cos(30975) * 31;
+acc += Math.sin(30975) + Math.cos(30976) * 32;
+acc += Math.sin(30976) + Math.cos(30977) * 33;
+acc += Math.sin(30977) + Math.cos(30978) * 34;
+acc += Math.sin(30978) + Math.cos(30979) * 35;
+acc += Math.sin(30979) + Math.cos(30980) * 36;
+acc += Math.sin(30980) + Math.cos(30981) * 37;
+acc += Math.sin(30981) + Math.cos(30982) * 38;
+acc += Math.sin(30982) + Math.cos(30983) * 39;
+acc += Math.sin(30983) + Math.cos(30984) * 40;
+acc += Math.sin(30984) + Math.cos(30985) * 41;
+acc += Math.sin(30985) + Math.cos(30986) * 42;
+acc += Math.sin(30986) + Math.cos(30987) * 43;
+acc += Math.sin(30987) + Math.cos(30988) * 44;
+acc += Math.sin(30988) + Math.cos(30989) * 45;
+acc += Math.sin(30989) + Math.cos(30990) * 46;
+acc += Math.sin(30990) + Math.cos(30991) * 47;
+acc += Math.sin(30991) + Math.cos(30992) * 48;
+acc += Math.sin(30992) + Math.cos(30993) * 49;
+acc += Math.sin(30993) + Math.cos(30994) * 50;
+acc += Math.sin(30994) + Math.cos(30995) * 51;
+acc += Math.sin(30995) + Math.cos(30996) * 52;
+acc += Math.sin(30996) + Math.cos(30997) * 53;
+acc += Math.sin(30997) + Math.cos(30998) * 54;
+acc += Math.sin(30998) + Math.cos(30999) * 55;
+acc += Math.sin(30999) + Math.cos(31000) * 56;
+acc += Math.sin(31000) + Math.cos(31001) * 57;
+acc += Math.sin(31001) + Math.cos(31002) * 58;
+acc += Math.sin(31002) + Math.cos(31003) * 59;
+acc += Math.sin(31003) + Math.cos(31004) * 60;
+acc += Math.sin(31004) + Math.cos(31005) * 61;
+acc += Math.sin(31005) + Math.cos(31006) * 62;
+acc += Math.sin(31006) + Math.cos(31007) * 63;
+acc += Math.sin(31007) + Math.cos(31008) * 64;
+acc += Math.sin(31008) + Math.cos(31009) * 65;
+acc += Math.sin(31009) + Math.cos(31010) * 66;
+acc += Math.sin(31010) + Math.cos(31011) * 67;
+acc += Math.sin(31011) + Math.cos(31012) * 68;
+acc += Math.sin(31012) + Math.cos(31013) * 69;
+acc += Math.sin(31013) + Math.cos(31014) * 70;
+acc += Math.sin(31014) + Math.cos(31015) * 71;
+acc += Math.sin(31015) + Math.cos(31016) * 72;
+acc += Math.sin(31016) + Math.cos(31017) * 73;
+acc += Math.sin(31017) + Math.cos(31018) * 74;
+acc += Math.sin(31018) + Math.cos(31019) * 75;
+acc += Math.sin(31019) + Math.cos(31020) * 76;
+acc += Math.sin(31020) + Math.cos(31021) * 77;
+acc += Math.sin(31021) + Math.cos(31022) * 78;
+acc += Math.sin(31022) + Math.cos(31023) * 79;
+acc += Math.sin(31023) + Math.cos(31024) * 80;
+acc += Math.sin(31024) + Math.cos(31025) * 81;
+acc += Math.sin(31025) + Math.cos(31026) * 82;
+acc += Math.sin(31026) + Math.cos(31027) * 83;
+acc += Math.sin(31027) + Math.cos(31028) * 84;
+acc += Math.sin(31028) + Math.cos(31029) * 85;
+acc += Math.sin(31029) + Math.cos(31030) * 86;
+acc += Math.sin(31030) + Math.cos(31031) * 87;
+acc += Math.sin(31031) + Math.cos(31032) * 88;
+acc += Math.sin(31032) + Math.cos(31033) * 89;
+acc += Math.sin(31033) + Math.cos(31034) * 90;
+acc += Math.sin(31034) + Math.cos(31035) * 91;
+acc += Math.sin(31035) + Math.cos(31036) * 92;
+acc += Math.sin(31036) + Math.cos(31037) * 93;
+acc += Math.sin(31037) + Math.cos(31038) * 94;
+acc += Math.sin(31038) + Math.cos(31039) * 95;
+acc += Math.sin(31039) + Math.cos(31040) * 96;
+acc += Math.sin(31040) + Math.cos(31041) * 0;
+acc += Math.sin(31041) + Math.cos(31042) * 1;
+acc += Math.sin(31042) + Math.cos(31043) * 2;
+acc += Math.sin(31043) + Math.cos(31044) * 3;
+acc += Math.sin(31044) + Math.cos(31045) * 4;
+acc += Math.sin(31045) + Math.cos(31046) * 5;
+acc += Math.sin(31046) + Math.cos(31047) * 6;
+acc += Math.sin(31047) + Math.cos(31048) * 7;
+acc += Math.sin(31048) + Math.cos(31049) * 8;
+acc += Math.sin(31049) + Math.cos(31050) * 9;
+acc += Math.sin(31050) + Math.cos(31051) * 10;
+acc += Math.sin(31051) + Math.cos(31052) * 11;
+acc += Math.sin(31052) + Math.cos(31053) * 12;
+acc += Math.sin(31053) + Math.cos(31054) * 13;
+acc += Math.sin(31054) + Math.cos(31055) * 14;
+acc += Math.sin(31055) + Math.cos(31056) * 15;
+acc += Math.sin(31056) + Math.cos(31057) * 16;
+acc += Math.sin(31057) + Math.cos(31058) * 17;
+acc += Math.sin(31058) + Math.cos(31059) * 18;
+acc += Math.sin(31059) + Math.cos(31060) * 19;
+acc += Math.sin(31060) + Math.cos(31061) * 20;
+acc += Math.sin(31061) + Math.cos(31062) * 21;
+acc += Math.sin(31062) + Math.cos(31063) * 22;
+acc += Math.sin(31063) + Math.cos(31064) * 23;
+acc += Math.sin(31064) + Math.cos(31065) * 24;
+acc += Math.sin(31065) + Math.cos(31066) * 25;
+acc += Math.sin(31066) + Math.cos(31067) * 26;
+acc += Math.sin(31067) + Math.cos(31068) * 27;
+acc += Math.sin(31068) + Math.cos(31069) * 28;
+acc += Math.sin(31069) + Math.cos(31070) * 29;
+acc += Math.sin(31070) + Math.cos(31071) * 30;
+acc += Math.sin(31071) + Math.cos(31072) * 31;
+acc += Math.sin(31072) + Math.cos(31073) * 32;
+acc += Math.sin(31073) + Math.cos(31074) * 33;
+acc += Math.sin(31074) + Math.cos(31075) * 34;
+acc += Math.sin(31075) + Math.cos(31076) * 35;
+acc += Math.sin(31076) + Math.cos(31077) * 36;
+acc += Math.sin(31077) + Math.cos(31078) * 37;
+acc += Math.sin(31078) + Math.cos(31079) * 38;
+acc += Math.sin(31079) + Math.cos(31080) * 39;
+acc += Math.sin(31080) + Math.cos(31081) * 40;
+acc += Math.sin(31081) + Math.cos(31082) * 41;
+acc += Math.sin(31082) + Math.cos(31083) * 42;
+acc += Math.sin(31083) + Math.cos(31084) * 43;
+acc += Math.sin(31084) + Math.cos(31085) * 44;
+acc += Math.sin(31085) + Math.cos(31086) * 45;
+acc += Math.sin(31086) + Math.cos(31087) * 46;
+acc += Math.sin(31087) + Math.cos(31088) * 47;
+acc += Math.sin(31088) + Math.cos(31089) * 48;
+acc += Math.sin(31089) + Math.cos(31090) * 49;
+acc += Math.sin(31090) + Math.cos(31091) * 50;
+acc += Math.sin(31091) + Math.cos(31092) * 51;
+acc += Math.sin(31092) + Math.cos(31093) * 52;
+acc += Math.sin(31093) + Math.cos(31094) * 53;
+acc += Math.sin(31094) + Math.cos(31095) * 54;
+acc += Math.sin(31095) + Math.cos(31096) * 55;
+acc += Math.sin(31096) + Math.cos(31097) * 56;
+acc += Math.sin(31097) + Math.cos(31098) * 57;
+acc += Math.sin(31098) + Math.cos(31099) * 58;
+acc += Math.sin(31099) + Math.cos(31100) * 59;
+acc += Math.sin(31100) + Math.cos(31101) * 60;
+acc += Math.sin(31101) + Math.cos(31102) * 61;
+acc += Math.sin(31102) + Math.cos(31103) * 62;
+acc += Math.sin(31103) + Math.cos(31104) * 63;
+acc += Math.sin(31104) + Math.cos(31105) * 64;
+acc += Math.sin(31105) + Math.cos(31106) * 65;
+acc += Math.sin(31106) + Math.cos(31107) * 66;
+acc += Math.sin(31107) + Math.cos(31108) * 67;
+acc += Math.sin(31108) + Math.cos(31109) * 68;
+acc += Math.sin(31109) + Math.cos(31110) * 69;
+acc += Math.sin(31110) + Math.cos(31111) * 70;
+acc += Math.sin(31111) + Math.cos(31112) * 71;
+acc += Math.sin(31112) + Math.cos(31113) * 72;
+acc += Math.sin(31113) + Math.cos(31114) * 73;
+acc += Math.sin(31114) + Math.cos(31115) * 74;
+acc += Math.sin(31115) + Math.cos(31116) * 75;
+acc += Math.sin(31116) + Math.cos(31117) * 76;
+acc += Math.sin(31117) + Math.cos(31118) * 77;
+acc += Math.sin(31118) + Math.cos(31119) * 78;
+acc += Math.sin(31119) + Math.cos(31120) * 79;
+acc += Math.sin(31120) + Math.cos(31121) * 80;
+acc += Math.sin(31121) + Math.cos(31122) * 81;
+acc += Math.sin(31122) + Math.cos(31123) * 82;
+acc += Math.sin(31123) + Math.cos(31124) * 83;
+acc += Math.sin(31124) + Math.cos(31125) * 84;
+acc += Math.sin(31125) + Math.cos(31126) * 85;
+acc += Math.sin(31126) + Math.cos(31127) * 86;
+acc += Math.sin(31127) + Math.cos(31128) * 87;
+acc += Math.sin(31128) + Math.cos(31129) * 88;
+acc += Math.sin(31129) + Math.cos(31130) * 89;
+acc += Math.sin(31130) + Math.cos(31131) * 90;
+acc += Math.sin(31131) + Math.cos(31132) * 91;
+acc += Math.sin(31132) + Math.cos(31133) * 92;
+acc += Math.sin(31133) + Math.cos(31134) * 93;
+acc += Math.sin(31134) + Math.cos(31135) * 94;
+acc += Math.sin(31135) + Math.cos(31136) * 95;
+acc += Math.sin(31136) + Math.cos(31137) * 96;
+acc += Math.sin(31137) + Math.cos(31138) * 0;
+acc += Math.sin(31138) + Math.cos(31139) * 1;
+acc += Math.sin(31139) + Math.cos(31140) * 2;
+acc += Math.sin(31140) + Math.cos(31141) * 3;
+acc += Math.sin(31141) + Math.cos(31142) * 4;
+acc += Math.sin(31142) + Math.cos(31143) * 5;
+acc += Math.sin(31143) + Math.cos(31144) * 6;
+acc += Math.sin(31144) + Math.cos(31145) * 7;
+acc += Math.sin(31145) + Math.cos(31146) * 8;
+acc += Math.sin(31146) + Math.cos(31147) * 9;
+acc += Math.sin(31147) + Math.cos(31148) * 10;
+acc += Math.sin(31148) + Math.cos(31149) * 11;
+acc += Math.sin(31149) + Math.cos(31150) * 12;
+acc += Math.sin(31150) + Math.cos(31151) * 13;
+acc += Math.sin(31151) + Math.cos(31152) * 14;
+acc += Math.sin(31152) + Math.cos(31153) * 15;
+acc += Math.sin(31153) + Math.cos(31154) * 16;
+acc += Math.sin(31154) + Math.cos(31155) * 17;
+acc += Math.sin(31155) + Math.cos(31156) * 18;
+acc += Math.sin(31156) + Math.cos(31157) * 19;
+acc += Math.sin(31157) + Math.cos(31158) * 20;
+acc += Math.sin(31158) + Math.cos(31159) * 21;
+acc += Math.sin(31159) + Math.cos(31160) * 22;
+acc += Math.sin(31160) + Math.cos(31161) * 23;
+acc += Math.sin(31161) + Math.cos(31162) * 24;
+acc += Math.sin(31162) + Math.cos(31163) * 25;
+acc += Math.sin(31163) + Math.cos(31164) * 26;
+acc += Math.sin(31164) + Math.cos(31165) * 27;
+acc += Math.sin(31165) + Math.cos(31166) * 28;
+acc += Math.sin(31166) + Math.cos(31167) * 29;
+acc += Math.sin(31167) + Math.cos(31168) * 30;
+acc += Math.sin(31168) + Math.cos(31169) * 31;
+acc += Math.sin(31169) + Math.cos(31170) * 32;
+acc += Math.sin(31170) + Math.cos(31171) * 33;
+acc += Math.sin(31171) + Math.cos(31172) * 34;
+acc += Math.sin(31172) + Math.cos(31173) * 35;
+acc += Math.sin(31173) + Math.cos(31174) * 36;
+acc += Math.sin(31174) + Math.cos(31175) * 37;
+acc += Math.sin(31175) + Math.cos(31176) * 38;
+acc += Math.sin(31176) + Math.cos(31177) * 39;
+acc += Math.sin(31177) + Math.cos(31178) * 40;
+acc += Math.sin(31178) + Math.cos(31179) * 41;
+acc += Math.sin(31179) + Math.cos(31180) * 42;
+acc += Math.sin(31180) + Math.cos(31181) * 43;
+acc += Math.sin(31181) + Math.cos(31182) * 44;
+acc += Math.sin(31182) + Math.cos(31183) * 45;
+acc += Math.sin(31183) + Math.cos(31184) * 46;
+acc += Math.sin(31184) + Math.cos(31185) * 47;
+acc += Math.sin(31185) + Math.cos(31186) * 48;
+acc += Math.sin(31186) + Math.cos(31187) * 49;
+acc += Math.sin(31187) + Math.cos(31188) * 50;
+acc += Math.sin(31188) + Math.cos(31189) * 51;
+acc += Math.sin(31189) + Math.cos(31190) * 52;
+acc += Math.sin(31190) + Math.cos(31191) * 53;
+acc += Math.sin(31191) + Math.cos(31192) * 54;
+acc += Math.sin(31192) + Math.cos(31193) * 55;
+acc += Math.sin(31193) + Math.cos(31194) * 56;
+acc += Math.sin(31194) + Math.cos(31195) * 57;
+acc += Math.sin(31195) + Math.cos(31196) * 58;
+acc += Math.sin(31196) + Math.cos(31197) * 59;
+acc += Math.sin(31197) + Math.cos(31198) * 60;
+acc += Math.sin(31198) + Math.cos(31199) * 61;
+acc += Math.sin(31199) + Math.cos(31200) * 62;
+acc += Math.sin(31200) + Math.cos(31201) * 63;
+acc += Math.sin(31201) + Math.cos(31202) * 64;
+acc += Math.sin(31202) + Math.cos(31203) * 65;
+acc += Math.sin(31203) + Math.cos(31204) * 66;
+acc += Math.sin(31204) + Math.cos(31205) * 67;
+acc += Math.sin(31205) + Math.cos(31206) * 68;
+acc += Math.sin(31206) + Math.cos(31207) * 69;
+acc += Math.sin(31207) + Math.cos(31208) * 70;
+acc += Math.sin(31208) + Math.cos(31209) * 71;
+acc += Math.sin(31209) + Math.cos(31210) * 72;
+acc += Math.sin(31210) + Math.cos(31211) * 73;
+acc += Math.sin(31211) + Math.cos(31212) * 74;
+acc += Math.sin(31212) + Math.cos(31213) * 75;
+acc += Math.sin(31213) + Math.cos(31214) * 76;
+acc += Math.sin(31214) + Math.cos(31215) * 77;
+acc += Math.sin(31215) + Math.cos(31216) * 78;
+acc += Math.sin(31216) + Math.cos(31217) * 79;
+acc += Math.sin(31217) + Math.cos(31218) * 80;
+acc += Math.sin(31218) + Math.cos(31219) * 81;
+acc += Math.sin(31219) + Math.cos(31220) * 82;
+acc += Math.sin(31220) + Math.cos(31221) * 83;
+acc += Math.sin(31221) + Math.cos(31222) * 84;
+acc += Math.sin(31222) + Math.cos(31223) * 85;
+acc += Math.sin(31223) + Math.cos(31224) * 86;
+acc += Math.sin(31224) + Math.cos(31225) * 87;
+acc += Math.sin(31225) + Math.cos(31226) * 88;
+acc += Math.sin(31226) + Math.cos(31227) * 89;
+acc += Math.sin(31227) + Math.cos(31228) * 90;
+acc += Math.sin(31228) + Math.cos(31229) * 91;
+acc += Math.sin(31229) + Math.cos(31230) * 92;
+acc += Math.sin(31230) + Math.cos(31231) * 93;
+acc += Math.sin(31231) + Math.cos(31232) * 94;
+acc += Math.sin(31232) + Math.cos(31233) * 95;
+acc += Math.sin(31233) + Math.cos(31234) * 96;
+acc += Math.sin(31234) + Math.cos(31235) * 0;
+acc += Math.sin(31235) + Math.cos(31236) * 1;
+acc += Math.sin(31236) + Math.cos(31237) * 2;
+acc += Math.sin(31237) + Math.cos(31238) * 3;
+acc += Math.sin(31238) + Math.cos(31239) * 4;
+acc += Math.sin(31239) + Math.cos(31240) * 5;
+acc += Math.sin(31240) + Math.cos(31241) * 6;
+acc += Math.sin(31241) + Math.cos(31242) * 7;
+acc += Math.sin(31242) + Math.cos(31243) * 8;
+acc += Math.sin(31243) + Math.cos(31244) * 9;
+acc += Math.sin(31244) + Math.cos(31245) * 10;
+acc += Math.sin(31245) + Math.cos(31246) * 11;
+acc += Math.sin(31246) + Math.cos(31247) * 12;
+acc += Math.sin(31247) + Math.cos(31248) * 13;
+acc += Math.sin(31248) + Math.cos(31249) * 14;
+acc += Math.sin(31249) + Math.cos(31250) * 15;
+acc += Math.sin(31250) + Math.cos(31251) * 16;
+acc += Math.sin(31251) + Math.cos(31252) * 17;
+acc += Math.sin(31252) + Math.cos(31253) * 18;
+acc += Math.sin(31253) + Math.cos(31254) * 19;
+acc += Math.sin(31254) + Math.cos(31255) * 20;
+acc += Math.sin(31255) + Math.cos(31256) * 21;
+acc += Math.sin(31256) + Math.cos(31257) * 22;
+acc += Math.sin(31257) + Math.cos(31258) * 23;
+acc += Math.sin(31258) + Math.cos(31259) * 24;
+acc += Math.sin(31259) + Math.cos(31260) * 25;
+acc += Math.sin(31260) + Math.cos(31261) * 26;
+acc += Math.sin(31261) + Math.cos(31262) * 27;
+acc += Math.sin(31262) + Math.cos(31263) * 28;
+acc += Math.sin(31263) + Math.cos(31264) * 29;
+acc += Math.sin(31264) + Math.cos(31265) * 30;
+acc += Math.sin(31265) + Math.cos(31266) * 31;
+acc += Math.sin(31266) + Math.cos(31267) * 32;
+acc += Math.sin(31267) + Math.cos(31268) * 33;
+acc += Math.sin(31268) + Math.cos(31269) * 34;
+acc += Math.sin(31269) + Math.cos(31270) * 35;
+acc += Math.sin(31270) + Math.cos(31271) * 36;
+acc += Math.sin(31271) + Math.cos(31272) * 37;
+acc += Math.sin(31272) + Math.cos(31273) * 38;
+acc += Math.sin(31273) + Math.cos(31274) * 39;
+acc += Math.sin(31274) + Math.cos(31275) * 40;
+acc += Math.sin(31275) + Math.cos(31276) * 41;
+acc += Math.sin(31276) + Math.cos(31277) * 42;
+acc += Math.sin(31277) + Math.cos(31278) * 43;
+acc += Math.sin(31278) + Math.cos(31279) * 44;
+acc += Math.sin(31279) + Math.cos(31280) * 45;
+acc += Math.sin(31280) + Math.cos(31281) * 46;
+acc += Math.sin(31281) + Math.cos(31282) * 47;
+acc += Math.sin(31282) + Math.cos(31283) * 48;
+acc += Math.sin(31283) + Math.cos(31284) * 49;
+acc += Math.sin(31284) + Math.cos(31285) * 50;
+acc += Math.sin(31285) + Math.cos(31286) * 51;
+acc += Math.sin(31286) + Math.cos(31287) * 52;
+acc += Math.sin(31287) + Math.cos(31288) * 53;
+acc += Math.sin(31288) + Math.cos(31289) * 54;
+acc += Math.sin(31289) + Math.cos(31290) * 55;
+acc += Math.sin(31290) + Math.cos(31291) * 56;
+acc += Math.sin(31291) + Math.cos(31292) * 57;
+acc += Math.sin(31292) + Math.cos(31293) * 58;
+acc += Math.sin(31293) + Math.cos(31294) * 59;
+acc += Math.sin(31294) + Math.cos(31295) * 60;
+acc += Math.sin(31295) + Math.cos(31296) * 61;
+acc += Math.sin(31296) + Math.cos(31297) * 62;
+acc += Math.sin(31297) + Math.cos(31298) * 63;
+acc += Math.sin(31298) + Math.cos(31299) * 64;
+acc += Math.sin(31299) + Math.cos(31300) * 65;
+acc += Math.sin(31300) + Math.cos(31301) * 66;
+acc += Math.sin(31301) + Math.cos(31302) * 67;
+acc += Math.sin(31302) + Math.cos(31303) * 68;
+acc += Math.sin(31303) + Math.cos(31304) * 69;
+acc += Math.sin(31304) + Math.cos(31305) * 70;
+acc += Math.sin(31305) + Math.cos(31306) * 71;
+acc += Math.sin(31306) + Math.cos(31307) * 72;
+acc += Math.sin(31307) + Math.cos(31308) * 73;
+acc += Math.sin(31308) + Math.cos(31309) * 74;
+acc += Math.sin(31309) + Math.cos(31310) * 75;
+acc += Math.sin(31310) + Math.cos(31311) * 76;
+acc += Math.sin(31311) + Math.cos(31312) * 77;
+acc += Math.sin(31312) + Math.cos(31313) * 78;
+acc += Math.sin(31313) + Math.cos(31314) * 79;
+acc += Math.sin(31314) + Math.cos(31315) * 80;
+acc += Math.sin(31315) + Math.cos(31316) * 81;
+acc += Math.sin(31316) + Math.cos(31317) * 82;
+acc += Math.sin(31317) + Math.cos(31318) * 83;
+acc += Math.sin(31318) + Math.cos(31319) * 84;
+acc += Math.sin(31319) + Math.cos(31320) * 85;
+acc += Math.sin(31320) + Math.cos(31321) * 86;
+acc += Math.sin(31321) + Math.cos(31322) * 87;
+acc += Math.sin(31322) + Math.cos(31323) * 88;
+acc += Math.sin(31323) + Math.cos(31324) * 89;
+acc += Math.sin(31324) + Math.cos(31325) * 90;
+acc += Math.sin(31325) + Math.cos(31326) * 91;
+acc += Math.sin(31326) + Math.cos(31327) * 92;
+acc += Math.sin(31327) + Math.cos(31328) * 93;
+acc += Math.sin(31328) + Math.cos(31329) * 94;
+acc += Math.sin(31329) + Math.cos(31330) * 95;
+acc += Math.sin(31330) + Math.cos(31331) * 96;
+acc += Math.sin(31331) + Math.cos(31332) * 0;
+acc += Math.sin(31332) + Math.cos(31333) * 1;
+acc += Math.sin(31333) + Math.cos(31334) * 2;
+acc += Math.sin(31334) + Math.cos(31335) * 3;
+acc += Math.sin(31335) + Math.cos(31336) * 4;
+acc += Math.sin(31336) + Math.cos(31337) * 5;
+acc += Math.sin(31337) + Math.cos(31338) * 6;
+acc += Math.sin(31338) + Math.cos(31339) * 7;
+acc += Math.sin(31339) + Math.cos(31340) * 8;
+acc += Math.sin(31340) + Math.cos(31341) * 9;
+acc += Math.sin(31341) + Math.cos(31342) * 10;
+acc += Math.sin(31342) + Math.cos(31343) * 11;
+acc += Math.sin(31343) + Math.cos(31344) * 12;
+acc += Math.sin(31344) + Math.cos(31345) * 13;
+acc += Math.sin(31345) + Math.cos(31346) * 14;
+acc += Math.sin(31346) + Math.cos(31347) * 15;
+acc += Math.sin(31347) + Math.cos(31348) * 16;
+acc += Math.sin(31348) + Math.cos(31349) * 17;
+acc += Math.sin(31349) + Math.cos(31350) * 18;
+acc += Math.sin(31350) + Math.cos(31351) * 19;
+acc += Math.sin(31351) + Math.cos(31352) * 20;
+acc += Math.sin(31352) + Math.cos(31353) * 21;
+acc += Math.sin(31353) + Math.cos(31354) * 22;
+acc += Math.sin(31354) + Math.cos(31355) * 23;
+acc += Math.sin(31355) + Math.cos(31356) * 24;
+acc += Math.sin(31356) + Math.cos(31357) * 25;
+acc += Math.sin(31357) + Math.cos(31358) * 26;
+acc += Math.sin(31358) + Math.cos(31359) * 27;
+acc += Math.sin(31359) + Math.cos(31360) * 28;
+acc += Math.sin(31360) + Math.cos(31361) * 29;
+acc += Math.sin(31361) + Math.cos(31362) * 30;
+acc += Math.sin(31362) + Math.cos(31363) * 31;
+acc += Math.sin(31363) + Math.cos(31364) * 32;
+acc += Math.sin(31364) + Math.cos(31365) * 33;
+acc += Math.sin(31365) + Math.cos(31366) * 34;
+acc += Math.sin(31366) + Math.cos(31367) * 35;
+acc += Math.sin(31367) + Math.cos(31368) * 36;
+acc += Math.sin(31368) + Math.cos(31369) * 37;
+acc += Math.sin(31369) + Math.cos(31370) * 38;
+acc += Math.sin(31370) + Math.cos(31371) * 39;
+acc += Math.sin(31371) + Math.cos(31372) * 40;
+acc += Math.sin(31372) + Math.cos(31373) * 41;
+acc += Math.sin(31373) + Math.cos(31374) * 42;
+acc += Math.sin(31374) + Math.cos(31375) * 43;
+acc += Math.sin(31375) + Math.cos(31376) * 44;
+acc += Math.sin(31376) + Math.cos(31377) * 45;
+acc += Math.sin(31377) + Math.cos(31378) * 46;
+acc += Math.sin(31378) + Math.cos(31379) * 47;
+acc += Math.sin(31379) + Math.cos(31380) * 48;
+acc += Math.sin(31380) + Math.cos(31381) * 49;
+acc += Math.sin(31381) + Math.cos(31382) * 50;
+acc += Math.sin(31382) + Math.cos(31383) * 51;
+acc += Math.sin(31383) + Math.cos(31384) * 52;
+acc += Math.sin(31384) + Math.cos(31385) * 53;
+acc += Math.sin(31385) + Math.cos(31386) * 54;
+acc += Math.sin(31386) + Math.cos(31387) * 55;
+acc += Math.sin(31387) + Math.cos(31388) * 56;
+acc += Math.sin(31388) + Math.cos(31389) * 57;
+acc += Math.sin(31389) + Math.cos(31390) * 58;
+acc += Math.sin(31390) + Math.cos(31391) * 59;
+acc += Math.sin(31391) + Math.cos(31392) * 60;
+acc += Math.sin(31392) + Math.cos(31393) * 61;
+acc += Math.sin(31393) + Math.cos(31394) * 62;
+acc += Math.sin(31394) + Math.cos(31395) * 63;
+acc += Math.sin(31395) + Math.cos(31396) * 64;
+acc += Math.sin(31396) + Math.cos(31397) * 65;
+acc += Math.sin(31397) + Math.cos(31398) * 66;
+acc += Math.sin(31398) + Math.cos(31399) * 67;
+acc += Math.sin(31399) + Math.cos(31400) * 68;
+acc += Math.sin(31400) + Math.cos(31401) * 69;
+acc += Math.sin(31401) + Math.cos(31402) * 70;
+acc += Math.sin(31402) + Math.cos(31403) * 71;
+acc += Math.sin(31403) + Math.cos(31404) * 72;
+acc += Math.sin(31404) + Math.cos(31405) * 73;
+acc += Math.sin(31405) + Math.cos(31406) * 74;
+acc += Math.sin(31406) + Math.cos(31407) * 75;
+acc += Math.sin(31407) + Math.cos(31408) * 76;
+acc += Math.sin(31408) + Math.cos(31409) * 77;
+acc += Math.sin(31409) + Math.cos(31410) * 78;
+acc += Math.sin(31410) + Math.cos(31411) * 79;
+acc += Math.sin(31411) + Math.cos(31412) * 80;
+acc += Math.sin(31412) + Math.cos(31413) * 81;
+acc += Math.sin(31413) + Math.cos(31414) * 82;
+acc += Math.sin(31414) + Math.cos(31415) * 83;
+acc += Math.sin(31415) + Math.cos(31416) * 84;
+acc += Math.sin(31416) + Math.cos(31417) * 85;
+acc += Math.sin(31417) + Math.cos(31418) * 86;
+acc += Math.sin(31418) + Math.cos(31419) * 87;
+acc += Math.sin(31419) + Math.cos(31420) * 88;
+acc += Math.sin(31420) + Math.cos(31421) * 89;
+acc += Math.sin(31421) + Math.cos(31422) * 90;
+acc += Math.sin(31422) + Math.cos(31423) * 91;
+acc += Math.sin(31423) + Math.cos(31424) * 92;
+acc += Math.sin(31424) + Math.cos(31425) * 93;
+acc += Math.sin(31425) + Math.cos(31426) * 94;
+acc += Math.sin(31426) + Math.cos(31427) * 95;
+acc += Math.sin(31427) + Math.cos(31428) * 96;
+acc += Math.sin(31428) + Math.cos(31429) * 0;
+acc += Math.sin(31429) + Math.cos(31430) * 1;
+acc += Math.sin(31430) + Math.cos(31431) * 2;
+acc += Math.sin(31431) + Math.cos(31432) * 3;
+acc += Math.sin(31432) + Math.cos(31433) * 4;
+acc += Math.sin(31433) + Math.cos(31434) * 5;
+acc += Math.sin(31434) + Math.cos(31435) * 6;
+acc += Math.sin(31435) + Math.cos(31436) * 7;
+acc += Math.sin(31436) + Math.cos(31437) * 8;
+acc += Math.sin(31437) + Math.cos(31438) * 9;
+acc += Math.sin(31438) + Math.cos(31439) * 10;
+acc += Math.sin(31439) + Math.cos(31440) * 11;
+acc += Math.sin(31440) + Math.cos(31441) * 12;
+acc += Math.sin(31441) + Math.cos(31442) * 13;
+acc += Math.sin(31442) + Math.cos(31443) * 14;
+acc += Math.sin(31443) + Math.cos(31444) * 15;
+acc += Math.sin(31444) + Math.cos(31445) * 16;
+acc += Math.sin(31445) + Math.cos(31446) * 17;
+acc += Math.sin(31446) + Math.cos(31447) * 18;
+acc += Math.sin(31447) + Math.cos(31448) * 19;
+acc += Math.sin(31448) + Math.cos(31449) * 20;
+acc += Math.sin(31449) + Math.cos(31450) * 21;
+acc += Math.sin(31450) + Math.cos(31451) * 22;
+acc += Math.sin(31451) + Math.cos(31452) * 23;
+acc += Math.sin(31452) + Math.cos(31453) * 24;
+acc += Math.sin(31453) + Math.cos(31454) * 25;
+acc += Math.sin(31454) + Math.cos(31455) * 26;
+acc += Math.sin(31455) + Math.cos(31456) * 27;
+acc += Math.sin(31456) + Math.cos(31457) * 28;
+acc += Math.sin(31457) + Math.cos(31458) * 29;
+acc += Math.sin(31458) + Math.cos(31459) * 30;
+acc += Math.sin(31459) + Math.cos(31460) * 31;
+acc += Math.sin(31460) + Math.cos(31461) * 32;
+acc += Math.sin(31461) + Math.cos(31462) * 33;
+acc += Math.sin(31462) + Math.cos(31463) * 34;
+acc += Math.sin(31463) + Math.cos(31464) * 35;
+acc += Math.sin(31464) + Math.cos(31465) * 36;
+acc += Math.sin(31465) + Math.cos(31466) * 37;
+acc += Math.sin(31466) + Math.cos(31467) * 38;
+acc += Math.sin(31467) + Math.cos(31468) * 39;
+acc += Math.sin(31468) + Math.cos(31469) * 40;
+acc += Math.sin(31469) + Math.cos(31470) * 41;
+acc += Math.sin(31470) + Math.cos(31471) * 42;
+acc += Math.sin(31471) + Math.cos(31472) * 43;
+acc += Math.sin(31472) + Math.cos(31473) * 44;
+acc += Math.sin(31473) + Math.cos(31474) * 45;
+acc += Math.sin(31474) + Math.cos(31475) * 46;
+acc += Math.sin(31475) + Math.cos(31476) * 47;
+acc += Math.sin(31476) + Math.cos(31477) * 48;
+acc += Math.sin(31477) + Math.cos(31478) * 49;
+acc += Math.sin(31478) + Math.cos(31479) * 50;
+acc += Math.sin(31479) + Math.cos(31480) * 51;
+acc += Math.sin(31480) + Math.cos(31481) * 52;
+acc += Math.sin(31481) + Math.cos(31482) * 53;
+acc += Math.sin(31482) + Math.cos(31483) * 54;
+acc += Math.sin(31483) + Math.cos(31484) * 55;
+acc += Math.sin(31484) + Math.cos(31485) * 56;
+acc += Math.sin(31485) + Math.cos(31486) * 57;
+acc += Math.sin(31486) + Math.cos(31487) * 58;
+acc += Math.sin(31487) + Math.cos(31488) * 59;
+acc += Math.sin(31488) + Math.cos(31489) * 60;
+acc += Math.sin(31489) + Math.cos(31490) * 61;
+acc += Math.sin(31490) + Math.cos(31491) * 62;
+acc += Math.sin(31491) + Math.cos(31492) * 63;
+acc += Math.sin(31492) + Math.cos(31493) * 64;
+acc += Math.sin(31493) + Math.cos(31494) * 65;
+acc += Math.sin(31494) + Math.cos(31495) * 66;
+acc += Math.sin(31495) + Math.cos(31496) * 67;
+acc += Math.sin(31496) + Math.cos(31497) * 68;
+acc += Math.sin(31497) + Math.cos(31498) * 69;
+acc += Math.sin(31498) + Math.cos(31499) * 70;
+acc += Math.sin(31499) + Math.cos(31500) * 71;
+acc += Math.sin(31500) + Math.cos(31501) * 72;
+acc += Math.sin(31501) + Math.cos(31502) * 73;
+acc += Math.sin(31502) + Math.cos(31503) * 74;
+acc += Math.sin(31503) + Math.cos(31504) * 75;
+acc += Math.sin(31504) + Math.cos(31505) * 76;
+acc += Math.sin(31505) + Math.cos(31506) * 77;
+acc += Math.sin(31506) + Math.cos(31507) * 78;
+acc += Math.sin(31507) + Math.cos(31508) * 79;
+acc += Math.sin(31508) + Math.cos(31509) * 80;
+acc += Math.sin(31509) + Math.cos(31510) * 81;
+acc += Math.sin(31510) + Math.cos(31511) * 82;
+acc += Math.sin(31511) + Math.cos(31512) * 83;
+acc += Math.sin(31512) + Math.cos(31513) * 84;
+acc += Math.sin(31513) + Math.cos(31514) * 85;
+acc += Math.sin(31514) + Math.cos(31515) * 86;
+acc += Math.sin(31515) + Math.cos(31516) * 87;
+acc += Math.sin(31516) + Math.cos(31517) * 88;
+acc += Math.sin(31517) + Math.cos(31518) * 89;
+acc += Math.sin(31518) + Math.cos(31519) * 90;
+acc += Math.sin(31519) + Math.cos(31520) * 91;
+acc += Math.sin(31520) + Math.cos(31521) * 92;
+acc += Math.sin(31521) + Math.cos(31522) * 93;
+acc += Math.sin(31522) + Math.cos(31523) * 94;
+acc += Math.sin(31523) + Math.cos(31524) * 95;
+acc += Math.sin(31524) + Math.cos(31525) * 96;
+acc += Math.sin(31525) + Math.cos(31526) * 0;
+acc += Math.sin(31526) + Math.cos(31527) * 1;
+acc += Math.sin(31527) + Math.cos(31528) * 2;
+acc += Math.sin(31528) + Math.cos(31529) * 3;
+acc += Math.sin(31529) + Math.cos(31530) * 4;
+acc += Math.sin(31530) + Math.cos(31531) * 5;
+acc += Math.sin(31531) + Math.cos(31532) * 6;
+acc += Math.sin(31532) + Math.cos(31533) * 7;
+acc += Math.sin(31533) + Math.cos(31534) * 8;
+acc += Math.sin(31534) + Math.cos(31535) * 9;
+acc += Math.sin(31535) + Math.cos(31536) * 10;
+acc += Math.sin(31536) + Math.cos(31537) * 11;
+acc += Math.sin(31537) + Math.cos(31538) * 12;
+acc += Math.sin(31538) + Math.cos(31539) * 13;
+acc += Math.sin(31539) + Math.cos(31540) * 14;
+acc += Math.sin(31540) + Math.cos(31541) * 15;
+acc += Math.sin(31541) + Math.cos(31542) * 16;
+acc += Math.sin(31542) + Math.cos(31543) * 17;
+acc += Math.sin(31543) + Math.cos(31544) * 18;
+acc += Math.sin(31544) + Math.cos(31545) * 19;
+acc += Math.sin(31545) + Math.cos(31546) * 20;
+acc += Math.sin(31546) + Math.cos(31547) * 21;
+acc += Math.sin(31547) + Math.cos(31548) * 22;
+acc += Math.sin(31548) + Math.cos(31549) * 23;
+acc += Math.sin(31549) + Math.cos(31550) * 24;
+acc += Math.sin(31550) + Math.cos(31551) * 25;
+acc += Math.sin(31551) + Math.cos(31552) * 26;
+acc += Math.sin(31552) + Math.cos(31553) * 27;
+acc += Math.sin(31553) + Math.cos(31554) * 28;
+acc += Math.sin(31554) + Math.cos(31555) * 29;
+acc += Math.sin(31555) + Math.cos(31556) * 30;
+acc += Math.sin(31556) + Math.cos(31557) * 31;
+acc += Math.sin(31557) + Math.cos(31558) * 32;
+acc += Math.sin(31558) + Math.cos(31559) * 33;
+acc += Math.sin(31559) + Math.cos(31560) * 34;
+acc += Math.sin(31560) + Math.cos(31561) * 35;
+acc += Math.sin(31561) + Math.cos(31562) * 36;
+acc += Math.sin(31562) + Math.cos(31563) * 37;
+acc += Math.sin(31563) + Math.cos(31564) * 38;
+acc += Math.sin(31564) + Math.cos(31565) * 39;
+acc += Math.sin(31565) + Math.cos(31566) * 40;
+acc += Math.sin(31566) + Math.cos(31567) * 41;
+acc += Math.sin(31567) + Math.cos(31568) * 42;
+acc += Math.sin(31568) + Math.cos(31569) * 43;
+acc += Math.sin(31569) + Math.cos(31570) * 44;
+acc += Math.sin(31570) + Math.cos(31571) * 45;
+acc += Math.sin(31571) + Math.cos(31572) * 46;
+acc += Math.sin(31572) + Math.cos(31573) * 47;
+acc += Math.sin(31573) + Math.cos(31574) * 48;
+acc += Math.sin(31574) + Math.cos(31575) * 49;
+acc += Math.sin(31575) + Math.cos(31576) * 50;
+acc += Math.sin(31576) + Math.cos(31577) * 51;
+acc += Math.sin(31577) + Math.cos(31578) * 52;
+acc += Math.sin(31578) + Math.cos(31579) * 53;
+acc += Math.sin(31579) + Math.cos(31580) * 54;
+acc += Math.sin(31580) + Math.cos(31581) * 55;
+acc += Math.sin(31581) + Math.cos(31582) * 56;
+acc += Math.sin(31582) + Math.cos(31583) * 57;
+acc += Math.sin(31583) + Math.cos(31584) * 58;
+acc += Math.sin(31584) + Math.cos(31585) * 59;
+acc += Math.sin(31585) + Math.cos(31586) * 60;
+acc += Math.sin(31586) + Math.cos(31587) * 61;
+acc += Math.sin(31587) + Math.cos(31588) * 62;
+acc += Math.sin(31588) + Math.cos(31589) * 63;
+acc += Math.sin(31589) + Math.cos(31590) * 64;
+acc += Math.sin(31590) + Math.cos(31591) * 65;
+acc += Math.sin(31591) + Math.cos(31592) * 66;
+acc += Math.sin(31592) + Math.cos(31593) * 67;
+acc += Math.sin(31593) + Math.cos(31594) * 68;
+acc += Math.sin(31594) + Math.cos(31595) * 69;
+acc += Math.sin(31595) + Math.cos(31596) * 70;
+acc += Math.sin(31596) + Math.cos(31597) * 71;
+acc += Math.sin(31597) + Math.cos(31598) * 72;
+acc += Math.sin(31598) + Math.cos(31599) * 73;
+acc += Math.sin(31599) + Math.cos(31600) * 74;
+acc += Math.sin(31600) + Math.cos(31601) * 75;
+acc += Math.sin(31601) + Math.cos(31602) * 76;
+acc += Math.sin(31602) + Math.cos(31603) * 77;
+acc += Math.sin(31603) + Math.cos(31604) * 78;
+acc += Math.sin(31604) + Math.cos(31605) * 79;
+acc += Math.sin(31605) + Math.cos(31606) * 80;
+acc += Math.sin(31606) + Math.cos(31607) * 81;
+acc += Math.sin(31607) + Math.cos(31608) * 82;
+acc += Math.sin(31608) + Math.cos(31609) * 83;
+acc += Math.sin(31609) + Math.cos(31610) * 84;
+acc += Math.sin(31610) + Math.cos(31611) * 85;
+acc += Math.sin(31611) + Math.cos(31612) * 86;
+acc += Math.sin(31612) + Math.cos(31613) * 87;
+acc += Math.sin(31613) + Math.cos(31614) * 88;
+acc += Math.sin(31614) + Math.cos(31615) * 89;
+acc += Math.sin(31615) + Math.cos(31616) * 90;
+acc += Math.sin(31616) + Math.cos(31617) * 91;
+acc += Math.sin(31617) + Math.cos(31618) * 92;
+acc += Math.sin(31618) + Math.cos(31619) * 93;
+acc += Math.sin(31619) + Math.cos(31620) * 94;
+acc += Math.sin(31620) + Math.cos(31621) * 95;
+acc += Math.sin(31621) + Math.cos(31622) * 96;
+acc += Math.sin(31622) + Math.cos(31623) * 0;
+acc += Math.sin(31623) + Math.cos(31624) * 1;
+acc += Math.sin(31624) + Math.cos(31625) * 2;
+acc += Math.sin(31625) + Math.cos(31626) * 3;
+acc += Math.sin(31626) + Math.cos(31627) * 4;
+acc += Math.sin(31627) + Math.cos(31628) * 5;
+acc += Math.sin(31628) + Math.cos(31629) * 6;
+acc += Math.sin(31629) + Math.cos(31630) * 7;
+acc += Math.sin(31630) + Math.cos(31631) * 8;
+acc += Math.sin(31631) + Math.cos(31632) * 9;
+acc += Math.sin(31632) + Math.cos(31633) * 10;
+acc += Math.sin(31633) + Math.cos(31634) * 11;
+acc += Math.sin(31634) + Math.cos(31635) * 12;
+acc += Math.sin(31635) + Math.cos(31636) * 13;
+acc += Math.sin(31636) + Math.cos(31637) * 14;
+acc += Math.sin(31637) + Math.cos(31638) * 15;
+acc += Math.sin(31638) + Math.cos(31639) * 16;
+acc += Math.sin(31639) + Math.cos(31640) * 17;
+acc += Math.sin(31640) + Math.cos(31641) * 18;
+acc += Math.sin(31641) + Math.cos(31642) * 19;
+acc += Math.sin(31642) + Math.cos(31643) * 20;
+acc += Math.sin(31643) + Math.cos(31644) * 21;
+acc += Math.sin(31644) + Math.cos(31645) * 22;
+acc += Math.sin(31645) + Math.cos(31646) * 23;
+acc += Math.sin(31646) + Math.cos(31647) * 24;
+acc += Math.sin(31647) + Math.cos(31648) * 25;
+acc += Math.sin(31648) + Math.cos(31649) * 26;
+acc += Math.sin(31649) + Math.cos(31650) * 27;
+acc += Math.sin(31650) + Math.cos(31651) * 28;
+acc += Math.sin(31651) + Math.cos(31652) * 29;
+acc += Math.sin(31652) + Math.cos(31653) * 30;
+acc += Math.sin(31653) + Math.cos(31654) * 31;
+acc += Math.sin(31654) + Math.cos(31655) * 32;
+acc += Math.sin(31655) + Math.cos(31656) * 33;
+acc += Math.sin(31656) + Math.cos(31657) * 34;
+acc += Math.sin(31657) + Math.cos(31658) * 35;
+acc += Math.sin(31658) + Math.cos(31659) * 36;
+acc += Math.sin(31659) + Math.cos(31660) * 37;
+acc += Math.sin(31660) + Math.cos(31661) * 38;
+acc += Math.sin(31661) + Math.cos(31662) * 39;
+acc += Math.sin(31662) + Math.cos(31663) * 40;
+acc += Math.sin(31663) + Math.cos(31664) * 41;
+acc += Math.sin(31664) + Math.cos(31665) * 42;
+acc += Math.sin(31665) + Math.cos(31666) * 43;
+acc += Math.sin(31666) + Math.cos(31667) * 44;
+acc += Math.sin(31667) + Math.cos(31668) * 45;
+acc += Math.sin(31668) + Math.cos(31669) * 46;
+acc += Math.sin(31669) + Math.cos(31670) * 47;
+acc += Math.sin(31670) + Math.cos(31671) * 48;
+acc += Math.sin(31671) + Math.cos(31672) * 49;
+acc += Math.sin(31672) + Math.cos(31673) * 50;
+acc += Math.sin(31673) + Math.cos(31674) * 51;
+acc += Math.sin(31674) + Math.cos(31675) * 52;
+acc += Math.sin(31675) + Math.cos(31676) * 53;
+acc += Math.sin(31676) + Math.cos(31677) * 54;
+acc += Math.sin(31677) + Math.cos(31678) * 55;
+acc += Math.sin(31678) + Math.cos(31679) * 56;
+acc += Math.sin(31679) + Math.cos(31680) * 57;
+acc += Math.sin(31680) + Math.cos(31681) * 58;
+acc += Math.sin(31681) + Math.cos(31682) * 59;
+acc += Math.sin(31682) + Math.cos(31683) * 60;
+acc += Math.sin(31683) + Math.cos(31684) * 61;
+acc += Math.sin(31684) + Math.cos(31685) * 62;
+acc += Math.sin(31685) + Math.cos(31686) * 63;
+acc += Math.sin(31686) + Math.cos(31687) * 64;
+acc += Math.sin(31687) + Math.cos(31688) * 65;
+acc += Math.sin(31688) + Math.cos(31689) * 66;
+acc += Math.sin(31689) + Math.cos(31690) * 67;
+acc += Math.sin(31690) + Math.cos(31691) * 68;
+acc += Math.sin(31691) + Math.cos(31692) * 69;
+acc += Math.sin(31692) + Math.cos(31693) * 70;
+acc += Math.sin(31693) + Math.cos(31694) * 71;
+acc += Math.sin(31694) + Math.cos(31695) * 72;
+acc += Math.sin(31695) + Math.cos(31696) * 73;
+acc += Math.sin(31696) + Math.cos(31697) * 74;
+acc += Math.sin(31697) + Math.cos(31698) * 75;
+acc += Math.sin(31698) + Math.cos(31699) * 76;
+acc += Math.sin(31699) + Math.cos(31700) * 77;
+acc += Math.sin(31700) + Math.cos(31701) * 78;
+acc += Math.sin(31701) + Math.cos(31702) * 79;
+acc += Math.sin(31702) + Math.cos(31703) * 80;
+acc += Math.sin(31703) + Math.cos(31704) * 81;
+acc += Math.sin(31704) + Math.cos(31705) * 82;
+acc += Math.sin(31705) + Math.cos(31706) * 83;
+acc += Math.sin(31706) + Math.cos(31707) * 84;
+acc += Math.sin(31707) + Math.cos(31708) * 85;
+acc += Math.sin(31708) + Math.cos(31709) * 86;
+acc += Math.sin(31709) + Math.cos(31710) * 87;
+acc += Math.sin(31710) + Math.cos(31711) * 88;
+acc += Math.sin(31711) + Math.cos(31712) * 89;
+acc += Math.sin(31712) + Math.cos(31713) * 90;
+acc += Math.sin(31713) + Math.cos(31714) * 91;
+acc += Math.sin(31714) + Math.cos(31715) * 92;
+acc += Math.sin(31715) + Math.cos(31716) * 93;
+acc += Math.sin(31716) + Math.cos(31717) * 94;
+acc += Math.sin(31717) + Math.cos(31718) * 95;
+acc += Math.sin(31718) + Math.cos(31719) * 96;
+acc += Math.sin(31719) + Math.cos(31720) * 0;
+acc += Math.sin(31720) + Math.cos(31721) * 1;
+acc += Math.sin(31721) + Math.cos(31722) * 2;
+acc += Math.sin(31722) + Math.cos(31723) * 3;
+acc += Math.sin(31723) + Math.cos(31724) * 4;
+acc += Math.sin(31724) + Math.cos(31725) * 5;
+acc += Math.sin(31725) + Math.cos(31726) * 6;
+acc += Math.sin(31726) + Math.cos(31727) * 7;
+acc += Math.sin(31727) + Math.cos(31728) * 8;
+acc += Math.sin(31728) + Math.cos(31729) * 9;
+acc += Math.sin(31729) + Math.cos(31730) * 10;
+acc += Math.sin(31730) + Math.cos(31731) * 11;
+acc += Math.sin(31731) + Math.cos(31732) * 12;
+acc += Math.sin(31732) + Math.cos(31733) * 13;
+acc += Math.sin(31733) + Math.cos(31734) * 14;
+acc += Math.sin(31734) + Math.cos(31735) * 15;
+acc += Math.sin(31735) + Math.cos(31736) * 16;
+acc += Math.sin(31736) + Math.cos(31737) * 17;
+acc += Math.sin(31737) + Math.cos(31738) * 18;
+acc += Math.sin(31738) + Math.cos(31739) * 19;
+acc += Math.sin(31739) + Math.cos(31740) * 20;
+acc += Math.sin(31740) + Math.cos(31741) * 21;
+acc += Math.sin(31741) + Math.cos(31742) * 22;
+acc += Math.sin(31742) + Math.cos(31743) * 23;
+acc += Math.sin(31743) + Math.cos(31744) * 24;
+acc += Math.sin(31744) + Math.cos(31745) * 25;
+acc += Math.sin(31745) + Math.cos(31746) * 26;
+acc += Math.sin(31746) + Math.cos(31747) * 27;
+acc += Math.sin(31747) + Math.cos(31748) * 28;
+acc += Math.sin(31748) + Math.cos(31749) * 29;
+acc += Math.sin(31749) + Math.cos(31750) * 30;
+acc += Math.sin(31750) + Math.cos(31751) * 31;
+acc += Math.sin(31751) + Math.cos(31752) * 32;
+acc += Math.sin(31752) + Math.cos(31753) * 33;
+acc += Math.sin(31753) + Math.cos(31754) * 34;
+acc += Math.sin(31754) + Math.cos(31755) * 35;
+acc += Math.sin(31755) + Math.cos(31756) * 36;
+acc += Math.sin(31756) + Math.cos(31757) * 37;
+acc += Math.sin(31757) + Math.cos(31758) * 38;
+acc += Math.sin(31758) + Math.cos(31759) * 39;
+acc += Math.sin(31759) + Math.cos(31760) * 40;
+acc += Math.sin(31760) + Math.cos(31761) * 41;
+acc += Math.sin(31761) + Math.cos(31762) * 42;
+acc += Math.sin(31762) + Math.cos(31763) * 43;
+acc += Math.sin(31763) + Math.cos(31764) * 44;
+acc += Math.sin(31764) + Math.cos(31765) * 45;
+acc += Math.sin(31765) + Math.cos(31766) * 46;
+acc += Math.sin(31766) + Math.cos(31767) * 47;
+acc += Math.sin(31767) + Math.cos(31768) * 48;
+acc += Math.sin(31768) + Math.cos(31769) * 49;
+acc += Math.sin(31769) + Math.cos(31770) * 50;
+acc += Math.sin(31770) + Math.cos(31771) * 51;
+acc += Math.sin(31771) + Math.cos(31772) * 52;
+acc += Math.sin(31772) + Math.cos(31773) * 53;
+acc += Math.sin(31773) + Math.cos(31774) * 54;
+acc += Math.sin(31774) + Math.cos(31775) * 55;
+acc += Math.sin(31775) + Math.cos(31776) * 56;
+acc += Math.sin(31776) + Math.cos(31777) * 57;
+acc += Math.sin(31777) + Math.cos(31778) * 58;
+acc += Math.sin(31778) + Math.cos(31779) * 59;
+acc += Math.sin(31779) + Math.cos(31780) * 60;
+acc += Math.sin(31780) + Math.cos(31781) * 61;
+acc += Math.sin(31781) + Math.cos(31782) * 62;
+acc += Math.sin(31782) + Math.cos(31783) * 63;
+acc += Math.sin(31783) + Math.cos(31784) * 64;
+acc += Math.sin(31784) + Math.cos(31785) * 65;
+acc += Math.sin(31785) + Math.cos(31786) * 66;
+acc += Math.sin(31786) + Math.cos(31787) * 67;
+acc += Math.sin(31787) + Math.cos(31788) * 68;
+acc += Math.sin(31788) + Math.cos(31789) * 69;
+acc += Math.sin(31789) + Math.cos(31790) * 70;
+acc += Math.sin(31790) + Math.cos(31791) * 71;
+acc += Math.sin(31791) + Math.cos(31792) * 72;
+acc += Math.sin(31792) + Math.cos(31793) * 73;
+acc += Math.sin(31793) + Math.cos(31794) * 74;
+acc += Math.sin(31794) + Math.cos(31795) * 75;
+acc += Math.sin(31795) + Math.cos(31796) * 76;
+acc += Math.sin(31796) + Math.cos(31797) * 77;
+acc += Math.sin(31797) + Math.cos(31798) * 78;
+acc += Math.sin(31798) + Math.cos(31799) * 79;
+acc += Math.sin(31799) + Math.cos(31800) * 80;
+acc += Math.sin(31800) + Math.cos(31801) * 81;
+acc += Math.sin(31801) + Math.cos(31802) * 82;
+acc += Math.sin(31802) + Math.cos(31803) * 83;
+acc += Math.sin(31803) + Math.cos(31804) * 84;
+acc += Math.sin(31804) + Math.cos(31805) * 85;
+acc += Math.sin(31805) + Math.cos(31806) * 86;
+acc += Math.sin(31806) + Math.cos(31807) * 87;
+acc += Math.sin(31807) + Math.cos(31808) * 88;
+acc += Math.sin(31808) + Math.cos(31809) * 89;
+acc += Math.sin(31809) + Math.cos(31810) * 90;
+acc += Math.sin(31810) + Math.cos(31811) * 91;
+acc += Math.sin(31811) + Math.cos(31812) * 92;
+acc += Math.sin(31812) + Math.cos(31813) * 93;
+acc += Math.sin(31813) + Math.cos(31814) * 94;
+acc += Math.sin(31814) + Math.cos(31815) * 95;
+acc += Math.sin(31815) + Math.cos(31816) * 96;
+acc += Math.sin(31816) + Math.cos(31817) * 0;
+acc += Math.sin(31817) + Math.cos(31818) * 1;
+acc += Math.sin(31818) + Math.cos(31819) * 2;
+acc += Math.sin(31819) + Math.cos(31820) * 3;
+acc += Math.sin(31820) + Math.cos(31821) * 4;
+acc += Math.sin(31821) + Math.cos(31822) * 5;
+acc += Math.sin(31822) + Math.cos(31823) * 6;
+acc += Math.sin(31823) + Math.cos(31824) * 7;
+acc += Math.sin(31824) + Math.cos(31825) * 8;
+acc += Math.sin(31825) + Math.cos(31826) * 9;
+acc += Math.sin(31826) + Math.cos(31827) * 10;
+acc += Math.sin(31827) + Math.cos(31828) * 11;
+acc += Math.sin(31828) + Math.cos(31829) * 12;
+acc += Math.sin(31829) + Math.cos(31830) * 13;
+acc += Math.sin(31830) + Math.cos(31831) * 14;
+acc += Math.sin(31831) + Math.cos(31832) * 15;
+acc += Math.sin(31832) + Math.cos(31833) * 16;
+acc += Math.sin(31833) + Math.cos(31834) * 17;
+acc += Math.sin(31834) + Math.cos(31835) * 18;
+acc += Math.sin(31835) + Math.cos(31836) * 19;
+acc += Math.sin(31836) + Math.cos(31837) * 20;
+acc += Math.sin(31837) + Math.cos(31838) * 21;
+acc += Math.sin(31838) + Math.cos(31839) * 22;
+acc += Math.sin(31839) + Math.cos(31840) * 23;
+acc += Math.sin(31840) + Math.cos(31841) * 24;
+acc += Math.sin(31841) + Math.cos(31842) * 25;
+acc += Math.sin(31842) + Math.cos(31843) * 26;
+acc += Math.sin(31843) + Math.cos(31844) * 27;
+acc += Math.sin(31844) + Math.cos(31845) * 28;
+acc += Math.sin(31845) + Math.cos(31846) * 29;
+acc += Math.sin(31846) + Math.cos(31847) * 30;
+acc += Math.sin(31847) + Math.cos(31848) * 31;
+acc += Math.sin(31848) + Math.cos(31849) * 32;
+acc += Math.sin(31849) + Math.cos(31850) * 33;
+acc += Math.sin(31850) + Math.cos(31851) * 34;
+acc += Math.sin(31851) + Math.cos(31852) * 35;
+acc += Math.sin(31852) + Math.cos(31853) * 36;
+acc += Math.sin(31853) + Math.cos(31854) * 37;
+acc += Math.sin(31854) + Math.cos(31855) * 38;
+acc += Math.sin(31855) + Math.cos(31856) * 39;
+acc += Math.sin(31856) + Math.cos(31857) * 40;
+acc += Math.sin(31857) + Math.cos(31858) * 41;
+acc += Math.sin(31858) + Math.cos(31859) * 42;
+acc += Math.sin(31859) + Math.cos(31860) * 43;
+acc += Math.sin(31860) + Math.cos(31861) * 44;
+acc += Math.sin(31861) + Math.cos(31862) * 45;
+acc += Math.sin(31862) + Math.cos(31863) * 46;
+acc += Math.sin(31863) + Math.cos(31864) * 47;
+acc += Math.sin(31864) + Math.cos(31865) * 48;
+acc += Math.sin(31865) + Math.cos(31866) * 49;
+acc += Math.sin(31866) + Math.cos(31867) * 50;
+acc += Math.sin(31867) + Math.cos(31868) * 51;
+acc += Math.sin(31868) + Math.cos(31869) * 52;
+acc += Math.sin(31869) + Math.cos(31870) * 53;
+acc += Math.sin(31870) + Math.cos(31871) * 54;
+acc += Math.sin(31871) + Math.cos(31872) * 55;
+acc += Math.sin(31872) + Math.cos(31873) * 56;
+acc += Math.sin(31873) + Math.cos(31874) * 57;
+acc += Math.sin(31874) + Math.cos(31875) * 58;
+acc += Math.sin(31875) + Math.cos(31876) * 59;
+acc += Math.sin(31876) + Math.cos(31877) * 60;
+acc += Math.sin(31877) + Math.cos(31878) * 61;
+acc += Math.sin(31878) + Math.cos(31879) * 62;
+acc += Math.sin(31879) + Math.cos(31880) * 63;
+acc += Math.sin(31880) + Math.cos(31881) * 64;
+acc += Math.sin(31881) + Math.cos(31882) * 65;
+acc += Math.sin(31882) + Math.cos(31883) * 66;
+acc += Math.sin(31883) + Math.cos(31884) * 67;
+acc += Math.sin(31884) + Math.cos(31885) * 68;
+acc += Math.sin(31885) + Math.cos(31886) * 69;
+acc += Math.sin(31886) + Math.cos(31887) * 70;
+acc += Math.sin(31887) + Math.cos(31888) * 71;
+acc += Math.sin(31888) + Math.cos(31889) * 72;
+acc += Math.sin(31889) + Math.cos(31890) * 73;
+acc += Math.sin(31890) + Math.cos(31891) * 74;
+acc += Math.sin(31891) + Math.cos(31892) * 75;
+acc += Math.sin(31892) + Math.cos(31893) * 76;
+acc += Math.sin(31893) + Math.cos(31894) * 77;
+acc += Math.sin(31894) + Math.cos(31895) * 78;
+acc += Math.sin(31895) + Math.cos(31896) * 79;
+acc += Math.sin(31896) + Math.cos(31897) * 80;
+acc += Math.sin(31897) + Math.cos(31898) * 81;
+acc += Math.sin(31898) + Math.cos(31899) * 82;
+acc += Math.sin(31899) + Math.cos(31900) * 83;
+acc += Math.sin(31900) + Math.cos(31901) * 84;
+acc += Math.sin(31901) + Math.cos(31902) * 85;
+acc += Math.sin(31902) + Math.cos(31903) * 86;
+acc += Math.sin(31903) + Math.cos(31904) * 87;
+acc += Math.sin(31904) + Math.cos(31905) * 88;
+acc += Math.sin(31905) + Math.cos(31906) * 89;
+acc += Math.sin(31906) + Math.cos(31907) * 90;
+acc += Math.sin(31907) + Math.cos(31908) * 91;
+acc += Math.sin(31908) + Math.cos(31909) * 92;
+acc += Math.sin(31909) + Math.cos(31910) * 93;
+acc += Math.sin(31910) + Math.cos(31911) * 94;
+acc += Math.sin(31911) + Math.cos(31912) * 95;
+acc += Math.sin(31912) + Math.cos(31913) * 96;
+acc += Math.sin(31913) + Math.cos(31914) * 0;
+acc += Math.sin(31914) + Math.cos(31915) * 1;
+acc += Math.sin(31915) + Math.cos(31916) * 2;
+acc += Math.sin(31916) + Math.cos(31917) * 3;
+acc += Math.sin(31917) + Math.cos(31918) * 4;
+acc += Math.sin(31918) + Math.cos(31919) * 5;
+acc += Math.sin(31919) + Math.cos(31920) * 6;
+acc += Math.sin(31920) + Math.cos(31921) * 7;
+acc += Math.sin(31921) + Math.cos(31922) * 8;
+acc += Math.sin(31922) + Math.cos(31923) * 9;
+acc += Math.sin(31923) + Math.cos(31924) * 10;
+acc += Math.sin(31924) + Math.cos(31925) * 11;
+acc += Math.sin(31925) + Math.cos(31926) * 12;
+acc += Math.sin(31926) + Math.cos(31927) * 13;
+acc += Math.sin(31927) + Math.cos(31928) * 14;
+acc += Math.sin(31928) + Math.cos(31929) * 15;
+acc += Math.sin(31929) + Math.cos(31930) * 16;
+acc += Math.sin(31930) + Math.cos(31931) * 17;
+acc += Math.sin(31931) + Math.cos(31932) * 18;
+acc += Math.sin(31932) + Math.cos(31933) * 19;
+acc += Math.sin(31933) + Math.cos(31934) * 20;
+acc += Math.sin(31934) + Math.cos(31935) * 21;
+acc += Math.sin(31935) + Math.cos(31936) * 22;
+acc += Math.sin(31936) + Math.cos(31937) * 23;
+acc += Math.sin(31937) + Math.cos(31938) * 24;
+acc += Math.sin(31938) + Math.cos(31939) * 25;
+acc += Math.sin(31939) + Math.cos(31940) * 26;
+acc += Math.sin(31940) + Math.cos(31941) * 27;
+acc += Math.sin(31941) + Math.cos(31942) * 28;
+acc += Math.sin(31942) + Math.cos(31943) * 29;
+acc += Math.sin(31943) + Math.cos(31944) * 30;
+acc += Math.sin(31944) + Math.cos(31945) * 31;
+acc += Math.sin(31945) + Math.cos(31946) * 32;
+acc += Math.sin(31946) + Math.cos(31947) * 33;
+acc += Math.sin(31947) + Math.cos(31948) * 34;
+acc += Math.sin(31948) + Math.cos(31949) * 35;
+acc += Math.sin(31949) + Math.cos(31950) * 36;
+acc += Math.sin(31950) + Math.cos(31951) * 37;
+acc += Math.sin(31951) + Math.cos(31952) * 38;
+acc += Math.sin(31952) + Math.cos(31953) * 39;
+acc += Math.sin(31953) + Math.cos(31954) * 40;
+acc += Math.sin(31954) + Math.cos(31955) * 41;
+acc += Math.sin(31955) + Math.cos(31956) * 42;
+acc += Math.sin(31956) + Math.cos(31957) * 43;
+acc += Math.sin(31957) + Math.cos(31958) * 44;
+acc += Math.sin(31958) + Math.cos(31959) * 45;
+acc += Math.sin(31959) + Math.cos(31960) * 46;
+acc += Math.sin(31960) + Math.cos(31961) * 47;
+acc += Math.sin(31961) + Math.cos(31962) * 48;
+acc += Math.sin(31962) + Math.cos(31963) * 49;
+acc += Math.sin(31963) + Math.cos(31964) * 50;
+acc += Math.sin(31964) + Math.cos(31965) * 51;
+acc += Math.sin(31965) + Math.cos(31966) * 52;
+acc += Math.sin(31966) + Math.cos(31967) * 53;
+acc += Math.sin(31967) + Math.cos(31968) * 54;
+acc += Math.sin(31968) + Math.cos(31969) * 55;
+acc += Math.sin(31969) + Math.cos(31970) * 56;
+acc += Math.sin(31970) + Math.cos(31971) * 57;
+acc += Math.sin(31971) + Math.cos(31972) * 58;
+acc += Math.sin(31972) + Math.cos(31973) * 59;
+acc += Math.sin(31973) + Math.cos(31974) * 60;
+acc += Math.sin(31974) + Math.cos(31975) * 61;
+acc += Math.sin(31975) + Math.cos(31976) * 62;
+acc += Math.sin(31976) + Math.cos(31977) * 63;
+acc += Math.sin(31977) + Math.cos(31978) * 64;
+acc += Math.sin(31978) + Math.cos(31979) * 65;
+acc += Math.sin(31979) + Math.cos(31980) * 66;
+acc += Math.sin(31980) + Math.cos(31981) * 67;
+acc += Math.sin(31981) + Math.cos(31982) * 68;
+acc += Math.sin(31982) + Math.cos(31983) * 69;
+acc += Math.sin(31983) + Math.cos(31984) * 70;
+acc += Math.sin(31984) + Math.cos(31985) * 71;
+acc += Math.sin(31985) + Math.cos(31986) * 72;
+acc += Math.sin(31986) + Math.cos(31987) * 73;
+acc += Math.sin(31987) + Math.cos(31988) * 74;
+acc += Math.sin(31988) + Math.cos(31989) * 75;
+acc += Math.sin(31989) + Math.cos(31990) * 76;
+acc += Math.sin(31990) + Math.cos(31991) * 77;
+acc += Math.sin(31991) + Math.cos(31992) * 78;
+acc += Math.sin(31992) + Math.cos(31993) * 79;
+acc += Math.sin(31993) + Math.cos(31994) * 80;
+acc += Math.sin(31994) + Math.cos(31995) * 81;
+acc += Math.sin(31995) + Math.cos(31996) * 82;
+acc += Math.sin(31996) + Math.cos(31997) * 83;
+acc += Math.sin(31997) + Math.cos(31998) * 84;
+acc += Math.sin(31998) + Math.cos(31999) * 85;
+acc += Math.sin(31999) + Math.cos(32000) * 86;
+acc += Math.sin(32000) + Math.cos(32001) * 87;
+acc += Math.sin(32001) + Math.cos(32002) * 88;
+acc += Math.sin(32002) + Math.cos(32003) * 89;
+acc += Math.sin(32003) + Math.cos(32004) * 90;
+acc += Math.sin(32004) + Math.cos(32005) * 91;
+acc += Math.sin(32005) + Math.cos(32006) * 92;
+acc += Math.sin(32006) + Math.cos(32007) * 93;
+acc += Math.sin(32007) + Math.cos(32008) * 94;
+acc += Math.sin(32008) + Math.cos(32009) * 95;
+acc += Math.sin(32009) + Math.cos(32010) * 96;
+acc += Math.sin(32010) + Math.cos(32011) * 0;
+acc += Math.sin(32011) + Math.cos(32012) * 1;
+acc += Math.sin(32012) + Math.cos(32013) * 2;
+acc += Math.sin(32013) + Math.cos(32014) * 3;
+acc += Math.sin(32014) + Math.cos(32015) * 4;
+acc += Math.sin(32015) + Math.cos(32016) * 5;
+acc += Math.sin(32016) + Math.cos(32017) * 6;
+acc += Math.sin(32017) + Math.cos(32018) * 7;
+acc += Math.sin(32018) + Math.cos(32019) * 8;
+acc += Math.sin(32019) + Math.cos(32020) * 9;
+acc += Math.sin(32020) + Math.cos(32021) * 10;
+acc += Math.sin(32021) + Math.cos(32022) * 11;
+acc += Math.sin(32022) + Math.cos(32023) * 12;
+acc += Math.sin(32023) + Math.cos(32024) * 13;
+acc += Math.sin(32024) + Math.cos(32025) * 14;
+acc += Math.sin(32025) + Math.cos(32026) * 15;
+acc += Math.sin(32026) + Math.cos(32027) * 16;
+acc += Math.sin(32027) + Math.cos(32028) * 17;
+acc += Math.sin(32028) + Math.cos(32029) * 18;
+acc += Math.sin(32029) + Math.cos(32030) * 19;
+acc += Math.sin(32030) + Math.cos(32031) * 20;
+acc += Math.sin(32031) + Math.cos(32032) * 21;
+acc += Math.sin(32032) + Math.cos(32033) * 22;
+acc += Math.sin(32033) + Math.cos(32034) * 23;
+acc += Math.sin(32034) + Math.cos(32035) * 24;
+acc += Math.sin(32035) + Math.cos(32036) * 25;
+acc += Math.sin(32036) + Math.cos(32037) * 26;
+acc += Math.sin(32037) + Math.cos(32038) * 27;
+acc += Math.sin(32038) + Math.cos(32039) * 28;
+acc += Math.sin(32039) + Math.cos(32040) * 29;
+acc += Math.sin(32040) + Math.cos(32041) * 30;
+acc += Math.sin(32041) + Math.cos(32042) * 31;
+acc += Math.sin(32042) + Math.cos(32043) * 32;
+acc += Math.sin(32043) + Math.cos(32044) * 33;
+acc += Math.sin(32044) + Math.cos(32045) * 34;
+acc += Math.sin(32045) + Math.cos(32046) * 35;
+acc += Math.sin(32046) + Math.cos(32047) * 36;
+acc += Math.sin(32047) + Math.cos(32048) * 37;
+acc += Math.sin(32048) + Math.cos(32049) * 38;
+acc += Math.sin(32049) + Math.cos(32050) * 39;
+acc += Math.sin(32050) + Math.cos(32051) * 40;
+acc += Math.sin(32051) + Math.cos(32052) * 41;
+acc += Math.sin(32052) + Math.cos(32053) * 42;
+acc += Math.sin(32053) + Math.cos(32054) * 43;
+acc += Math.sin(32054) + Math.cos(32055) * 44;
+acc += Math.sin(32055) + Math.cos(32056) * 45;
+acc += Math.sin(32056) + Math.cos(32057) * 46;
+acc += Math.sin(32057) + Math.cos(32058) * 47;
+acc += Math.sin(32058) + Math.cos(32059) * 48;
+acc += Math.sin(32059) + Math.cos(32060) * 49;
+acc += Math.sin(32060) + Math.cos(32061) * 50;
+acc += Math.sin(32061) + Math.cos(32062) * 51;
+acc += Math.sin(32062) + Math.cos(32063) * 52;
+acc += Math.sin(32063) + Math.cos(32064) * 53;
+acc += Math.sin(32064) + Math.cos(32065) * 54;
+acc += Math.sin(32065) + Math.cos(32066) * 55;
+acc += Math.sin(32066) + Math.cos(32067) * 56;
+acc += Math.sin(32067) + Math.cos(32068) * 57;
+acc += Math.sin(32068) + Math.cos(32069) * 58;
+acc += Math.sin(32069) + Math.cos(32070) * 59;
+acc += Math.sin(32070) + Math.cos(32071) * 60;
+acc += Math.sin(32071) + Math.cos(32072) * 61;
+acc += Math.sin(32072) + Math.cos(32073) * 62;
+acc += Math.sin(32073) + Math.cos(32074) * 63;
+acc += Math.sin(32074) + Math.cos(32075) * 64;
+acc += Math.sin(32075) + Math.cos(32076) * 65;
+acc += Math.sin(32076) + Math.cos(32077) * 66;
+acc += Math.sin(32077) + Math.cos(32078) * 67;
+acc += Math.sin(32078) + Math.cos(32079) * 68;
+acc += Math.sin(32079) + Math.cos(32080) * 69;
+acc += Math.sin(32080) + Math.cos(32081) * 70;
+acc += Math.sin(32081) + Math.cos(32082) * 71;
+acc += Math.sin(32082) + Math.cos(32083) * 72;
+acc += Math.sin(32083) + Math.cos(32084) * 73;
+acc += Math.sin(32084) + Math.cos(32085) * 74;
+acc += Math.sin(32085) + Math.cos(32086) * 75;
+acc += Math.sin(32086) + Math.cos(32087) * 76;
+acc += Math.sin(32087) + Math.cos(32088) * 77;
+acc += Math.sin(32088) + Math.cos(32089) * 78;
+acc += Math.sin(32089) + Math.cos(32090) * 79;
+acc += Math.sin(32090) + Math.cos(32091) * 80;
+acc += Math.sin(32091) + Math.cos(32092) * 81;
+acc += Math.sin(32092) + Math.cos(32093) * 82;
+acc += Math.sin(32093) + Math.cos(32094) * 83;
+acc += Math.sin(32094) + Math.cos(32095) * 84;
+acc += Math.sin(32095) + Math.cos(32096) * 85;
+acc += Math.sin(32096) + Math.cos(32097) * 86;
+acc += Math.sin(32097) + Math.cos(32098) * 87;
+acc += Math.sin(32098) + Math.cos(32099) * 88;
+acc += Math.sin(32099) + Math.cos(32100) * 89;
+acc += Math.sin(32100) + Math.cos(32101) * 90;
+acc += Math.sin(32101) + Math.cos(32102) * 91;
+acc += Math.sin(32102) + Math.cos(32103) * 92;
+acc += Math.sin(32103) + Math.cos(32104) * 93;
+acc += Math.sin(32104) + Math.cos(32105) * 94;
+acc += Math.sin(32105) + Math.cos(32106) * 95;
+acc += Math.sin(32106) + Math.cos(32107) * 96;
+acc += Math.sin(32107) + Math.cos(32108) * 0;
+acc += Math.sin(32108) + Math.cos(32109) * 1;
+acc += Math.sin(32109) + Math.cos(32110) * 2;
+acc += Math.sin(32110) + Math.cos(32111) * 3;
+acc += Math.sin(32111) + Math.cos(32112) * 4;
+acc += Math.sin(32112) + Math.cos(32113) * 5;
+acc += Math.sin(32113) + Math.cos(32114) * 6;
+acc += Math.sin(32114) + Math.cos(32115) * 7;
+acc += Math.sin(32115) + Math.cos(32116) * 8;
+acc += Math.sin(32116) + Math.cos(32117) * 9;
+acc += Math.sin(32117) + Math.cos(32118) * 10;
+acc += Math.sin(32118) + Math.cos(32119) * 11;
+acc += Math.sin(32119) + Math.cos(32120) * 12;
+acc += Math.sin(32120) + Math.cos(32121) * 13;
+acc += Math.sin(32121) + Math.cos(32122) * 14;
+acc += Math.sin(32122) + Math.cos(32123) * 15;
+acc += Math.sin(32123) + Math.cos(32124) * 16;
+acc += Math.sin(32124) + Math.cos(32125) * 17;
+acc += Math.sin(32125) + Math.cos(32126) * 18;
+acc += Math.sin(32126) + Math.cos(32127) * 19;
+acc += Math.sin(32127) + Math.cos(32128) * 20;
+acc += Math.sin(32128) + Math.cos(32129) * 21;
+acc += Math.sin(32129) + Math.cos(32130) * 22;
+acc += Math.sin(32130) + Math.cos(32131) * 23;
+acc += Math.sin(32131) + Math.cos(32132) * 24;
+acc += Math.sin(32132) + Math.cos(32133) * 25;
+acc += Math.sin(32133) + Math.cos(32134) * 26;
+acc += Math.sin(32134) + Math.cos(32135) * 27;
+acc += Math.sin(32135) + Math.cos(32136) * 28;
+acc += Math.sin(32136) + Math.cos(32137) * 29;
+acc += Math.sin(32137) + Math.cos(32138) * 30;
+acc += Math.sin(32138) + Math.cos(32139) * 31;
+acc += Math.sin(32139) + Math.cos(32140) * 32;
+acc += Math.sin(32140) + Math.cos(32141) * 33;
+acc += Math.sin(32141) + Math.cos(32142) * 34;
+acc += Math.sin(32142) + Math.cos(32143) * 35;
+acc += Math.sin(32143) + Math.cos(32144) * 36;
+acc += Math.sin(32144) + Math.cos(32145) * 37;
+acc += Math.sin(32145) + Math.cos(32146) * 38;
+acc += Math.sin(32146) + Math.cos(32147) * 39;
+acc += Math.sin(32147) + Math.cos(32148) * 40;
+acc += Math.sin(32148) + Math.cos(32149) * 41;
+acc += Math.sin(32149) + Math.cos(32150) * 42;
+acc += Math.sin(32150) + Math.cos(32151) * 43;
+acc += Math.sin(32151) + Math.cos(32152) * 44;
+acc += Math.sin(32152) + Math.cos(32153) * 45;
+acc += Math.sin(32153) + Math.cos(32154) * 46;
+acc += Math.sin(32154) + Math.cos(32155) * 47;
+acc += Math.sin(32155) + Math.cos(32156) * 48;
+acc += Math.sin(32156) + Math.cos(32157) * 49;
+acc += Math.sin(32157) + Math.cos(32158) * 50;
+acc += Math.sin(32158) + Math.cos(32159) * 51;
+acc += Math.sin(32159) + Math.cos(32160) * 52;
+acc += Math.sin(32160) + Math.cos(32161) * 53;
+acc += Math.sin(32161) + Math.cos(32162) * 54;
+acc += Math.sin(32162) + Math.cos(32163) * 55;
+acc += Math.sin(32163) + Math.cos(32164) * 56;
+acc += Math.sin(32164) + Math.cos(32165) * 57;
+acc += Math.sin(32165) + Math.cos(32166) * 58;
+acc += Math.sin(32166) + Math.cos(32167) * 59;
+acc += Math.sin(32167) + Math.cos(32168) * 60;
+acc += Math.sin(32168) + Math.cos(32169) * 61;
+acc += Math.sin(32169) + Math.cos(32170) * 62;
+acc += Math.sin(32170) + Math.cos(32171) * 63;
+acc += Math.sin(32171) + Math.cos(32172) * 64;
+acc += Math.sin(32172) + Math.cos(32173) * 65;
+acc += Math.sin(32173) + Math.cos(32174) * 66;
+acc += Math.sin(32174) + Math.cos(32175) * 67;
+acc += Math.sin(32175) + Math.cos(32176) * 68;
+acc += Math.sin(32176) + Math.cos(32177) * 69;
+acc += Math.sin(32177) + Math.cos(32178) * 70;
+acc += Math.sin(32178) + Math.cos(32179) * 71;
+acc += Math.sin(32179) + Math.cos(32180) * 72;
+acc += Math.sin(32180) + Math.cos(32181) * 73;
+acc += Math.sin(32181) + Math.cos(32182) * 74;
+acc += Math.sin(32182) + Math.cos(32183) * 75;
+acc += Math.sin(32183) + Math.cos(32184) * 76;
+acc += Math.sin(32184) + Math.cos(32185) * 77;
+acc += Math.sin(32185) + Math.cos(32186) * 78;
+acc += Math.sin(32186) + Math.cos(32187) * 79;
+acc += Math.sin(32187) + Math.cos(32188) * 80;
+acc += Math.sin(32188) + Math.cos(32189) * 81;
+acc += Math.sin(32189) + Math.cos(32190) * 82;
+acc += Math.sin(32190) + Math.cos(32191) * 83;
+acc += Math.sin(32191) + Math.cos(32192) * 84;
+acc += Math.sin(32192) + Math.cos(32193) * 85;
+acc += Math.sin(32193) + Math.cos(32194) * 86;
+acc += Math.sin(32194) + Math.cos(32195) * 87;
+acc += Math.sin(32195) + Math.cos(32196) * 88;
+acc += Math.sin(32196) + Math.cos(32197) * 89;
+acc += Math.sin(32197) + Math.cos(32198) * 90;
+acc += Math.sin(32198) + Math.cos(32199) * 91;
+acc += Math.sin(32199) + Math.cos(32200) * 92;
+acc += Math.sin(32200) + Math.cos(32201) * 93;
+acc += Math.sin(32201) + Math.cos(32202) * 94;
+acc += Math.sin(32202) + Math.cos(32203) * 95;
+acc += Math.sin(32203) + Math.cos(32204) * 96;
+acc += Math.sin(32204) + Math.cos(32205) * 0;
+acc += Math.sin(32205) + Math.cos(32206) * 1;
+acc += Math.sin(32206) + Math.cos(32207) * 2;
+acc += Math.sin(32207) + Math.cos(32208) * 3;
+acc += Math.sin(32208) + Math.cos(32209) * 4;
+acc += Math.sin(32209) + Math.cos(32210) * 5;
+acc += Math.sin(32210) + Math.cos(32211) * 6;
+acc += Math.sin(32211) + Math.cos(32212) * 7;
+acc += Math.sin(32212) + Math.cos(32213) * 8;
+acc += Math.sin(32213) + Math.cos(32214) * 9;
+acc += Math.sin(32214) + Math.cos(32215) * 10;
+acc += Math.sin(32215) + Math.cos(32216) * 11;
+acc += Math.sin(32216) + Math.cos(32217) * 12;
+acc += Math.sin(32217) + Math.cos(32218) * 13;
+acc += Math.sin(32218) + Math.cos(32219) * 14;
+acc += Math.sin(32219) + Math.cos(32220) * 15;
+acc += Math.sin(32220) + Math.cos(32221) * 16;
+acc += Math.sin(32221) + Math.cos(32222) * 17;
+acc += Math.sin(32222) + Math.cos(32223) * 18;
+acc += Math.sin(32223) + Math.cos(32224) * 19;
+acc += Math.sin(32224) + Math.cos(32225) * 20;
+acc += Math.sin(32225) + Math.cos(32226) * 21;
+acc += Math.sin(32226) + Math.cos(32227) * 22;
+acc += Math.sin(32227) + Math.cos(32228) * 23;
+acc += Math.sin(32228) + Math.cos(32229) * 24;
+acc += Math.sin(32229) + Math.cos(32230) * 25;
+acc += Math.sin(32230) + Math.cos(32231) * 26;
+acc += Math.sin(32231) + Math.cos(32232) * 27;
+acc += Math.sin(32232) + Math.cos(32233) * 28;
+acc += Math.sin(32233) + Math.cos(32234) * 29;
+acc += Math.sin(32234) + Math.cos(32235) * 30;
+acc += Math.sin(32235) + Math.cos(32236) * 31;
+acc += Math.sin(32236) + Math.cos(32237) * 32;
+acc += Math.sin(32237) + Math.cos(32238) * 33;
+acc += Math.sin(32238) + Math.cos(32239) * 34;
+acc += Math.sin(32239) + Math.cos(32240) * 35;
+acc += Math.sin(32240) + Math.cos(32241) * 36;
+acc += Math.sin(32241) + Math.cos(32242) * 37;
+acc += Math.sin(32242) + Math.cos(32243) * 38;
+acc += Math.sin(32243) + Math.cos(32244) * 39;
+acc += Math.sin(32244) + Math.cos(32245) * 40;
+acc += Math.sin(32245) + Math.cos(32246) * 41;
+acc += Math.sin(32246) + Math.cos(32247) * 42;
+acc += Math.sin(32247) + Math.cos(32248) * 43;
+acc += Math.sin(32248) + Math.cos(32249) * 44;
+acc += Math.sin(32249) + Math.cos(32250) * 45;
+acc += Math.sin(32250) + Math.cos(32251) * 46;
+acc += Math.sin(32251) + Math.cos(32252) * 47;
+acc += Math.sin(32252) + Math.cos(32253) * 48;
+acc += Math.sin(32253) + Math.cos(32254) * 49;
+acc += Math.sin(32254) + Math.cos(32255) * 50;
+acc += Math.sin(32255) + Math.cos(32256) * 51;
+acc += Math.sin(32256) + Math.cos(32257) * 52;
+acc += Math.sin(32257) + Math.cos(32258) * 53;
+acc += Math.sin(32258) + Math.cos(32259) * 54;
+acc += Math.sin(32259) + Math.cos(32260) * 55;
+acc += Math.sin(32260) + Math.cos(32261) * 56;
+acc += Math.sin(32261) + Math.cos(32262) * 57;
+acc += Math.sin(32262) + Math.cos(32263) * 58;
+acc += Math.sin(32263) + Math.cos(32264) * 59;
+acc += Math.sin(32264) + Math.cos(32265) * 60;
+acc += Math.sin(32265) + Math.cos(32266) * 61;
+acc += Math.sin(32266) + Math.cos(32267) * 62;
+acc += Math.sin(32267) + Math.cos(32268) * 63;
+acc += Math.sin(32268) + Math.cos(32269) * 64;
+acc += Math.sin(32269) + Math.cos(32270) * 65;
+acc += Math.sin(32270) + Math.cos(32271) * 66;
+acc += Math.sin(32271) + Math.cos(32272) * 67;
+acc += Math.sin(32272) + Math.cos(32273) * 68;
+acc += Math.sin(32273) + Math.cos(32274) * 69;
+acc += Math.sin(32274) + Math.cos(32275) * 70;
+acc += Math.sin(32275) + Math.cos(32276) * 71;
+acc += Math.sin(32276) + Math.cos(32277) * 72;
+acc += Math.sin(32277) + Math.cos(32278) * 73;
+acc += Math.sin(32278) + Math.cos(32279) * 74;
+acc += Math.sin(32279) + Math.cos(32280) * 75;
+acc += Math.sin(32280) + Math.cos(32281) * 76;
+acc += Math.sin(32281) + Math.cos(32282) * 77;
+acc += Math.sin(32282) + Math.cos(32283) * 78;
+acc += Math.sin(32283) + Math.cos(32284) * 79;
+acc += Math.sin(32284) + Math.cos(32285) * 80;
+acc += Math.sin(32285) + Math.cos(32286) * 81;
+acc += Math.sin(32286) + Math.cos(32287) * 82;
+acc += Math.sin(32287) + Math.cos(32288) * 83;
+acc += Math.sin(32288) + Math.cos(32289) * 84;
+acc += Math.sin(32289) + Math.cos(32290) * 85;
+acc += Math.sin(32290) + Math.cos(32291) * 86;
+acc += Math.sin(32291) + Math.cos(32292) * 87;
+acc += Math.sin(32292) + Math.cos(32293) * 88;
+acc += Math.sin(32293) + Math.cos(32294) * 89;
+acc += Math.sin(32294) + Math.cos(32295) * 90;
+acc += Math.sin(32295) + Math.cos(32296) * 91;
+acc += Math.sin(32296) + Math.cos(32297) * 92;
+acc += Math.sin(32297) + Math.cos(32298) * 93;
+acc += Math.sin(32298) + Math.cos(32299) * 94;
+acc += Math.sin(32299) + Math.cos(32300) * 95;
+acc += Math.sin(32300) + Math.cos(32301) * 96;
+acc += Math.sin(32301) + Math.cos(32302) * 0;
+acc += Math.sin(32302) + Math.cos(32303) * 1;
+acc += Math.sin(32303) + Math.cos(32304) * 2;
+acc += Math.sin(32304) + Math.cos(32305) * 3;
+acc += Math.sin(32305) + Math.cos(32306) * 4;
+acc += Math.sin(32306) + Math.cos(32307) * 5;
+acc += Math.sin(32307) + Math.cos(32308) * 6;
+acc += Math.sin(32308) + Math.cos(32309) * 7;
+acc += Math.sin(32309) + Math.cos(32310) * 8;
+acc += Math.sin(32310) + Math.cos(32311) * 9;
+acc += Math.sin(32311) + Math.cos(32312) * 10;
+acc += Math.sin(32312) + Math.cos(32313) * 11;
+acc += Math.sin(32313) + Math.cos(32314) * 12;
+acc += Math.sin(32314) + Math.cos(32315) * 13;
+acc += Math.sin(32315) + Math.cos(32316) * 14;
+acc += Math.sin(32316) + Math.cos(32317) * 15;
+acc += Math.sin(32317) + Math.cos(32318) * 16;
+acc += Math.sin(32318) + Math.cos(32319) * 17;
+acc += Math.sin(32319) + Math.cos(32320) * 18;
+acc += Math.sin(32320) + Math.cos(32321) * 19;
+acc += Math.sin(32321) + Math.cos(32322) * 20;
+acc += Math.sin(32322) + Math.cos(32323) * 21;
+acc += Math.sin(32323) + Math.cos(32324) * 22;
+acc += Math.sin(32324) + Math.cos(32325) * 23;
+acc += Math.sin(32325) + Math.cos(32326) * 24;
+acc += Math.sin(32326) + Math.cos(32327) * 25;
+acc += Math.sin(32327) + Math.cos(32328) * 26;
+acc += Math.sin(32328) + Math.cos(32329) * 27;
+acc += Math.sin(32329) + Math.cos(32330) * 28;
+acc += Math.sin(32330) + Math.cos(32331) * 29;
+acc += Math.sin(32331) + Math.cos(32332) * 30;
+acc += Math.sin(32332) + Math.cos(32333) * 31;
+acc += Math.sin(32333) + Math.cos(32334) * 32;
+acc += Math.sin(32334) + Math.cos(32335) * 33;
+acc += Math.sin(32335) + Math.cos(32336) * 34;
+acc += Math.sin(32336) + Math.cos(32337) * 35;
+acc += Math.sin(32337) + Math.cos(32338) * 36;
+acc += Math.sin(32338) + Math.cos(32339) * 37;
+acc += Math.sin(32339) + Math.cos(32340) * 38;
+acc += Math.sin(32340) + Math.cos(32341) * 39;
+acc += Math.sin(32341) + Math.cos(32342) * 40;
+acc += Math.sin(32342) + Math.cos(32343) * 41;
+acc += Math.sin(32343) + Math.cos(32344) * 42;
+acc += Math.sin(32344) + Math.cos(32345) * 43;
+acc += Math.sin(32345) + Math.cos(32346) * 44;
+acc += Math.sin(32346) + Math.cos(32347) * 45;
+acc += Math.sin(32347) + Math.cos(32348) * 46;
+acc += Math.sin(32348) + Math.cos(32349) * 47;
+acc += Math.sin(32349) + Math.cos(32350) * 48;
+acc += Math.sin(32350) + Math.cos(32351) * 49;
+acc += Math.sin(32351) + Math.cos(32352) * 50;
+acc += Math.sin(32352) + Math.cos(32353) * 51;
+acc += Math.sin(32353) + Math.cos(32354) * 52;
+acc += Math.sin(32354) + Math.cos(32355) * 53;
+acc += Math.sin(32355) + Math.cos(32356) * 54;
+acc += Math.sin(32356) + Math.cos(32357) * 55;
+acc += Math.sin(32357) + Math.cos(32358) * 56;
+acc += Math.sin(32358) + Math.cos(32359) * 57;
+acc += Math.sin(32359) + Math.cos(32360) * 58;
+acc += Math.sin(32360) + Math.cos(32361) * 59;
+acc += Math.sin(32361) + Math.cos(32362) * 60;
+acc += Math.sin(32362) + Math.cos(32363) * 61;
+acc += Math.sin(32363) + Math.cos(32364) * 62;
+acc += Math.sin(32364) + Math.cos(32365) * 63;
+acc += Math.sin(32365) + Math.cos(32366) * 64;
+acc += Math.sin(32366) + Math.cos(32367) * 65;
+acc += Math.sin(32367) + Math.cos(32368) * 66;
+acc += Math.sin(32368) + Math.cos(32369) * 67;
+acc += Math.sin(32369) + Math.cos(32370) * 68;
+acc += Math.sin(32370) + Math.cos(32371) * 69;
+acc += Math.sin(32371) + Math.cos(32372) * 70;
+acc += Math.sin(32372) + Math.cos(32373) * 71;
+acc += Math.sin(32373) + Math.cos(32374) * 72;
+acc += Math.sin(32374) + Math.cos(32375) * 73;
+acc += Math.sin(32375) + Math.cos(32376) * 74;
+acc += Math.sin(32376) + Math.cos(32377) * 75;
+acc += Math.sin(32377) + Math.cos(32378) * 76;
+acc += Math.sin(32378) + Math.cos(32379) * 77;
+acc += Math.sin(32379) + Math.cos(32380) * 78;
+acc += Math.sin(32380) + Math.cos(32381) * 79;
+acc += Math.sin(32381) + Math.cos(32382) * 80;
+acc += Math.sin(32382) + Math.cos(32383) * 81;
+acc += Math.sin(32383) + Math.cos(32384) * 82;
+acc += Math.sin(32384) + Math.cos(32385) * 83;
+acc += Math.sin(32385) + Math.cos(32386) * 84;
+acc += Math.sin(32386) + Math.cos(32387) * 85;
+acc += Math.sin(32387) + Math.cos(32388) * 86;
+acc += Math.sin(32388) + Math.cos(32389) * 87;
+acc += Math.sin(32389) + Math.cos(32390) * 88;
+acc += Math.sin(32390) + Math.cos(32391) * 89;
+acc += Math.sin(32391) + Math.cos(32392) * 90;
+acc += Math.sin(32392) + Math.cos(32393) * 91;
+acc += Math.sin(32393) + Math.cos(32394) * 92;
+acc += Math.sin(32394) + Math.cos(32395) * 93;
+acc += Math.sin(32395) + Math.cos(32396) * 94;
+acc += Math.sin(32396) + Math.cos(32397) * 95;
+acc += Math.sin(32397) + Math.cos(32398) * 96;
+acc += Math.sin(32398) + Math.cos(32399) * 0;
+acc += Math.sin(32399) + Math.cos(32400) * 1;
+acc += Math.sin(32400) + Math.cos(32401) * 2;
+acc += Math.sin(32401) + Math.cos(32402) * 3;
+acc += Math.sin(32402) + Math.cos(32403) * 4;
+acc += Math.sin(32403) + Math.cos(32404) * 5;
+acc += Math.sin(32404) + Math.cos(32405) * 6;
+acc += Math.sin(32405) + Math.cos(32406) * 7;
+acc += Math.sin(32406) + Math.cos(32407) * 8;
+acc += Math.sin(32407) + Math.cos(32408) * 9;
+acc += Math.sin(32408) + Math.cos(32409) * 10;
+acc += Math.sin(32409) + Math.cos(32410) * 11;
+acc += Math.sin(32410) + Math.cos(32411) * 12;
+acc += Math.sin(32411) + Math.cos(32412) * 13;
+acc += Math.sin(32412) + Math.cos(32413) * 14;
+acc += Math.sin(32413) + Math.cos(32414) * 15;
+acc += Math.sin(32414) + Math.cos(32415) * 16;
+acc += Math.sin(32415) + Math.cos(32416) * 17;
+acc += Math.sin(32416) + Math.cos(32417) * 18;
+acc += Math.sin(32417) + Math.cos(32418) * 19;
+acc += Math.sin(32418) + Math.cos(32419) * 20;
+acc += Math.sin(32419) + Math.cos(32420) * 21;
+acc += Math.sin(32420) + Math.cos(32421) * 22;
+acc += Math.sin(32421) + Math.cos(32422) * 23;
+acc += Math.sin(32422) + Math.cos(32423) * 24;
+acc += Math.sin(32423) + Math.cos(32424) * 25;
+acc += Math.sin(32424) + Math.cos(32425) * 26;
+acc += Math.sin(32425) + Math.cos(32426) * 27;
+acc += Math.sin(32426) + Math.cos(32427) * 28;
+acc += Math.sin(32427) + Math.cos(32428) * 29;
+acc += Math.sin(32428) + Math.cos(32429) * 30;
+acc += Math.sin(32429) + Math.cos(32430) * 31;
+acc += Math.sin(32430) + Math.cos(32431) * 32;
+acc += Math.sin(32431) + Math.cos(32432) * 33;
+acc += Math.sin(32432) + Math.cos(32433) * 34;
+acc += Math.sin(32433) + Math.cos(32434) * 35;
+acc += Math.sin(32434) + Math.cos(32435) * 36;
+acc += Math.sin(32435) + Math.cos(32436) * 37;
+acc += Math.sin(32436) + Math.cos(32437) * 38;
+acc += Math.sin(32437) + Math.cos(32438) * 39;
+acc += Math.sin(32438) + Math.cos(32439) * 40;
+acc += Math.sin(32439) + Math.cos(32440) * 41;
+acc += Math.sin(32440) + Math.cos(32441) * 42;
+acc += Math.sin(32441) + Math.cos(32442) * 43;
+acc += Math.sin(32442) + Math.cos(32443) * 44;
+acc += Math.sin(32443) + Math.cos(32444) * 45;
+acc += Math.sin(32444) + Math.cos(32445) * 46;
+acc += Math.sin(32445) + Math.cos(32446) * 47;
+acc += Math.sin(32446) + Math.cos(32447) * 48;
+acc += Math.sin(32447) + Math.cos(32448) * 49;
+acc += Math.sin(32448) + Math.cos(32449) * 50;
+acc += Math.sin(32449) + Math.cos(32450) * 51;
+acc += Math.sin(32450) + Math.cos(32451) * 52;
+acc += Math.sin(32451) + Math.cos(32452) * 53;
+acc += Math.sin(32452) + Math.cos(32453) * 54;
+acc += Math.sin(32453) + Math.cos(32454) * 55;
+acc += Math.sin(32454) + Math.cos(32455) * 56;
+acc += Math.sin(32455) + Math.cos(32456) * 57;
+acc += Math.sin(32456) + Math.cos(32457) * 58;
+acc += Math.sin(32457) + Math.cos(32458) * 59;
+acc += Math.sin(32458) + Math.cos(32459) * 60;
+acc += Math.sin(32459) + Math.cos(32460) * 61;
+acc += Math.sin(32460) + Math.cos(32461) * 62;
+acc += Math.sin(32461) + Math.cos(32462) * 63;
+acc += Math.sin(32462) + Math.cos(32463) * 64;
+acc += Math.sin(32463) + Math.cos(32464) * 65;
+acc += Math.sin(32464) + Math.cos(32465) * 66;
+acc += Math.sin(32465) + Math.cos(32466) * 67;
+acc += Math.sin(32466) + Math.cos(32467) * 68;
+acc += Math.sin(32467) + Math.cos(32468) * 69;
+acc += Math.sin(32468) + Math.cos(32469) * 70;
+acc += Math.sin(32469) + Math.cos(32470) * 71;
+acc += Math.sin(32470) + Math.cos(32471) * 72;
+acc += Math.sin(32471) + Math.cos(32472) * 73;
+acc += Math.sin(32472) + Math.cos(32473) * 74;
+acc += Math.sin(32473) + Math.cos(32474) * 75;
+acc += Math.sin(32474) + Math.cos(32475) * 76;
+acc += Math.sin(32475) + Math.cos(32476) * 77;
+acc += Math.sin(32476) + Math.cos(32477) * 78;
+acc += Math.sin(32477) + Math.cos(32478) * 79;
+acc += Math.sin(32478) + Math.cos(32479) * 80;
+acc += Math.sin(32479) + Math.cos(32480) * 81;
+acc += Math.sin(32480) + Math.cos(32481) * 82;
+acc += Math.sin(32481) + Math.cos(32482) * 83;
+acc += Math.sin(32482) + Math.cos(32483) * 84;
+acc += Math.sin(32483) + Math.cos(32484) * 85;
+acc += Math.sin(32484) + Math.cos(32485) * 86;
+acc += Math.sin(32485) + Math.cos(32486) * 87;
+acc += Math.sin(32486) + Math.cos(32487) * 88;
+acc += Math.sin(32487) + Math.cos(32488) * 89;
+acc += Math.sin(32488) + Math.cos(32489) * 90;
+acc += Math.sin(32489) + Math.cos(32490) * 91;
+acc += Math.sin(32490) + Math.cos(32491) * 92;
+acc += Math.sin(32491) + Math.cos(32492) * 93;
+acc += Math.sin(32492) + Math.cos(32493) * 94;
+acc += Math.sin(32493) + Math.cos(32494) * 95;
+acc += Math.sin(32494) + Math.cos(32495) * 96;
+acc += Math.sin(32495) + Math.cos(32496) * 0;
+acc += Math.sin(32496) + Math.cos(32497) * 1;
+acc += Math.sin(32497) + Math.cos(32498) * 2;
+acc += Math.sin(32498) + Math.cos(32499) * 3;
+acc += Math.sin(32499) + Math.cos(32500) * 4;
+acc += Math.sin(32500) + Math.cos(32501) * 5;
+acc += Math.sin(32501) + Math.cos(32502) * 6;
+acc += Math.sin(32502) + Math.cos(32503) * 7;
+acc += Math.sin(32503) + Math.cos(32504) * 8;
+acc += Math.sin(32504) + Math.cos(32505) * 9;
+acc += Math.sin(32505) + Math.cos(32506) * 10;
+acc += Math.sin(32506) + Math.cos(32507) * 11;
+acc += Math.sin(32507) + Math.cos(32508) * 12;
+acc += Math.sin(32508) + Math.cos(32509) * 13;
+acc += Math.sin(32509) + Math.cos(32510) * 14;
+acc += Math.sin(32510) + Math.cos(32511) * 15;
+acc += Math.sin(32511) + Math.cos(32512) * 16;
+acc += Math.sin(32512) + Math.cos(32513) * 17;
+acc += Math.sin(32513) + Math.cos(32514) * 18;
+acc += Math.sin(32514) + Math.cos(32515) * 19;
+acc += Math.sin(32515) + Math.cos(32516) * 20;
+acc += Math.sin(32516) + Math.cos(32517) * 21;
+acc += Math.sin(32517) + Math.cos(32518) * 22;
+acc += Math.sin(32518) + Math.cos(32519) * 23;
+acc += Math.sin(32519) + Math.cos(32520) * 24;
+acc += Math.sin(32520) + Math.cos(32521) * 25;
+acc += Math.sin(32521) + Math.cos(32522) * 26;
+acc += Math.sin(32522) + Math.cos(32523) * 27;
+acc += Math.sin(32523) + Math.cos(32524) * 28;
+acc += Math.sin(32524) + Math.cos(32525) * 29;
+acc += Math.sin(32525) + Math.cos(32526) * 30;
+acc += Math.sin(32526) + Math.cos(32527) * 31;
+acc += Math.sin(32527) + Math.cos(32528) * 32;
+acc += Math.sin(32528) + Math.cos(32529) * 33;
+acc += Math.sin(32529) + Math.cos(32530) * 34;
+acc += Math.sin(32530) + Math.cos(32531) * 35;
+acc += Math.sin(32531) + Math.cos(32532) * 36;
+acc += Math.sin(32532) + Math.cos(32533) * 37;
+acc += Math.sin(32533) + Math.cos(32534) * 38;
+acc += Math.sin(32534) + Math.cos(32535) * 39;
+acc += Math.sin(32535) + Math.cos(32536) * 40;
+acc += Math.sin(32536) + Math.cos(32537) * 41;
+acc += Math.sin(32537) + Math.cos(32538) * 42;
+acc += Math.sin(32538) + Math.cos(32539) * 43;
+acc += Math.sin(32539) + Math.cos(32540) * 44;
+acc += Math.sin(32540) + Math.cos(32541) * 45;
+acc += Math.sin(32541) + Math.cos(32542) * 46;
+acc += Math.sin(32542) + Math.cos(32543) * 47;
+acc += Math.sin(32543) + Math.cos(32544) * 48;
+acc += Math.sin(32544) + Math.cos(32545) * 49;
+acc += Math.sin(32545) + Math.cos(32546) * 50;
+acc += Math.sin(32546) + Math.cos(32547) * 51;
+acc += Math.sin(32547) + Math.cos(32548) * 52;
+acc += Math.sin(32548) + Math.cos(32549) * 53;
+acc += Math.sin(32549) + Math.cos(32550) * 54;
+acc += Math.sin(32550) + Math.cos(32551) * 55;
+acc += Math.sin(32551) + Math.cos(32552) * 56;
+acc += Math.sin(32552) + Math.cos(32553) * 57;
+acc += Math.sin(32553) + Math.cos(32554) * 58;
+acc += Math.sin(32554) + Math.cos(32555) * 59;
+acc += Math.sin(32555) + Math.cos(32556) * 60;
+acc += Math.sin(32556) + Math.cos(32557) * 61;
+acc += Math.sin(32557) + Math.cos(32558) * 62;
+acc += Math.sin(32558) + Math.cos(32559) * 63;
+acc += Math.sin(32559) + Math.cos(32560) * 64;
+acc += Math.sin(32560) + Math.cos(32561) * 65;
+acc += Math.sin(32561) + Math.cos(32562) * 66;
+acc += Math.sin(32562) + Math.cos(32563) * 67;
+acc += Math.sin(32563) + Math.cos(32564) * 68;
+acc += Math.sin(32564) + Math.cos(32565) * 69;
+acc += Math.sin(32565) + Math.cos(32566) * 70;
+acc += Math.sin(32566) + Math.cos(32567) * 71;
+acc += Math.sin(32567) + Math.cos(32568) * 72;
+acc += Math.sin(32568) + Math.cos(32569) * 73;
+acc += Math.sin(32569) + Math.cos(32570) * 74;
+acc += Math.sin(32570) + Math.cos(32571) * 75;
+acc += Math.sin(32571) + Math.cos(32572) * 76;
+acc += Math.sin(32572) + Math.cos(32573) * 77;
+acc += Math.sin(32573) + Math.cos(32574) * 78;
+acc += Math.sin(32574) + Math.cos(32575) * 79;
+acc += Math.sin(32575) + Math.cos(32576) * 80;
+acc += Math.sin(32576) + Math.cos(32577) * 81;
+acc += Math.sin(32577) + Math.cos(32578) * 82;
+acc += Math.sin(32578) + Math.cos(32579) * 83;
+acc += Math.sin(32579) + Math.cos(32580) * 84;
+acc += Math.sin(32580) + Math.cos(32581) * 85;
+acc += Math.sin(32581) + Math.cos(32582) * 86;
+acc += Math.sin(32582) + Math.cos(32583) * 87;
+acc += Math.sin(32583) + Math.cos(32584) * 88;
+acc += Math.sin(32584) + Math.cos(32585) * 89;
+acc += Math.sin(32585) + Math.cos(32586) * 90;
+acc += Math.sin(32586) + Math.cos(32587) * 91;
+acc += Math.sin(32587) + Math.cos(32588) * 92;
+acc += Math.sin(32588) + Math.cos(32589) * 93;
+acc += Math.sin(32589) + Math.cos(32590) * 94;
+acc += Math.sin(32590) + Math.cos(32591) * 95;
+acc += Math.sin(32591) + Math.cos(32592) * 96;
+acc += Math.sin(32592) + Math.cos(32593) * 0;
+acc += Math.sin(32593) + Math.cos(32594) * 1;
+acc += Math.sin(32594) + Math.cos(32595) * 2;
+acc += Math.sin(32595) + Math.cos(32596) * 3;
+acc += Math.sin(32596) + Math.cos(32597) * 4;
+acc += Math.sin(32597) + Math.cos(32598) * 5;
+acc += Math.sin(32598) + Math.cos(32599) * 6;
+acc += Math.sin(32599) + Math.cos(32600) * 7;
+acc += Math.sin(32600) + Math.cos(32601) * 8;
+acc += Math.sin(32601) + Math.cos(32602) * 9;
+acc += Math.sin(32602) + Math.cos(32603) * 10;
+acc += Math.sin(32603) + Math.cos(32604) * 11;
+acc += Math.sin(32604) + Math.cos(32605) * 12;
+acc += Math.sin(32605) + Math.cos(32606) * 13;
+acc += Math.sin(32606) + Math.cos(32607) * 14;
+acc += Math.sin(32607) + Math.cos(32608) * 15;
+acc += Math.sin(32608) + Math.cos(32609) * 16;
+acc += Math.sin(32609) + Math.cos(32610) * 17;
+acc += Math.sin(32610) + Math.cos(32611) * 18;
+acc += Math.sin(32611) + Math.cos(32612) * 19;
+acc += Math.sin(32612) + Math.cos(32613) * 20;
+acc += Math.sin(32613) + Math.cos(32614) * 21;
+acc += Math.sin(32614) + Math.cos(32615) * 22;
+acc += Math.sin(32615) + Math.cos(32616) * 23;
+acc += Math.sin(32616) + Math.cos(32617) * 24;
+acc += Math.sin(32617) + Math.cos(32618) * 25;
+acc += Math.sin(32618) + Math.cos(32619) * 26;
+acc += Math.sin(32619) + Math.cos(32620) * 27;
+acc += Math.sin(32620) + Math.cos(32621) * 28;
+acc += Math.sin(32621) + Math.cos(32622) * 29;
+acc += Math.sin(32622) + Math.cos(32623) * 30;
+acc += Math.sin(32623) + Math.cos(32624) * 31;
+acc += Math.sin(32624) + Math.cos(32625) * 32;
+acc += Math.sin(32625) + Math.cos(32626) * 33;
+acc += Math.sin(32626) + Math.cos(32627) * 34;
+acc += Math.sin(32627) + Math.cos(32628) * 35;
+acc += Math.sin(32628) + Math.cos(32629) * 36;
+acc += Math.sin(32629) + Math.cos(32630) * 37;
+acc += Math.sin(32630) + Math.cos(32631) * 38;
+acc += Math.sin(32631) + Math.cos(32632) * 39;
+acc += Math.sin(32632) + Math.cos(32633) * 40;
+acc += Math.sin(32633) + Math.cos(32634) * 41;
+acc += Math.sin(32634) + Math.cos(32635) * 42;
+acc += Math.sin(32635) + Math.cos(32636) * 43;
+acc += Math.sin(32636) + Math.cos(32637) * 44;
+acc += Math.sin(32637) + Math.cos(32638) * 45;
+acc += Math.sin(32638) + Math.cos(32639) * 46;
+acc += Math.sin(32639) + Math.cos(32640) * 47;
+acc += Math.sin(32640) + Math.cos(32641) * 48;
+acc += Math.sin(32641) + Math.cos(32642) * 49;
+acc += Math.sin(32642) + Math.cos(32643) * 50;
+acc += Math.sin(32643) + Math.cos(32644) * 51;
+acc += Math.sin(32644) + Math.cos(32645) * 52;
+acc += Math.sin(32645) + Math.cos(32646) * 53;
+acc += Math.sin(32646) + Math.cos(32647) * 54;
+acc += Math.sin(32647) + Math.cos(32648) * 55;
+acc += Math.sin(32648) + Math.cos(32649) * 56;
+acc += Math.sin(32649) + Math.cos(32650) * 57;
+acc += Math.sin(32650) + Math.cos(32651) * 58;
+acc += Math.sin(32651) + Math.cos(32652) * 59;
+acc += Math.sin(32652) + Math.cos(32653) * 60;
+acc += Math.sin(32653) + Math.cos(32654) * 61;
+acc += Math.sin(32654) + Math.cos(32655) * 62;
+acc += Math.sin(32655) + Math.cos(32656) * 63;
+acc += Math.sin(32656) + Math.cos(32657) * 64;
+acc += Math.sin(32657) + Math.cos(32658) * 65;
+acc += Math.sin(32658) + Math.cos(32659) * 66;
+acc += Math.sin(32659) + Math.cos(32660) * 67;
+acc += Math.sin(32660) + Math.cos(32661) * 68;
+acc += Math.sin(32661) + Math.cos(32662) * 69;
+acc += Math.sin(32662) + Math.cos(32663) * 70;
+acc += Math.sin(32663) + Math.cos(32664) * 71;
+acc += Math.sin(32664) + Math.cos(32665) * 72;
+acc += Math.sin(32665) + Math.cos(32666) * 73;
+acc += Math.sin(32666) + Math.cos(32667) * 74;
+acc += Math.sin(32667) + Math.cos(32668) * 75;
+acc += Math.sin(32668) + Math.cos(32669) * 76;
+acc += Math.sin(32669) + Math.cos(32670) * 77;
+acc += Math.sin(32670) + Math.cos(32671) * 78;
+acc += Math.sin(32671) + Math.cos(32672) * 79;
+acc += Math.sin(32672) + Math.cos(32673) * 80;
+acc += Math.sin(32673) + Math.cos(32674) * 81;
+acc += Math.sin(32674) + Math.cos(32675) * 82;
+acc += Math.sin(32675) + Math.cos(32676) * 83;
+acc += Math.sin(32676) + Math.cos(32677) * 84;
+acc += Math.sin(32677) + Math.cos(32678) * 85;
+acc += Math.sin(32678) + Math.cos(32679) * 86;
+acc += Math.sin(32679) + Math.cos(32680) * 87;
+acc += Math.sin(32680) + Math.cos(32681) * 88;
+acc += Math.sin(32681) + Math.cos(32682) * 89;
+acc += Math.sin(32682) + Math.cos(32683) * 90;
+acc += Math.sin(32683) + Math.cos(32684) * 91;
+acc += Math.sin(32684) + Math.cos(32685) * 92;
+acc += Math.sin(32685) + Math.cos(32686) * 93;
+acc += Math.sin(32686) + Math.cos(32687) * 94;
+acc += Math.sin(32687) + Math.cos(32688) * 95;
+acc += Math.sin(32688) + Math.cos(32689) * 96;
+acc += Math.sin(32689) + Math.cos(32690) * 0;
+acc += Math.sin(32690) + Math.cos(32691) * 1;
+acc += Math.sin(32691) + Math.cos(32692) * 2;
+acc += Math.sin(32692) + Math.cos(32693) * 3;
+acc += Math.sin(32693) + Math.cos(32694) * 4;
+acc += Math.sin(32694) + Math.cos(32695) * 5;
+acc += Math.sin(32695) + Math.cos(32696) * 6;
+acc += Math.sin(32696) + Math.cos(32697) * 7;
+acc += Math.sin(32697) + Math.cos(32698) * 8;
+acc += Math.sin(32698) + Math.cos(32699) * 9;
+acc += Math.sin(32699) + Math.cos(32700) * 10;
+acc += Math.sin(32700) + Math.cos(32701) * 11;
+acc += Math.sin(32701) + Math.cos(32702) * 12;
+acc += Math.sin(32702) + Math.cos(32703) * 13;
+acc += Math.sin(32703) + Math.cos(32704) * 14;
+acc += Math.sin(32704) + Math.cos(32705) * 15;
+acc += Math.sin(32705) + Math.cos(32706) * 16;
+acc += Math.sin(32706) + Math.cos(32707) * 17;
+acc += Math.sin(32707) + Math.cos(32708) * 18;
+acc += Math.sin(32708) + Math.cos(32709) * 19;
+acc += Math.sin(32709) + Math.cos(32710) * 20;
+acc += Math.sin(32710) + Math.cos(32711) * 21;
+acc += Math.sin(32711) + Math.cos(32712) * 22;
+acc += Math.sin(32712) + Math.cos(32713) * 23;
+acc += Math.sin(32713) + Math.cos(32714) * 24;
+acc += Math.sin(32714) + Math.cos(32715) * 25;
+acc += Math.sin(32715) + Math.cos(32716) * 26;
+acc += Math.sin(32716) + Math.cos(32717) * 27;
+acc += Math.sin(32717) + Math.cos(32718) * 28;
+acc += Math.sin(32718) + Math.cos(32719) * 29;
+acc += Math.sin(32719) + Math.cos(32720) * 30;
+acc += Math.sin(32720) + Math.cos(32721) * 31;
+acc += Math.sin(32721) + Math.cos(32722) * 32;
+acc += Math.sin(32722) + Math.cos(32723) * 33;
+acc += Math.sin(32723) + Math.cos(32724) * 34;
+acc += Math.sin(32724) + Math.cos(32725) * 35;
+acc += Math.sin(32725) + Math.cos(32726) * 36;
+acc += Math.sin(32726) + Math.cos(32727) * 37;
+acc += Math.sin(32727) + Math.cos(32728) * 38;
+acc += Math.sin(32728) + Math.cos(32729) * 39;
+acc += Math.sin(32729) + Math.cos(32730) * 40;
+acc += Math.sin(32730) + Math.cos(32731) * 41;
+acc += Math.sin(32731) + Math.cos(32732) * 42;
+acc += Math.sin(32732) + Math.cos(32733) * 43;
+acc += Math.sin(32733) + Math.cos(32734) * 44;
+acc += Math.sin(32734) + Math.cos(32735) * 45;
+acc += Math.sin(32735) + Math.cos(32736) * 46;
+acc += Math.sin(32736) + Math.cos(32737) * 47;
+acc += Math.sin(32737) + Math.cos(32738) * 48;
+acc += Math.sin(32738) + Math.cos(32739) * 49;
+acc += Math.sin(32739) + Math.cos(32740) * 50;
+acc += Math.sin(32740) + Math.cos(32741) * 51;
+acc += Math.sin(32741) + Math.cos(32742) * 52;
+acc += Math.sin(32742) + Math.cos(32743) * 53;
+acc += Math.sin(32743) + Math.cos(32744) * 54;
+acc += Math.sin(32744) + Math.cos(32745) * 55;
+acc += Math.sin(32745) + Math.cos(32746) * 56;
+acc += Math.sin(32746) + Math.cos(32747) * 57;
+acc += Math.sin(32747) + Math.cos(32748) * 58;
+acc += Math.sin(32748) + Math.cos(32749) * 59;
+acc += Math.sin(32749) + Math.cos(32750) * 60;
+acc += Math.sin(32750) + Math.cos(32751) * 61;
+acc += Math.sin(32751) + Math.cos(32752) * 62;
+acc += Math.sin(32752) + Math.cos(32753) * 63;
+acc += Math.sin(32753) + Math.cos(32754) * 64;
+acc += Math.sin(32754) + Math.cos(32755) * 65;
+acc += Math.sin(32755) + Math.cos(32756) * 66;
+acc += Math.sin(32756) + Math.cos(32757) * 67;
+acc += Math.sin(32757) + Math.cos(32758) * 68;
+acc += Math.sin(32758) + Math.cos(32759) * 69;
+acc += Math.sin(32759) + Math.cos(32760) * 70;
+acc += Math.sin(32760) + Math.cos(32761) * 71;
+acc += Math.sin(32761) + Math.cos(32762) * 72;
+acc += Math.sin(32762) + Math.cos(32763) * 73;
+acc += Math.sin(32763) + Math.cos(32764) * 74;
+acc += Math.sin(32764) + Math.cos(32765) * 75;
+acc += Math.sin(32765) + Math.cos(32766) * 76;
+acc += Math.sin(32766) + Math.cos(32767) * 77;
+acc += Math.sin(32767) + Math.cos(32768) * 78;
+acc += Math.sin(32768) + Math.cos(32769) * 79;
+acc += Math.sin(32769) + Math.cos(32770) * 80;
+acc += Math.sin(32770) + Math.cos(32771) * 81;
+acc += Math.sin(32771) + Math.cos(32772) * 82;
+acc += Math.sin(32772) + Math.cos(32773) * 83;
+acc += Math.sin(32773) + Math.cos(32774) * 84;
+acc += Math.sin(32774) + Math.cos(32775) * 85;
+acc += Math.sin(32775) + Math.cos(32776) * 86;
+acc += Math.sin(32776) + Math.cos(32777) * 87;
+acc += Math.sin(32777) + Math.cos(32778) * 88;
+acc += Math.sin(32778) + Math.cos(32779) * 89;
+acc += Math.sin(32779) + Math.cos(32780) * 90;
+acc += Math.sin(32780) + Math.cos(32781) * 91;
+acc += Math.sin(32781) + Math.cos(32782) * 92;
+acc += Math.sin(32782) + Math.cos(32783) * 93;
+acc += Math.sin(32783) + Math.cos(32784) * 94;
+acc += Math.sin(32784) + Math.cos(32785) * 95;
+acc += Math.sin(32785) + Math.cos(32786) * 96;
+acc += Math.sin(32786) + Math.cos(32787) * 0;
+acc += Math.sin(32787) + Math.cos(32788) * 1;
+acc += Math.sin(32788) + Math.cos(32789) * 2;
+acc += Math.sin(32789) + Math.cos(32790) * 3;
+acc += Math.sin(32790) + Math.cos(32791) * 4;
+acc += Math.sin(32791) + Math.cos(32792) * 5;
+acc += Math.sin(32792) + Math.cos(32793) * 6;
+acc += Math.sin(32793) + Math.cos(32794) * 7;
+acc += Math.sin(32794) + Math.cos(32795) * 8;
+acc += Math.sin(32795) + Math.cos(32796) * 9;
+acc += Math.sin(32796) + Math.cos(32797) * 10;
+acc += Math.sin(32797) + Math.cos(32798) * 11;
+acc += Math.sin(32798) + Math.cos(32799) * 12;
+acc += Math.sin(32799) + Math.cos(32800) * 13;
+acc += Math.sin(32800) + Math.cos(32801) * 14;
+acc += Math.sin(32801) + Math.cos(32802) * 15;
+acc += Math.sin(32802) + Math.cos(32803) * 16;
+acc += Math.sin(32803) + Math.cos(32804) * 17;
+acc += Math.sin(32804) + Math.cos(32805) * 18;
+acc += Math.sin(32805) + Math.cos(32806) * 19;
+acc += Math.sin(32806) + Math.cos(32807) * 20;
+acc += Math.sin(32807) + Math.cos(32808) * 21;
+acc += Math.sin(32808) + Math.cos(32809) * 22;
+acc += Math.sin(32809) + Math.cos(32810) * 23;
+acc += Math.sin(32810) + Math.cos(32811) * 24;
+acc += Math.sin(32811) + Math.cos(32812) * 25;
+acc += Math.sin(32812) + Math.cos(32813) * 26;
+acc += Math.sin(32813) + Math.cos(32814) * 27;
+acc += Math.sin(32814) + Math.cos(32815) * 28;
+acc += Math.sin(32815) + Math.cos(32816) * 29;
+acc += Math.sin(32816) + Math.cos(32817) * 30;
+acc += Math.sin(32817) + Math.cos(32818) * 31;
+acc += Math.sin(32818) + Math.cos(32819) * 32;
+acc += Math.sin(32819) + Math.cos(32820) * 33;
+acc += Math.sin(32820) + Math.cos(32821) * 34;
+acc += Math.sin(32821) + Math.cos(32822) * 35;
+acc += Math.sin(32822) + Math.cos(32823) * 36;
+acc += Math.sin(32823) + Math.cos(32824) * 37;
+acc += Math.sin(32824) + Math.cos(32825) * 38;
+acc += Math.sin(32825) + Math.cos(32826) * 39;
+acc += Math.sin(32826) + Math.cos(32827) * 40;
+acc += Math.sin(32827) + Math.cos(32828) * 41;
+acc += Math.sin(32828) + Math.cos(32829) * 42;
+acc += Math.sin(32829) + Math.cos(32830) * 43;
+acc += Math.sin(32830) + Math.cos(32831) * 44;
+acc += Math.sin(32831) + Math.cos(32832) * 45;
+acc += Math.sin(32832) + Math.cos(32833) * 46;
+acc += Math.sin(32833) + Math.cos(32834) * 47;
+acc += Math.sin(32834) + Math.cos(32835) * 48;
+acc += Math.sin(32835) + Math.cos(32836) * 49;
+acc += Math.sin(32836) + Math.cos(32837) * 50;
+acc += Math.sin(32837) + Math.cos(32838) * 51;
+acc += Math.sin(32838) + Math.cos(32839) * 52;
+acc += Math.sin(32839) + Math.cos(32840) * 53;
+acc += Math.sin(32840) + Math.cos(32841) * 54;
+acc += Math.sin(32841) + Math.cos(32842) * 55;
+acc += Math.sin(32842) + Math.cos(32843) * 56;
+acc += Math.sin(32843) + Math.cos(32844) * 57;
+acc += Math.sin(32844) + Math.cos(32845) * 58;
+acc += Math.sin(32845) + Math.cos(32846) * 59;
+acc += Math.sin(32846) + Math.cos(32847) * 60;
+acc += Math.sin(32847) + Math.cos(32848) * 61;
+acc += Math.sin(32848) + Math.cos(32849) * 62;
+acc += Math.sin(32849) + Math.cos(32850) * 63;
+acc += Math.sin(32850) + Math.cos(32851) * 64;
+acc += Math.sin(32851) + Math.cos(32852) * 65;
+acc += Math.sin(32852) + Math.cos(32853) * 66;
+acc += Math.sin(32853) + Math.cos(32854) * 67;
+acc += Math.sin(32854) + Math.cos(32855) * 68;
+acc += Math.sin(32855) + Math.cos(32856) * 69;
+acc += Math.sin(32856) + Math.cos(32857) * 70;
+acc += Math.sin(32857) + Math.cos(32858) * 71;
+acc += Math.sin(32858) + Math.cos(32859) * 72;
+acc += Math.sin(32859) + Math.cos(32860) * 73;
+acc += Math.sin(32860) + Math.cos(32861) * 74;
+acc += Math.sin(32861) + Math.cos(32862) * 75;
+acc += Math.sin(32862) + Math.cos(32863) * 76;
+acc += Math.sin(32863) + Math.cos(32864) * 77;
+acc += Math.sin(32864) + Math.cos(32865) * 78;
+acc += Math.sin(32865) + Math.cos(32866) * 79;
+acc += Math.sin(32866) + Math.cos(32867) * 80;
+acc += Math.sin(32867) + Math.cos(32868) * 81;
+acc += Math.sin(32868) + Math.cos(32869) * 82;
+acc += Math.sin(32869) + Math.cos(32870) * 83;
+acc += Math.sin(32870) + Math.cos(32871) * 84;
+acc += Math.sin(32871) + Math.cos(32872) * 85;
+acc += Math.sin(32872) + Math.cos(32873) * 86;
+acc += Math.sin(32873) + Math.cos(32874) * 87;
+acc += Math.sin(32874) + Math.cos(32875) * 88;
+acc += Math.sin(32875) + Math.cos(32876) * 89;
+acc += Math.sin(32876) + Math.cos(32877) * 90;
+acc += Math.sin(32877) + Math.cos(32878) * 91;
+acc += Math.sin(32878) + Math.cos(32879) * 92;
+acc += Math.sin(32879) + Math.cos(32880) * 93;
+acc += Math.sin(32880) + Math.cos(32881) * 94;
+acc += Math.sin(32881) + Math.cos(32882) * 95;
+acc += Math.sin(32882) + Math.cos(32883) * 96;
+acc += Math.sin(32883) + Math.cos(32884) * 0;
+acc += Math.sin(32884) + Math.cos(32885) * 1;
+acc += Math.sin(32885) + Math.cos(32886) * 2;
+acc += Math.sin(32886) + Math.cos(32887) * 3;
+acc += Math.sin(32887) + Math.cos(32888) * 4;
+acc += Math.sin(32888) + Math.cos(32889) * 5;
+acc += Math.sin(32889) + Math.cos(32890) * 6;
+acc += Math.sin(32890) + Math.cos(32891) * 7;
+acc += Math.sin(32891) + Math.cos(32892) * 8;
+acc += Math.sin(32892) + Math.cos(32893) * 9;
+acc += Math.sin(32893) + Math.cos(32894) * 10;
+acc += Math.sin(32894) + Math.cos(32895) * 11;
+acc += Math.sin(32895) + Math.cos(32896) * 12;
+acc += Math.sin(32896) + Math.cos(32897) * 13;
+acc += Math.sin(32897) + Math.cos(32898) * 14;
+acc += Math.sin(32898) + Math.cos(32899) * 15;
+acc += Math.sin(32899) + Math.cos(32900) * 16;
+acc += Math.sin(32900) + Math.cos(32901) * 17;
+acc += Math.sin(32901) + Math.cos(32902) * 18;
+acc += Math.sin(32902) + Math.cos(32903) * 19;
+acc += Math.sin(32903) + Math.cos(32904) * 20;
+acc += Math.sin(32904) + Math.cos(32905) * 21;
+acc += Math.sin(32905) + Math.cos(32906) * 22;
+acc += Math.sin(32906) + Math.cos(32907) * 23;
+acc += Math.sin(32907) + Math.cos(32908) * 24;
+acc += Math.sin(32908) + Math.cos(32909) * 25;
+acc += Math.sin(32909) + Math.cos(32910) * 26;
+acc += Math.sin(32910) + Math.cos(32911) * 27;
+acc += Math.sin(32911) + Math.cos(32912) * 28;
+acc += Math.sin(32912) + Math.cos(32913) * 29;
+acc += Math.sin(32913) + Math.cos(32914) * 30;
+acc += Math.sin(32914) + Math.cos(32915) * 31;
+acc += Math.sin(32915) + Math.cos(32916) * 32;
+acc += Math.sin(32916) + Math.cos(32917) * 33;
+acc += Math.sin(32917) + Math.cos(32918) * 34;
+acc += Math.sin(32918) + Math.cos(32919) * 35;
+acc += Math.sin(32919) + Math.cos(32920) * 36;
+acc += Math.sin(32920) + Math.cos(32921) * 37;
+acc += Math.sin(32921) + Math.cos(32922) * 38;
+acc += Math.sin(32922) + Math.cos(32923) * 39;
+acc += Math.sin(32923) + Math.cos(32924) * 40;
+acc += Math.sin(32924) + Math.cos(32925) * 41;
+acc += Math.sin(32925) + Math.cos(32926) * 42;
+acc += Math.sin(32926) + Math.cos(32927) * 43;
+acc += Math.sin(32927) + Math.cos(32928) * 44;
+acc += Math.sin(32928) + Math.cos(32929) * 45;
+acc += Math.sin(32929) + Math.cos(32930) * 46;
+acc += Math.sin(32930) + Math.cos(32931) * 47;
+acc += Math.sin(32931) + Math.cos(32932) * 48;
+acc += Math.sin(32932) + Math.cos(32933) * 49;
+acc += Math.sin(32933) + Math.cos(32934) * 50;
+acc += Math.sin(32934) + Math.cos(32935) * 51;
+acc += Math.sin(32935) + Math.cos(32936) * 52;
+acc += Math.sin(32936) + Math.cos(32937) * 53;
+acc += Math.sin(32937) + Math.cos(32938) * 54;
+acc += Math.sin(32938) + Math.cos(32939) * 55;
+acc += Math.sin(32939) + Math.cos(32940) * 56;
+acc += Math.sin(32940) + Math.cos(32941) * 57;
+acc += Math.sin(32941) + Math.cos(32942) * 58;
+acc += Math.sin(32942) + Math.cos(32943) * 59;
+acc += Math.sin(32943) + Math.cos(32944) * 60;
+acc += Math.sin(32944) + Math.cos(32945) * 61;
+acc += Math.sin(32945) + Math.cos(32946) * 62;
+acc += Math.sin(32946) + Math.cos(32947) * 63;
+acc += Math.sin(32947) + Math.cos(32948) * 64;
+acc += Math.sin(32948) + Math.cos(32949) * 65;
+acc += Math.sin(32949) + Math.cos(32950) * 66;
+acc += Math.sin(32950) + Math.cos(32951) * 67;
+acc += Math.sin(32951) + Math.cos(32952) * 68;
+acc += Math.sin(32952) + Math.cos(32953) * 69;
+acc += Math.sin(32953) + Math.cos(32954) * 70;
+acc += Math.sin(32954) + Math.cos(32955) * 71;
+acc += Math.sin(32955) + Math.cos(32956) * 72;
+acc += Math.sin(32956) + Math.cos(32957) * 73;
+acc += Math.sin(32957) + Math.cos(32958) * 74;
+acc += Math.sin(32958) + Math.cos(32959) * 75;
+acc += Math.sin(32959) + Math.cos(32960) * 76;
+acc += Math.sin(32960) + Math.cos(32961) * 77;
+acc += Math.sin(32961) + Math.cos(32962) * 78;
+acc += Math.sin(32962) + Math.cos(32963) * 79;
+acc += Math.sin(32963) + Math.cos(32964) * 80;
+acc += Math.sin(32964) + Math.cos(32965) * 81;
+acc += Math.sin(32965) + Math.cos(32966) * 82;
+acc += Math.sin(32966) + Math.cos(32967) * 83;
+acc += Math.sin(32967) + Math.cos(32968) * 84;
+acc += Math.sin(32968) + Math.cos(32969) * 85;
+acc += Math.sin(32969) + Math.cos(32970) * 86;
+acc += Math.sin(32970) + Math.cos(32971) * 87;
+acc += Math.sin(32971) + Math.cos(32972) * 88;
+acc += Math.sin(32972) + Math.cos(32973) * 89;
+acc += Math.sin(32973) + Math.cos(32974) * 90;
+acc += Math.sin(32974) + Math.cos(32975) * 91;
+acc += Math.sin(32975) + Math.cos(32976) * 92;
+acc += Math.sin(32976) + Math.cos(32977) * 93;
+acc += Math.sin(32977) + Math.cos(32978) * 94;
+acc += Math.sin(32978) + Math.cos(32979) * 95;
+acc += Math.sin(32979) + Math.cos(32980) * 96;
+acc += Math.sin(32980) + Math.cos(32981) * 0;
+acc += Math.sin(32981) + Math.cos(32982) * 1;
+acc += Math.sin(32982) + Math.cos(32983) * 2;
+acc += Math.sin(32983) + Math.cos(32984) * 3;
+acc += Math.sin(32984) + Math.cos(32985) * 4;
+acc += Math.sin(32985) + Math.cos(32986) * 5;
+acc += Math.sin(32986) + Math.cos(32987) * 6;
+acc += Math.sin(32987) + Math.cos(32988) * 7;
+acc += Math.sin(32988) + Math.cos(32989) * 8;
+acc += Math.sin(32989) + Math.cos(32990) * 9;
+acc += Math.sin(32990) + Math.cos(32991) * 10;
+acc += Math.sin(32991) + Math.cos(32992) * 11;
+acc += Math.sin(32992) + Math.cos(32993) * 12;
+acc += Math.sin(32993) + Math.cos(32994) * 13;
+acc += Math.sin(32994) + Math.cos(32995) * 14;
+acc += Math.sin(32995) + Math.cos(32996) * 15;
+acc += Math.sin(32996) + Math.cos(32997) * 16;
+acc += Math.sin(32997) + Math.cos(32998) * 17;
+acc += Math.sin(32998) + Math.cos(32999) * 18;
+acc += Math.sin(32999) + Math.cos(33000) * 19;
+acc += Math.sin(33000) + Math.cos(33001) * 20;
+acc += Math.sin(33001) + Math.cos(33002) * 21;
+acc += Math.sin(33002) + Math.cos(33003) * 22;
+acc += Math.sin(33003) + Math.cos(33004) * 23;
+acc += Math.sin(33004) + Math.cos(33005) * 24;
+acc += Math.sin(33005) + Math.cos(33006) * 25;
+acc += Math.sin(33006) + Math.cos(33007) * 26;
+acc += Math.sin(33007) + Math.cos(33008) * 27;
+acc += Math.sin(33008) + Math.cos(33009) * 28;
+acc += Math.sin(33009) + Math.cos(33010) * 29;
+acc += Math.sin(33010) + Math.cos(33011) * 30;
+acc += Math.sin(33011) + Math.cos(33012) * 31;
+acc += Math.sin(33012) + Math.cos(33013) * 32;
+acc += Math.sin(33013) + Math.cos(33014) * 33;
+acc += Math.sin(33014) + Math.cos(33015) * 34;
+acc += Math.sin(33015) + Math.cos(33016) * 35;
+acc += Math.sin(33016) + Math.cos(33017) * 36;
+acc += Math.sin(33017) + Math.cos(33018) * 37;
+acc += Math.sin(33018) + Math.cos(33019) * 38;
+acc += Math.sin(33019) + Math.cos(33020) * 39;
+acc += Math.sin(33020) + Math.cos(33021) * 40;
+acc += Math.sin(33021) + Math.cos(33022) * 41;
+acc += Math.sin(33022) + Math.cos(33023) * 42;
+acc += Math.sin(33023) + Math.cos(33024) * 43;
+acc += Math.sin(33024) + Math.cos(33025) * 44;
+acc += Math.sin(33025) + Math.cos(33026) * 45;
+acc += Math.sin(33026) + Math.cos(33027) * 46;
+acc += Math.sin(33027) + Math.cos(33028) * 47;
+acc += Math.sin(33028) + Math.cos(33029) * 48;
+acc += Math.sin(33029) + Math.cos(33030) * 49;
+acc += Math.sin(33030) + Math.cos(33031) * 50;
+acc += Math.sin(33031) + Math.cos(33032) * 51;
+acc += Math.sin(33032) + Math.cos(33033) * 52;
+acc += Math.sin(33033) + Math.cos(33034) * 53;
+acc += Math.sin(33034) + Math.cos(33035) * 54;
+acc += Math.sin(33035) + Math.cos(33036) * 55;
+acc += Math.sin(33036) + Math.cos(33037) * 56;
+acc += Math.sin(33037) + Math.cos(33038) * 57;
+acc += Math.sin(33038) + Math.cos(33039) * 58;
+acc += Math.sin(33039) + Math.cos(33040) * 59;
+acc += Math.sin(33040) + Math.cos(33041) * 60;
+acc += Math.sin(33041) + Math.cos(33042) * 61;
+acc += Math.sin(33042) + Math.cos(33043) * 62;
+acc += Math.sin(33043) + Math.cos(33044) * 63;
+acc += Math.sin(33044) + Math.cos(33045) * 64;
+acc += Math.sin(33045) + Math.cos(33046) * 65;
+acc += Math.sin(33046) + Math.cos(33047) * 66;
+acc += Math.sin(33047) + Math.cos(33048) * 67;
+acc += Math.sin(33048) + Math.cos(33049) * 68;
+acc += Math.sin(33049) + Math.cos(33050) * 69;
+acc += Math.sin(33050) + Math.cos(33051) * 70;
+acc += Math.sin(33051) + Math.cos(33052) * 71;
+acc += Math.sin(33052) + Math.cos(33053) * 72;
+acc += Math.sin(33053) + Math.cos(33054) * 73;
+acc += Math.sin(33054) + Math.cos(33055) * 74;
+acc += Math.sin(33055) + Math.cos(33056) * 75;
+acc += Math.sin(33056) + Math.cos(33057) * 76;
+acc += Math.sin(33057) + Math.cos(33058) * 77;
+acc += Math.sin(33058) + Math.cos(33059) * 78;
+acc += Math.sin(33059) + Math.cos(33060) * 79;
+acc += Math.sin(33060) + Math.cos(33061) * 80;
+acc += Math.sin(33061) + Math.cos(33062) * 81;
+acc += Math.sin(33062) + Math.cos(33063) * 82;
+acc += Math.sin(33063) + Math.cos(33064) * 83;
+acc += Math.sin(33064) + Math.cos(33065) * 84;
+acc += Math.sin(33065) + Math.cos(33066) * 85;
+acc += Math.sin(33066) + Math.cos(33067) * 86;
+acc += Math.sin(33067) + Math.cos(33068) * 87;
+acc += Math.sin(33068) + Math.cos(33069) * 88;
+acc += Math.sin(33069) + Math.cos(33070) * 89;
+acc += Math.sin(33070) + Math.cos(33071) * 90;
+acc += Math.sin(33071) + Math.cos(33072) * 91;
+acc += Math.sin(33072) + Math.cos(33073) * 92;
+acc += Math.sin(33073) + Math.cos(33074) * 93;
+acc += Math.sin(33074) + Math.cos(33075) * 94;
+acc += Math.sin(33075) + Math.cos(33076) * 95;
+acc += Math.sin(33076) + Math.cos(33077) * 96;
+acc += Math.sin(33077) + Math.cos(33078) * 0;
+acc += Math.sin(33078) + Math.cos(33079) * 1;
+acc += Math.sin(33079) + Math.cos(33080) * 2;
+acc += Math.sin(33080) + Math.cos(33081) * 3;
+acc += Math.sin(33081) + Math.cos(33082) * 4;
+acc += Math.sin(33082) + Math.cos(33083) * 5;
+acc += Math.sin(33083) + Math.cos(33084) * 6;
+acc += Math.sin(33084) + Math.cos(33085) * 7;
+acc += Math.sin(33085) + Math.cos(33086) * 8;
+acc += Math.sin(33086) + Math.cos(33087) * 9;
+acc += Math.sin(33087) + Math.cos(33088) * 10;
+acc += Math.sin(33088) + Math.cos(33089) * 11;
+acc += Math.sin(33089) + Math.cos(33090) * 12;
+acc += Math.sin(33090) + Math.cos(33091) * 13;
+acc += Math.sin(33091) + Math.cos(33092) * 14;
+acc += Math.sin(33092) + Math.cos(33093) * 15;
+acc += Math.sin(33093) + Math.cos(33094) * 16;
+acc += Math.sin(33094) + Math.cos(33095) * 17;
+acc += Math.sin(33095) + Math.cos(33096) * 18;
+acc += Math.sin(33096) + Math.cos(33097) * 19;
+acc += Math.sin(33097) + Math.cos(33098) * 20;
+acc += Math.sin(33098) + Math.cos(33099) * 21;
+acc += Math.sin(33099) + Math.cos(33100) * 22;
+acc += Math.sin(33100) + Math.cos(33101) * 23;
+acc += Math.sin(33101) + Math.cos(33102) * 24;
+acc += Math.sin(33102) + Math.cos(33103) * 25;
+acc += Math.sin(33103) + Math.cos(33104) * 26;
+acc += Math.sin(33104) + Math.cos(33105) * 27;
+acc += Math.sin(33105) + Math.cos(33106) * 28;
+acc += Math.sin(33106) + Math.cos(33107) * 29;
+acc += Math.sin(33107) + Math.cos(33108) * 30;
+acc += Math.sin(33108) + Math.cos(33109) * 31;
+acc += Math.sin(33109) + Math.cos(33110) * 32;
+acc += Math.sin(33110) + Math.cos(33111) * 33;
+acc += Math.sin(33111) + Math.cos(33112) * 34;
+acc += Math.sin(33112) + Math.cos(33113) * 35;
+acc += Math.sin(33113) + Math.cos(33114) * 36;
+acc += Math.sin(33114) + Math.cos(33115) * 37;
+acc += Math.sin(33115) + Math.cos(33116) * 38;
+acc += Math.sin(33116) + Math.cos(33117) * 39;
+acc += Math.sin(33117) + Math.cos(33118) * 40;
+acc += Math.sin(33118) + Math.cos(33119) * 41;
+acc += Math.sin(33119) + Math.cos(33120) * 42;
+acc += Math.sin(33120) + Math.cos(33121) * 43;
+acc += Math.sin(33121) + Math.cos(33122) * 44;
+acc += Math.sin(33122) + Math.cos(33123) * 45;
+acc += Math.sin(33123) + Math.cos(33124) * 46;
+acc += Math.sin(33124) + Math.cos(33125) * 47;
+acc += Math.sin(33125) + Math.cos(33126) * 48;
+acc += Math.sin(33126) + Math.cos(33127) * 49;
+acc += Math.sin(33127) + Math.cos(33128) * 50;
+acc += Math.sin(33128) + Math.cos(33129) * 51;
+acc += Math.sin(33129) + Math.cos(33130) * 52;
+acc += Math.sin(33130) + Math.cos(33131) * 53;
+acc += Math.sin(33131) + Math.cos(33132) * 54;
+acc += Math.sin(33132) + Math.cos(33133) * 55;
+acc += Math.sin(33133) + Math.cos(33134) * 56;
+acc += Math.sin(33134) + Math.cos(33135) * 57;
+acc += Math.sin(33135) + Math.cos(33136) * 58;
+acc += Math.sin(33136) + Math.cos(33137) * 59;
+acc += Math.sin(33137) + Math.cos(33138) * 60;
+acc += Math.sin(33138) + Math.cos(33139) * 61;
+acc += Math.sin(33139) + Math.cos(33140) * 62;
+acc += Math.sin(33140) + Math.cos(33141) * 63;
+acc += Math.sin(33141) + Math.cos(33142) * 64;
+acc += Math.sin(33142) + Math.cos(33143) * 65;
+acc += Math.sin(33143) + Math.cos(33144) * 66;
+acc += Math.sin(33144) + Math.cos(33145) * 67;
+acc += Math.sin(33145) + Math.cos(33146) * 68;
+acc += Math.sin(33146) + Math.cos(33147) * 69;
+acc += Math.sin(33147) + Math.cos(33148) * 70;
+acc += Math.sin(33148) + Math.cos(33149) * 71;
+acc += Math.sin(33149) + Math.cos(33150) * 72;
+acc += Math.sin(33150) + Math.cos(33151) * 73;
+acc += Math.sin(33151) + Math.cos(33152) * 74;
+acc += Math.sin(33152) + Math.cos(33153) * 75;
+acc += Math.sin(33153) + Math.cos(33154) * 76;
+acc += Math.sin(33154) + Math.cos(33155) * 77;
+acc += Math.sin(33155) + Math.cos(33156) * 78;
+acc += Math.sin(33156) + Math.cos(33157) * 79;
+acc += Math.sin(33157) + Math.cos(33158) * 80;
+acc += Math.sin(33158) + Math.cos(33159) * 81;
+acc += Math.sin(33159) + Math.cos(33160) * 82;
+acc += Math.sin(33160) + Math.cos(33161) * 83;
+acc += Math.sin(33161) + Math.cos(33162) * 84;
+acc += Math.sin(33162) + Math.cos(33163) * 85;
+acc += Math.sin(33163) + Math.cos(33164) * 86;
+acc += Math.sin(33164) + Math.cos(33165) * 87;
+acc += Math.sin(33165) + Math.cos(33166) * 88;
+acc += Math.sin(33166) + Math.cos(33167) * 89;
+acc += Math.sin(33167) + Math.cos(33168) * 90;
+acc += Math.sin(33168) + Math.cos(33169) * 91;
+acc += Math.sin(33169) + Math.cos(33170) * 92;
+acc += Math.sin(33170) + Math.cos(33171) * 93;
+acc += Math.sin(33171) + Math.cos(33172) * 94;
+acc += Math.sin(33172) + Math.cos(33173) * 95;
+acc += Math.sin(33173) + Math.cos(33174) * 96;
+acc += Math.sin(33174) + Math.cos(33175) * 0;
+acc += Math.sin(33175) + Math.cos(33176) * 1;
+acc += Math.sin(33176) + Math.cos(33177) * 2;
+acc += Math.sin(33177) + Math.cos(33178) * 3;
+acc += Math.sin(33178) + Math.cos(33179) * 4;
+acc += Math.sin(33179) + Math.cos(33180) * 5;
+acc += Math.sin(33180) + Math.cos(33181) * 6;
+acc += Math.sin(33181) + Math.cos(33182) * 7;
+acc += Math.sin(33182) + Math.cos(33183) * 8;
+acc += Math.sin(33183) + Math.cos(33184) * 9;
+acc += Math.sin(33184) + Math.cos(33185) * 10;
+acc += Math.sin(33185) + Math.cos(33186) * 11;
+acc += Math.sin(33186) + Math.cos(33187) * 12;
+acc += Math.sin(33187) + Math.cos(33188) * 13;
+acc += Math.sin(33188) + Math.cos(33189) * 14;
+acc += Math.sin(33189) + Math.cos(33190) * 15;
+acc += Math.sin(33190) + Math.cos(33191) * 16;
+acc += Math.sin(33191) + Math.cos(33192) * 17;
+acc += Math.sin(33192) + Math.cos(33193) * 18;
+acc += Math.sin(33193) + Math.cos(33194) * 19;
+acc += Math.sin(33194) + Math.cos(33195) * 20;
+acc += Math.sin(33195) + Math.cos(33196) * 21;
+acc += Math.sin(33196) + Math.cos(33197) * 22;
+acc += Math.sin(33197) + Math.cos(33198) * 23;
+acc += Math.sin(33198) + Math.cos(33199) * 24;
+acc += Math.sin(33199) + Math.cos(33200) * 25;
+acc += Math.sin(33200) + Math.cos(33201) * 26;
+acc += Math.sin(33201) + Math.cos(33202) * 27;
+acc += Math.sin(33202) + Math.cos(33203) * 28;
+acc += Math.sin(33203) + Math.cos(33204) * 29;
+acc += Math.sin(33204) + Math.cos(33205) * 30;
+acc += Math.sin(33205) + Math.cos(33206) * 31;
+acc += Math.sin(33206) + Math.cos(33207) * 32;
+acc += Math.sin(33207) + Math.cos(33208) * 33;
+acc += Math.sin(33208) + Math.cos(33209) * 34;
+acc += Math.sin(33209) + Math.cos(33210) * 35;
+acc += Math.sin(33210) + Math.cos(33211) * 36;
+acc += Math.sin(33211) + Math.cos(33212) * 37;
+acc += Math.sin(33212) + Math.cos(33213) * 38;
+acc += Math.sin(33213) + Math.cos(33214) * 39;
+acc += Math.sin(33214) + Math.cos(33215) * 40;
+acc += Math.sin(33215) + Math.cos(33216) * 41;
+acc += Math.sin(33216) + Math.cos(33217) * 42;
+acc += Math.sin(33217) + Math.cos(33218) * 43;
+acc += Math.sin(33218) + Math.cos(33219) * 44;
+acc += Math.sin(33219) + Math.cos(33220) * 45;
+acc += Math.sin(33220) + Math.cos(33221) * 46;
+acc += Math.sin(33221) + Math.cos(33222) * 47;
+acc += Math.sin(33222) + Math.cos(33223) * 48;
+acc += Math.sin(33223) + Math.cos(33224) * 49;
+acc += Math.sin(33224) + Math.cos(33225) * 50;
+acc += Math.sin(33225) + Math.cos(33226) * 51;
+acc += Math.sin(33226) + Math.cos(33227) * 52;
+acc += Math.sin(33227) + Math.cos(33228) * 53;
+acc += Math.sin(33228) + Math.cos(33229) * 54;
+acc += Math.sin(33229) + Math.cos(33230) * 55;
+acc += Math.sin(33230) + Math.cos(33231) * 56;
+acc += Math.sin(33231) + Math.cos(33232) * 57;
+acc += Math.sin(33232) + Math.cos(33233) * 58;
+acc += Math.sin(33233) + Math.cos(33234) * 59;
+acc += Math.sin(33234) + Math.cos(33235) * 60;
+acc += Math.sin(33235) + Math.cos(33236) * 61;
+acc += Math.sin(33236) + Math.cos(33237) * 62;
+acc += Math.sin(33237) + Math.cos(33238) * 63;
+acc += Math.sin(33238) + Math.cos(33239) * 64;
+acc += Math.sin(33239) + Math.cos(33240) * 65;
+acc += Math.sin(33240) + Math.cos(33241) * 66;
+acc += Math.sin(33241) + Math.cos(33242) * 67;
+acc += Math.sin(33242) + Math.cos(33243) * 68;
+acc += Math.sin(33243) + Math.cos(33244) * 69;
+acc += Math.sin(33244) + Math.cos(33245) * 70;
+acc += Math.sin(33245) + Math.cos(33246) * 71;
+acc += Math.sin(33246) + Math.cos(33247) * 72;
+acc += Math.sin(33247) + Math.cos(33248) * 73;
+acc += Math.sin(33248) + Math.cos(33249) * 74;
+acc += Math.sin(33249) + Math.cos(33250) * 75;
+acc += Math.sin(33250) + Math.cos(33251) * 76;
+acc += Math.sin(33251) + Math.cos(33252) * 77;
+acc += Math.sin(33252) + Math.cos(33253) * 78;
+acc += Math.sin(33253) + Math.cos(33254) * 79;
+acc += Math.sin(33254) + Math.cos(33255) * 80;
+acc += Math.sin(33255) + Math.cos(33256) * 81;
+acc += Math.sin(33256) + Math.cos(33257) * 82;
+acc += Math.sin(33257) + Math.cos(33258) * 83;
+acc += Math.sin(33258) + Math.cos(33259) * 84;
+acc += Math.sin(33259) + Math.cos(33260) * 85;
+acc += Math.sin(33260) + Math.cos(33261) * 86;
+acc += Math.sin(33261) + Math.cos(33262) * 87;
+acc += Math.sin(33262) + Math.cos(33263) * 88;
+acc += Math.sin(33263) + Math.cos(33264) * 89;
+acc += Math.sin(33264) + Math.cos(33265) * 90;
+acc += Math.sin(33265) + Math.cos(33266) * 91;
+acc += Math.sin(33266) + Math.cos(33267) * 92;
+acc += Math.sin(33267) + Math.cos(33268) * 93;
+acc += Math.sin(33268) + Math.cos(33269) * 94;
+acc += Math.sin(33269) + Math.cos(33270) * 95;
+acc += Math.sin(33270) + Math.cos(33271) * 96;
+acc += Math.sin(33271) + Math.cos(33272) * 0;
+acc += Math.sin(33272) + Math.cos(33273) * 1;
+acc += Math.sin(33273) + Math.cos(33274) * 2;
+acc += Math.sin(33274) + Math.cos(33275) * 3;
+acc += Math.sin(33275) + Math.cos(33276) * 4;
+acc += Math.sin(33276) + Math.cos(33277) * 5;
+acc += Math.sin(33277) + Math.cos(33278) * 6;
+acc += Math.sin(33278) + Math.cos(33279) * 7;
+acc += Math.sin(33279) + Math.cos(33280) * 8;
+acc += Math.sin(33280) + Math.cos(33281) * 9;
+acc += Math.sin(33281) + Math.cos(33282) * 10;
+acc += Math.sin(33282) + Math.cos(33283) * 11;
+acc += Math.sin(33283) + Math.cos(33284) * 12;
+acc += Math.sin(33284) + Math.cos(33285) * 13;
+acc += Math.sin(33285) + Math.cos(33286) * 14;
+acc += Math.sin(33286) + Math.cos(33287) * 15;
+acc += Math.sin(33287) + Math.cos(33288) * 16;
+acc += Math.sin(33288) + Math.cos(33289) * 17;
+acc += Math.sin(33289) + Math.cos(33290) * 18;
+acc += Math.sin(33290) + Math.cos(33291) * 19;
+acc += Math.sin(33291) + Math.cos(33292) * 20;
+acc += Math.sin(33292) + Math.cos(33293) * 21;
+acc += Math.sin(33293) + Math.cos(33294) * 22;
+acc += Math.sin(33294) + Math.cos(33295) * 23;
+acc += Math.sin(33295) + Math.cos(33296) * 24;
+acc += Math.sin(33296) + Math.cos(33297) * 25;
+acc += Math.sin(33297) + Math.cos(33298) * 26;
+acc += Math.sin(33298) + Math.cos(33299) * 27;
+acc += Math.sin(33299) + Math.cos(33300) * 28;
+acc += Math.sin(33300) + Math.cos(33301) * 29;
+acc += Math.sin(33301) + Math.cos(33302) * 30;
+acc += Math.sin(33302) + Math.cos(33303) * 31;
+acc += Math.sin(33303) + Math.cos(33304) * 32;
+acc += Math.sin(33304) + Math.cos(33305) * 33;
+acc += Math.sin(33305) + Math.cos(33306) * 34;
+acc += Math.sin(33306) + Math.cos(33307) * 35;
+acc += Math.sin(33307) + Math.cos(33308) * 36;
+acc += Math.sin(33308) + Math.cos(33309) * 37;
+acc += Math.sin(33309) + Math.cos(33310) * 38;
+acc += Math.sin(33310) + Math.cos(33311) * 39;
+acc += Math.sin(33311) + Math.cos(33312) * 40;
+acc += Math.sin(33312) + Math.cos(33313) * 41;
+acc += Math.sin(33313) + Math.cos(33314) * 42;
+acc += Math.sin(33314) + Math.cos(33315) * 43;
+acc += Math.sin(33315) + Math.cos(33316) * 44;
+acc += Math.sin(33316) + Math.cos(33317) * 45;
+acc += Math.sin(33317) + Math.cos(33318) * 46;
+acc += Math.sin(33318) + Math.cos(33319) * 47;
+acc += Math.sin(33319) + Math.cos(33320) * 48;
+acc += Math.sin(33320) + Math.cos(33321) * 49;
+acc += Math.sin(33321) + Math.cos(33322) * 50;
+acc += Math.sin(33322) + Math.cos(33323) * 51;
+acc += Math.sin(33323) + Math.cos(33324) * 52;
+acc += Math.sin(33324) + Math.cos(33325) * 53;
+acc += Math.sin(33325) + Math.cos(33326) * 54;
+acc += Math.sin(33326) + Math.cos(33327) * 55;
+acc += Math.sin(33327) + Math.cos(33328) * 56;
+acc += Math.sin(33328) + Math.cos(33329) * 57;
+acc += Math.sin(33329) + Math.cos(33330) * 58;
+acc += Math.sin(33330) + Math.cos(33331) * 59;
+acc += Math.sin(33331) + Math.cos(33332) * 60;
+acc += Math.sin(33332) + Math.cos(33333) * 61;
+acc += Math.sin(33333) + Math.cos(33334) * 62;
+acc += Math.sin(33334) + Math.cos(33335) * 63;
+acc += Math.sin(33335) + Math.cos(33336) * 64;
+acc += Math.sin(33336) + Math.cos(33337) * 65;
+acc += Math.sin(33337) + Math.cos(33338) * 66;
+acc += Math.sin(33338) + Math.cos(33339) * 67;
+acc += Math.sin(33339) + Math.cos(33340) * 68;
+acc += Math.sin(33340) + Math.cos(33341) * 69;
+acc += Math.sin(33341) + Math.cos(33342) * 70;
+acc += Math.sin(33342) + Math.cos(33343) * 71;
+acc += Math.sin(33343) + Math.cos(33344) * 72;
+acc += Math.sin(33344) + Math.cos(33345) * 73;
+acc += Math.sin(33345) + Math.cos(33346) * 74;
+acc += Math.sin(33346) + Math.cos(33347) * 75;
+acc += Math.sin(33347) + Math.cos(33348) * 76;
+acc += Math.sin(33348) + Math.cos(33349) * 77;
+acc += Math.sin(33349) + Math.cos(33350) * 78;
+acc += Math.sin(33350) + Math.cos(33351) * 79;
+acc += Math.sin(33351) + Math.cos(33352) * 80;
+acc += Math.sin(33352) + Math.cos(33353) * 81;
+acc += Math.sin(33353) + Math.cos(33354) * 82;
+acc += Math.sin(33354) + Math.cos(33355) * 83;
+acc += Math.sin(33355) + Math.cos(33356) * 84;
+acc += Math.sin(33356) + Math.cos(33357) * 85;
+acc += Math.sin(33357) + Math.cos(33358) * 86;
+acc += Math.sin(33358) + Math.cos(33359) * 87;
+acc += Math.sin(33359) + Math.cos(33360) * 88;
+acc += Math.sin(33360) + Math.cos(33361) * 89;
+acc += Math.sin(33361) + Math.cos(33362) * 90;
+acc += Math.sin(33362) + Math.cos(33363) * 91;
+acc += Math.sin(33363) + Math.cos(33364) * 92;
+acc += Math.sin(33364) + Math.cos(33365) * 93;
+acc += Math.sin(33365) + Math.cos(33366) * 94;
+acc += Math.sin(33366) + Math.cos(33367) * 95;
+acc += Math.sin(33367) + Math.cos(33368) * 96;
+acc += Math.sin(33368) + Math.cos(33369) * 0;
+acc += Math.sin(33369) + Math.cos(33370) * 1;
+acc += Math.sin(33370) + Math.cos(33371) * 2;
+acc += Math.sin(33371) + Math.cos(33372) * 3;
+acc += Math.sin(33372) + Math.cos(33373) * 4;
+acc += Math.sin(33373) + Math.cos(33374) * 5;
+acc += Math.sin(33374) + Math.cos(33375) * 6;
+acc += Math.sin(33375) + Math.cos(33376) * 7;
+acc += Math.sin(33376) + Math.cos(33377) * 8;
+acc += Math.sin(33377) + Math.cos(33378) * 9;
+acc += Math.sin(33378) + Math.cos(33379) * 10;
+acc += Math.sin(33379) + Math.cos(33380) * 11;
+acc += Math.sin(33380) + Math.cos(33381) * 12;
+acc += Math.sin(33381) + Math.cos(33382) * 13;
+acc += Math.sin(33382) + Math.cos(33383) * 14;
+acc += Math.sin(33383) + Math.cos(33384) * 15;
+acc += Math.sin(33384) + Math.cos(33385) * 16;
+acc += Math.sin(33385) + Math.cos(33386) * 17;
+acc += Math.sin(33386) + Math.cos(33387) * 18;
+acc += Math.sin(33387) + Math.cos(33388) * 19;
+acc += Math.sin(33388) + Math.cos(33389) * 20;
+acc += Math.sin(33389) + Math.cos(33390) * 21;
+acc += Math.sin(33390) + Math.cos(33391) * 22;
+acc += Math.sin(33391) + Math.cos(33392) * 23;
+acc += Math.sin(33392) + Math.cos(33393) * 24;
+acc += Math.sin(33393) + Math.cos(33394) * 25;
+acc += Math.sin(33394) + Math.cos(33395) * 26;
+acc += Math.sin(33395) + Math.cos(33396) * 27;
+acc += Math.sin(33396) + Math.cos(33397) * 28;
+acc += Math.sin(33397) + Math.cos(33398) * 29;
+acc += Math.sin(33398) + Math.cos(33399) * 30;
+acc += Math.sin(33399) + Math.cos(33400) * 31;
+acc += Math.sin(33400) + Math.cos(33401) * 32;
+acc += Math.sin(33401) + Math.cos(33402) * 33;
+acc += Math.sin(33402) + Math.cos(33403) * 34;
+acc += Math.sin(33403) + Math.cos(33404) * 35;
+acc += Math.sin(33404) + Math.cos(33405) * 36;
+acc += Math.sin(33405) + Math.cos(33406) * 37;
+acc += Math.sin(33406) + Math.cos(33407) * 38;
+acc += Math.sin(33407) + Math.cos(33408) * 39;
+acc += Math.sin(33408) + Math.cos(33409) * 40;
+acc += Math.sin(33409) + Math.cos(33410) * 41;
+acc += Math.sin(33410) + Math.cos(33411) * 42;
+acc += Math.sin(33411) + Math.cos(33412) * 43;
+acc += Math.sin(33412) + Math.cos(33413) * 44;
+acc += Math.sin(33413) + Math.cos(33414) * 45;
+acc += Math.sin(33414) + Math.cos(33415) * 46;
+acc += Math.sin(33415) + Math.cos(33416) * 47;
+acc += Math.sin(33416) + Math.cos(33417) * 48;
+acc += Math.sin(33417) + Math.cos(33418) * 49;
+acc += Math.sin(33418) + Math.cos(33419) * 50;
+acc += Math.sin(33419) + Math.cos(33420) * 51;
+acc += Math.sin(33420) + Math.cos(33421) * 52;
+acc += Math.sin(33421) + Math.cos(33422) * 53;
+acc += Math.sin(33422) + Math.cos(33423) * 54;
+acc += Math.sin(33423) + Math.cos(33424) * 55;
+acc += Math.sin(33424) + Math.cos(33425) * 56;
+acc += Math.sin(33425) + Math.cos(33426) * 57;
+acc += Math.sin(33426) + Math.cos(33427) * 58;
+acc += Math.sin(33427) + Math.cos(33428) * 59;
+acc += Math.sin(33428) + Math.cos(33429) * 60;
+acc += Math.sin(33429) + Math.cos(33430) * 61;
+acc += Math.sin(33430) + Math.cos(33431) * 62;
+acc += Math.sin(33431) + Math.cos(33432) * 63;
+acc += Math.sin(33432) + Math.cos(33433) * 64;
+acc += Math.sin(33433) + Math.cos(33434) * 65;
+acc += Math.sin(33434) + Math.cos(33435) * 66;
+acc += Math.sin(33435) + Math.cos(33436) * 67;
+acc += Math.sin(33436) + Math.cos(33437) * 68;
+acc += Math.sin(33437) + Math.cos(33438) * 69;
+acc += Math.sin(33438) + Math.cos(33439) * 70;
+acc += Math.sin(33439) + Math.cos(33440) * 71;
+acc += Math.sin(33440) + Math.cos(33441) * 72;
+acc += Math.sin(33441) + Math.cos(33442) * 73;
+acc += Math.sin(33442) + Math.cos(33443) * 74;
+acc += Math.sin(33443) + Math.cos(33444) * 75;
+acc += Math.sin(33444) + Math.cos(33445) * 76;
+acc += Math.sin(33445) + Math.cos(33446) * 77;
+acc += Math.sin(33446) + Math.cos(33447) * 78;
+acc += Math.sin(33447) + Math.cos(33448) * 79;
+acc += Math.sin(33448) + Math.cos(33449) * 80;
+acc += Math.sin(33449) + Math.cos(33450) * 81;
+acc += Math.sin(33450) + Math.cos(33451) * 82;
+acc += Math.sin(33451) + Math.cos(33452) * 83;
+acc += Math.sin(33452) + Math.cos(33453) * 84;
+acc += Math.sin(33453) + Math.cos(33454) * 85;
+acc += Math.sin(33454) + Math.cos(33455) * 86;
+acc += Math.sin(33455) + Math.cos(33456) * 87;
+acc += Math.sin(33456) + Math.cos(33457) * 88;
+acc += Math.sin(33457) + Math.cos(33458) * 89;
+acc += Math.sin(33458) + Math.cos(33459) * 90;
+acc += Math.sin(33459) + Math.cos(33460) * 91;
+acc += Math.sin(33460) + Math.cos(33461) * 92;
+acc += Math.sin(33461) + Math.cos(33462) * 93;
+acc += Math.sin(33462) + Math.cos(33463) * 94;
+acc += Math.sin(33463) + Math.cos(33464) * 95;
+acc += Math.sin(33464) + Math.cos(33465) * 96;
+acc += Math.sin(33465) + Math.cos(33466) * 0;
+acc += Math.sin(33466) + Math.cos(33467) * 1;
+acc += Math.sin(33467) + Math.cos(33468) * 2;
+acc += Math.sin(33468) + Math.cos(33469) * 3;
+acc += Math.sin(33469) + Math.cos(33470) * 4;
+acc += Math.sin(33470) + Math.cos(33471) * 5;
+acc += Math.sin(33471) + Math.cos(33472) * 6;
+acc += Math.sin(33472) + Math.cos(33473) * 7;
+acc += Math.sin(33473) + Math.cos(33474) * 8;
+acc += Math.sin(33474) + Math.cos(33475) * 9;
+acc += Math.sin(33475) + Math.cos(33476) * 10;
+acc += Math.sin(33476) + Math.cos(33477) * 11;
+acc += Math.sin(33477) + Math.cos(33478) * 12;
+acc += Math.sin(33478) + Math.cos(33479) * 13;
+acc += Math.sin(33479) + Math.cos(33480) * 14;
+acc += Math.sin(33480) + Math.cos(33481) * 15;
+acc += Math.sin(33481) + Math.cos(33482) * 16;
+acc += Math.sin(33482) + Math.cos(33483) * 17;
+acc += Math.sin(33483) + Math.cos(33484) * 18;
+acc += Math.sin(33484) + Math.cos(33485) * 19;
+acc += Math.sin(33485) + Math.cos(33486) * 20;
+acc += Math.sin(33486) + Math.cos(33487) * 21;
+acc += Math.sin(33487) + Math.cos(33488) * 22;
+acc += Math.sin(33488) + Math.cos(33489) * 23;
+acc += Math.sin(33489) + Math.cos(33490) * 24;
+acc += Math.sin(33490) + Math.cos(33491) * 25;
+acc += Math.sin(33491) + Math.cos(33492) * 26;
+acc += Math.sin(33492) + Math.cos(33493) * 27;
+acc += Math.sin(33493) + Math.cos(33494) * 28;
+acc += Math.sin(33494) + Math.cos(33495) * 29;
+acc += Math.sin(33495) + Math.cos(33496) * 30;
+acc += Math.sin(33496) + Math.cos(33497) * 31;
+acc += Math.sin(33497) + Math.cos(33498) * 32;
+acc += Math.sin(33498) + Math.cos(33499) * 33;
+acc += Math.sin(33499) + Math.cos(33500) * 34;
+acc += Math.sin(33500) + Math.cos(33501) * 35;
+acc += Math.sin(33501) + Math.cos(33502) * 36;
+acc += Math.sin(33502) + Math.cos(33503) * 37;
+acc += Math.sin(33503) + Math.cos(33504) * 38;
+acc += Math.sin(33504) + Math.cos(33505) * 39;
+acc += Math.sin(33505) + Math.cos(33506) * 40;
+acc += Math.sin(33506) + Math.cos(33507) * 41;
+acc += Math.sin(33507) + Math.cos(33508) * 42;
+acc += Math.sin(33508) + Math.cos(33509) * 43;
+acc += Math.sin(33509) + Math.cos(33510) * 44;
+acc += Math.sin(33510) + Math.cos(33511) * 45;
+acc += Math.sin(33511) + Math.cos(33512) * 46;
+acc += Math.sin(33512) + Math.cos(33513) * 47;
+acc += Math.sin(33513) + Math.cos(33514) * 48;
+acc += Math.sin(33514) + Math.cos(33515) * 49;
+acc += Math.sin(33515) + Math.cos(33516) * 50;
+acc += Math.sin(33516) + Math.cos(33517) * 51;
+acc += Math.sin(33517) + Math.cos(33518) * 52;
+acc += Math.sin(33518) + Math.cos(33519) * 53;
+acc += Math.sin(33519) + Math.cos(33520) * 54;
+acc += Math.sin(33520) + Math.cos(33521) * 55;
+acc += Math.sin(33521) + Math.cos(33522) * 56;
+acc += Math.sin(33522) + Math.cos(33523) * 57;
+acc += Math.sin(33523) + Math.cos(33524) * 58;
+acc += Math.sin(33524) + Math.cos(33525) * 59;
+acc += Math.sin(33525) + Math.cos(33526) * 60;
+acc += Math.sin(33526) + Math.cos(33527) * 61;
+acc += Math.sin(33527) + Math.cos(33528) * 62;
+acc += Math.sin(33528) + Math.cos(33529) * 63;
+acc += Math.sin(33529) + Math.cos(33530) * 64;
+acc += Math.sin(33530) + Math.cos(33531) * 65;
+acc += Math.sin(33531) + Math.cos(33532) * 66;
+acc += Math.sin(33532) + Math.cos(33533) * 67;
+acc += Math.sin(33533) + Math.cos(33534) * 68;
+acc += Math.sin(33534) + Math.cos(33535) * 69;
+acc += Math.sin(33535) + Math.cos(33536) * 70;
+acc += Math.sin(33536) + Math.cos(33537) * 71;
+acc += Math.sin(33537) + Math.cos(33538) * 72;
+acc += Math.sin(33538) + Math.cos(33539) * 73;
+acc += Math.sin(33539) + Math.cos(33540) * 74;
+acc += Math.sin(33540) + Math.cos(33541) * 75;
+acc += Math.sin(33541) + Math.cos(33542) * 76;
+acc += Math.sin(33542) + Math.cos(33543) * 77;
+acc += Math.sin(33543) + Math.cos(33544) * 78;
+acc += Math.sin(33544) + Math.cos(33545) * 79;
+acc += Math.sin(33545) + Math.cos(33546) * 80;
+acc += Math.sin(33546) + Math.cos(33547) * 81;
+acc += Math.sin(33547) + Math.cos(33548) * 82;
+acc += Math.sin(33548) + Math.cos(33549) * 83;
+acc += Math.sin(33549) + Math.cos(33550) * 84;
+acc += Math.sin(33550) + Math.cos(33551) * 85;
+acc += Math.sin(33551) + Math.cos(33552) * 86;
+acc += Math.sin(33552) + Math.cos(33553) * 87;
+acc += Math.sin(33553) + Math.cos(33554) * 88;
+acc += Math.sin(33554) + Math.cos(33555) * 89;
+acc += Math.sin(33555) + Math.cos(33556) * 90;
+acc += Math.sin(33556) + Math.cos(33557) * 91;
+acc += Math.sin(33557) + Math.cos(33558) * 92;
+acc += Math.sin(33558) + Math.cos(33559) * 93;
+acc += Math.sin(33559) + Math.cos(33560) * 94;
+acc += Math.sin(33560) + Math.cos(33561) * 95;
+acc += Math.sin(33561) + Math.cos(33562) * 96;
+acc += Math.sin(33562) + Math.cos(33563) * 0;
+acc += Math.sin(33563) + Math.cos(33564) * 1;
+acc += Math.sin(33564) + Math.cos(33565) * 2;
+acc += Math.sin(33565) + Math.cos(33566) * 3;
+acc += Math.sin(33566) + Math.cos(33567) * 4;
+acc += Math.sin(33567) + Math.cos(33568) * 5;
+acc += Math.sin(33568) + Math.cos(33569) * 6;
+acc += Math.sin(33569) + Math.cos(33570) * 7;
+acc += Math.sin(33570) + Math.cos(33571) * 8;
+acc += Math.sin(33571) + Math.cos(33572) * 9;
+acc += Math.sin(33572) + Math.cos(33573) * 10;
+acc += Math.sin(33573) + Math.cos(33574) * 11;
+acc += Math.sin(33574) + Math.cos(33575) * 12;
+acc += Math.sin(33575) + Math.cos(33576) * 13;
+acc += Math.sin(33576) + Math.cos(33577) * 14;
+acc += Math.sin(33577) + Math.cos(33578) * 15;
+acc += Math.sin(33578) + Math.cos(33579) * 16;
+acc += Math.sin(33579) + Math.cos(33580) * 17;
+acc += Math.sin(33580) + Math.cos(33581) * 18;
+acc += Math.sin(33581) + Math.cos(33582) * 19;
+acc += Math.sin(33582) + Math.cos(33583) * 20;
+acc += Math.sin(33583) + Math.cos(33584) * 21;
+acc += Math.sin(33584) + Math.cos(33585) * 22;
+acc += Math.sin(33585) + Math.cos(33586) * 23;
+acc += Math.sin(33586) + Math.cos(33587) * 24;
+acc += Math.sin(33587) + Math.cos(33588) * 25;
+acc += Math.sin(33588) + Math.cos(33589) * 26;
+acc += Math.sin(33589) + Math.cos(33590) * 27;
+acc += Math.sin(33590) + Math.cos(33591) * 28;
+acc += Math.sin(33591) + Math.cos(33592) * 29;
+acc += Math.sin(33592) + Math.cos(33593) * 30;
+acc += Math.sin(33593) + Math.cos(33594) * 31;
+acc += Math.sin(33594) + Math.cos(33595) * 32;
+acc += Math.sin(33595) + Math.cos(33596) * 33;
+acc += Math.sin(33596) + Math.cos(33597) * 34;
+acc += Math.sin(33597) + Math.cos(33598) * 35;
+acc += Math.sin(33598) + Math.cos(33599) * 36;
+acc += Math.sin(33599) + Math.cos(33600) * 37;
+acc += Math.sin(33600) + Math.cos(33601) * 38;
+acc += Math.sin(33601) + Math.cos(33602) * 39;
+acc += Math.sin(33602) + Math.cos(33603) * 40;
+acc += Math.sin(33603) + Math.cos(33604) * 41;
+acc += Math.sin(33604) + Math.cos(33605) * 42;
+acc += Math.sin(33605) + Math.cos(33606) * 43;
+acc += Math.sin(33606) + Math.cos(33607) * 44;
+acc += Math.sin(33607) + Math.cos(33608) * 45;
+acc += Math.sin(33608) + Math.cos(33609) * 46;
+acc += Math.sin(33609) + Math.cos(33610) * 47;
+acc += Math.sin(33610) + Math.cos(33611) * 48;
+acc += Math.sin(33611) + Math.cos(33612) * 49;
+acc += Math.sin(33612) + Math.cos(33613) * 50;
+acc += Math.sin(33613) + Math.cos(33614) * 51;
+acc += Math.sin(33614) + Math.cos(33615) * 52;
+acc += Math.sin(33615) + Math.cos(33616) * 53;
+acc += Math.sin(33616) + Math.cos(33617) * 54;
+acc += Math.sin(33617) + Math.cos(33618) * 55;
+acc += Math.sin(33618) + Math.cos(33619) * 56;
+acc += Math.sin(33619) + Math.cos(33620) * 57;
+acc += Math.sin(33620) + Math.cos(33621) * 58;
+acc += Math.sin(33621) + Math.cos(33622) * 59;
+acc += Math.sin(33622) + Math.cos(33623) * 60;
+acc += Math.sin(33623) + Math.cos(33624) * 61;
+acc += Math.sin(33624) + Math.cos(33625) * 62;
+acc += Math.sin(33625) + Math.cos(33626) * 63;
+acc += Math.sin(33626) + Math.cos(33627) * 64;
+acc += Math.sin(33627) + Math.cos(33628) * 65;
+acc += Math.sin(33628) + Math.cos(33629) * 66;
+acc += Math.sin(33629) + Math.cos(33630) * 67;
+acc += Math.sin(33630) + Math.cos(33631) * 68;
+acc += Math.sin(33631) + Math.cos(33632) * 69;
+acc += Math.sin(33632) + Math.cos(33633) * 70;
+acc += Math.sin(33633) + Math.cos(33634) * 71;
+acc += Math.sin(33634) + Math.cos(33635) * 72;
+acc += Math.sin(33635) + Math.cos(33636) * 73;
+acc += Math.sin(33636) + Math.cos(33637) * 74;
+acc += Math.sin(33637) + Math.cos(33638) * 75;
+acc += Math.sin(33638) + Math.cos(33639) * 76;
+acc += Math.sin(33639) + Math.cos(33640) * 77;
+acc += Math.sin(33640) + Math.cos(33641) * 78;
+acc += Math.sin(33641) + Math.cos(33642) * 79;
+acc += Math.sin(33642) + Math.cos(33643) * 80;
+acc += Math.sin(33643) + Math.cos(33644) * 81;
+acc += Math.sin(33644) + Math.cos(33645) * 82;
+acc += Math.sin(33645) + Math.cos(33646) * 83;
+acc += Math.sin(33646) + Math.cos(33647) * 84;
+acc += Math.sin(33647) + Math.cos(33648) * 85;
+acc += Math.sin(33648) + Math.cos(33649) * 86;
+acc += Math.sin(33649) + Math.cos(33650) * 87;
+acc += Math.sin(33650) + Math.cos(33651) * 88;
+acc += Math.sin(33651) + Math.cos(33652) * 89;
+acc += Math.sin(33652) + Math.cos(33653) * 90;
+acc += Math.sin(33653) + Math.cos(33654) * 91;
+acc += Math.sin(33654) + Math.cos(33655) * 92;
+acc += Math.sin(33655) + Math.cos(33656) * 93;
+acc += Math.sin(33656) + Math.cos(33657) * 94;
+acc += Math.sin(33657) + Math.cos(33658) * 95;
+acc += Math.sin(33658) + Math.cos(33659) * 96;
+acc += Math.sin(33659) + Math.cos(33660) * 0;
+acc += Math.sin(33660) + Math.cos(33661) * 1;
+acc += Math.sin(33661) + Math.cos(33662) * 2;
+acc += Math.sin(33662) + Math.cos(33663) * 3;
+acc += Math.sin(33663) + Math.cos(33664) * 4;
+acc += Math.sin(33664) + Math.cos(33665) * 5;
+acc += Math.sin(33665) + Math.cos(33666) * 6;
+acc += Math.sin(33666) + Math.cos(33667) * 7;
+acc += Math.sin(33667) + Math.cos(33668) * 8;
+acc += Math.sin(33668) + Math.cos(33669) * 9;
+acc += Math.sin(33669) + Math.cos(33670) * 10;
+acc += Math.sin(33670) + Math.cos(33671) * 11;
+acc += Math.sin(33671) + Math.cos(33672) * 12;
+acc += Math.sin(33672) + Math.cos(33673) * 13;
+acc += Math.sin(33673) + Math.cos(33674) * 14;
+acc += Math.sin(33674) + Math.cos(33675) * 15;
+acc += Math.sin(33675) + Math.cos(33676) * 16;
+acc += Math.sin(33676) + Math.cos(33677) * 17;
+acc += Math.sin(33677) + Math.cos(33678) * 18;
+acc += Math.sin(33678) + Math.cos(33679) * 19;
+acc += Math.sin(33679) + Math.cos(33680) * 20;
+acc += Math.sin(33680) + Math.cos(33681) * 21;
+acc += Math.sin(33681) + Math.cos(33682) * 22;
+acc += Math.sin(33682) + Math.cos(33683) * 23;
+acc += Math.sin(33683) + Math.cos(33684) * 24;
+acc += Math.sin(33684) + Math.cos(33685) * 25;
+acc += Math.sin(33685) + Math.cos(33686) * 26;
+acc += Math.sin(33686) + Math.cos(33687) * 27;
+acc += Math.sin(33687) + Math.cos(33688) * 28;
+acc += Math.sin(33688) + Math.cos(33689) * 29;
+acc += Math.sin(33689) + Math.cos(33690) * 30;
+acc += Math.sin(33690) + Math.cos(33691) * 31;
+acc += Math.sin(33691) + Math.cos(33692) * 32;
+acc += Math.sin(33692) + Math.cos(33693) * 33;
+acc += Math.sin(33693) + Math.cos(33694) * 34;
+acc += Math.sin(33694) + Math.cos(33695) * 35;
+acc += Math.sin(33695) + Math.cos(33696) * 36;
+acc += Math.sin(33696) + Math.cos(33697) * 37;
+acc += Math.sin(33697) + Math.cos(33698) * 38;
+acc += Math.sin(33698) + Math.cos(33699) * 39;
+acc += Math.sin(33699) + Math.cos(33700) * 40;
+acc += Math.sin(33700) + Math.cos(33701) * 41;
+acc += Math.sin(33701) + Math.cos(33702) * 42;
+acc += Math.sin(33702) + Math.cos(33703) * 43;
+acc += Math.sin(33703) + Math.cos(33704) * 44;
+acc += Math.sin(33704) + Math.cos(33705) * 45;
+acc += Math.sin(33705) + Math.cos(33706) * 46;
+acc += Math.sin(33706) + Math.cos(33707) * 47;
+acc += Math.sin(33707) + Math.cos(33708) * 48;
+acc += Math.sin(33708) + Math.cos(33709) * 49;
+acc += Math.sin(33709) + Math.cos(33710) * 50;
+acc += Math.sin(33710) + Math.cos(33711) * 51;
+acc += Math.sin(33711) + Math.cos(33712) * 52;
+acc += Math.sin(33712) + Math.cos(33713) * 53;
+acc += Math.sin(33713) + Math.cos(33714) * 54;
+acc += Math.sin(33714) + Math.cos(33715) * 55;
+acc += Math.sin(33715) + Math.cos(33716) * 56;
+acc += Math.sin(33716) + Math.cos(33717) * 57;
+acc += Math.sin(33717) + Math.cos(33718) * 58;
+acc += Math.sin(33718) + Math.cos(33719) * 59;
+acc += Math.sin(33719) + Math.cos(33720) * 60;
+acc += Math.sin(33720) + Math.cos(33721) * 61;
+acc += Math.sin(33721) + Math.cos(33722) * 62;
+acc += Math.sin(33722) + Math.cos(33723) * 63;
+acc += Math.sin(33723) + Math.cos(33724) * 64;
+acc += Math.sin(33724) + Math.cos(33725) * 65;
+acc += Math.sin(33725) + Math.cos(33726) * 66;
+acc += Math.sin(33726) + Math.cos(33727) * 67;
+acc += Math.sin(33727) + Math.cos(33728) * 68;
+acc += Math.sin(33728) + Math.cos(33729) * 69;
+acc += Math.sin(33729) + Math.cos(33730) * 70;
+acc += Math.sin(33730) + Math.cos(33731) * 71;
+acc += Math.sin(33731) + Math.cos(33732) * 72;
+acc += Math.sin(33732) + Math.cos(33733) * 73;
+acc += Math.sin(33733) + Math.cos(33734) * 74;
+acc += Math.sin(33734) + Math.cos(33735) * 75;
+acc += Math.sin(33735) + Math.cos(33736) * 76;
+acc += Math.sin(33736) + Math.cos(33737) * 77;
+acc += Math.sin(33737) + Math.cos(33738) * 78;
+acc += Math.sin(33738) + Math.cos(33739) * 79;
+acc += Math.sin(33739) + Math.cos(33740) * 80;
+acc += Math.sin(33740) + Math.cos(33741) * 81;
+acc += Math.sin(33741) + Math.cos(33742) * 82;
+acc += Math.sin(33742) + Math.cos(33743) * 83;
+acc += Math.sin(33743) + Math.cos(33744) * 84;
+acc += Math.sin(33744) + Math.cos(33745) * 85;
+acc += Math.sin(33745) + Math.cos(33746) * 86;
+acc += Math.sin(33746) + Math.cos(33747) * 87;
+acc += Math.sin(33747) + Math.cos(33748) * 88;
+acc += Math.sin(33748) + Math.cos(33749) * 89;
+acc += Math.sin(33749) + Math.cos(33750) * 90;
+acc += Math.sin(33750) + Math.cos(33751) * 91;
+acc += Math.sin(33751) + Math.cos(33752) * 92;
+acc += Math.sin(33752) + Math.cos(33753) * 93;
+acc += Math.sin(33753) + Math.cos(33754) * 94;
+acc += Math.sin(33754) + Math.cos(33755) * 95;
+acc += Math.sin(33755) + Math.cos(33756) * 96;
+acc += Math.sin(33756) + Math.cos(33757) * 0;
+acc += Math.sin(33757) + Math.cos(33758) * 1;
+acc += Math.sin(33758) + Math.cos(33759) * 2;
+acc += Math.sin(33759) + Math.cos(33760) * 3;
+acc += Math.sin(33760) + Math.cos(33761) * 4;
+acc += Math.sin(33761) + Math.cos(33762) * 5;
+acc += Math.sin(33762) + Math.cos(33763) * 6;
+acc += Math.sin(33763) + Math.cos(33764) * 7;
+acc += Math.sin(33764) + Math.cos(33765) * 8;
+acc += Math.sin(33765) + Math.cos(33766) * 9;
+acc += Math.sin(33766) + Math.cos(33767) * 10;
+acc += Math.sin(33767) + Math.cos(33768) * 11;
+acc += Math.sin(33768) + Math.cos(33769) * 12;
+acc += Math.sin(33769) + Math.cos(33770) * 13;
+acc += Math.sin(33770) + Math.cos(33771) * 14;
+acc += Math.sin(33771) + Math.cos(33772) * 15;
+acc += Math.sin(33772) + Math.cos(33773) * 16;
+acc += Math.sin(33773) + Math.cos(33774) * 17;
+acc += Math.sin(33774) + Math.cos(33775) * 18;
+acc += Math.sin(33775) + Math.cos(33776) * 19;
+acc += Math.sin(33776) + Math.cos(33777) * 20;
+acc += Math.sin(33777) + Math.cos(33778) * 21;
+acc += Math.sin(33778) + Math.cos(33779) * 22;
+acc += Math.sin(33779) + Math.cos(33780) * 23;
+acc += Math.sin(33780) + Math.cos(33781) * 24;
+acc += Math.sin(33781) + Math.cos(33782) * 25;
+acc += Math.sin(33782) + Math.cos(33783) * 26;
+acc += Math.sin(33783) + Math.cos(33784) * 27;
+acc += Math.sin(33784) + Math.cos(33785) * 28;
+acc += Math.sin(33785) + Math.cos(33786) * 29;
+acc += Math.sin(33786) + Math.cos(33787) * 30;
+acc += Math.sin(33787) + Math.cos(33788) * 31;
+acc += Math.sin(33788) + Math.cos(33789) * 32;
+acc += Math.sin(33789) + Math.cos(33790) * 33;
+acc += Math.sin(33790) + Math.cos(33791) * 34;
+acc += Math.sin(33791) + Math.cos(33792) * 35;
+acc += Math.sin(33792) + Math.cos(33793) * 36;
+acc += Math.sin(33793) + Math.cos(33794) * 37;
+acc += Math.sin(33794) + Math.cos(33795) * 38;
+acc += Math.sin(33795) + Math.cos(33796) * 39;
+acc += Math.sin(33796) + Math.cos(33797) * 40;
+acc += Math.sin(33797) + Math.cos(33798) * 41;
+acc += Math.sin(33798) + Math.cos(33799) * 42;
+acc += Math.sin(33799) + Math.cos(33800) * 43;
+acc += Math.sin(33800) + Math.cos(33801) * 44;
+acc += Math.sin(33801) + Math.cos(33802) * 45;
+acc += Math.sin(33802) + Math.cos(33803) * 46;
+acc += Math.sin(33803) + Math.cos(33804) * 47;
+acc += Math.sin(33804) + Math.cos(33805) * 48;
+acc += Math.sin(33805) + Math.cos(33806) * 49;
+acc += Math.sin(33806) + Math.cos(33807) * 50;
+acc += Math.sin(33807) + Math.cos(33808) * 51;
+acc += Math.sin(33808) + Math.cos(33809) * 52;
+acc += Math.sin(33809) + Math.cos(33810) * 53;
+acc += Math.sin(33810) + Math.cos(33811) * 54;
+acc += Math.sin(33811) + Math.cos(33812) * 55;
+acc += Math.sin(33812) + Math.cos(33813) * 56;
+acc += Math.sin(33813) + Math.cos(33814) * 57;
+acc += Math.sin(33814) + Math.cos(33815) * 58;
+acc += Math.sin(33815) + Math.cos(33816) * 59;
+acc += Math.sin(33816) + Math.cos(33817) * 60;
+acc += Math.sin(33817) + Math.cos(33818) * 61;
+acc += Math.sin(33818) + Math.cos(33819) * 62;
+acc += Math.sin(33819) + Math.cos(33820) * 63;
+acc += Math.sin(33820) + Math.cos(33821) * 64;
+acc += Math.sin(33821) + Math.cos(33822) * 65;
+acc += Math.sin(33822) + Math.cos(33823) * 66;
+acc += Math.sin(33823) + Math.cos(33824) * 67;
+acc += Math.sin(33824) + Math.cos(33825) * 68;
+acc += Math.sin(33825) + Math.cos(33826) * 69;
+acc += Math.sin(33826) + Math.cos(33827) * 70;
+acc += Math.sin(33827) + Math.cos(33828) * 71;
+acc += Math.sin(33828) + Math.cos(33829) * 72;
+acc += Math.sin(33829) + Math.cos(33830) * 73;
+acc += Math.sin(33830) + Math.cos(33831) * 74;
+acc += Math.sin(33831) + Math.cos(33832) * 75;
+acc += Math.sin(33832) + Math.cos(33833) * 76;
+acc += Math.sin(33833) + Math.cos(33834) * 77;
+acc += Math.sin(33834) + Math.cos(33835) * 78;
+acc += Math.sin(33835) + Math.cos(33836) * 79;
+acc += Math.sin(33836) + Math.cos(33837) * 80;
+acc += Math.sin(33837) + Math.cos(33838) * 81;
+acc += Math.sin(33838) + Math.cos(33839) * 82;
+acc += Math.sin(33839) + Math.cos(33840) * 83;
+acc += Math.sin(33840) + Math.cos(33841) * 84;
+acc += Math.sin(33841) + Math.cos(33842) * 85;
+acc += Math.sin(33842) + Math.cos(33843) * 86;
+acc += Math.sin(33843) + Math.cos(33844) * 87;
+acc += Math.sin(33844) + Math.cos(33845) * 88;
+acc += Math.sin(33845) + Math.cos(33846) * 89;
+acc += Math.sin(33846) + Math.cos(33847) * 90;
+acc += Math.sin(33847) + Math.cos(33848) * 91;
+acc += Math.sin(33848) + Math.cos(33849) * 92;
+acc += Math.sin(33849) + Math.cos(33850) * 93;
+acc += Math.sin(33850) + Math.cos(33851) * 94;
+acc += Math.sin(33851) + Math.cos(33852) * 95;
+acc += Math.sin(33852) + Math.cos(33853) * 96;
+acc += Math.sin(33853) + Math.cos(33854) * 0;
+acc += Math.sin(33854) + Math.cos(33855) * 1;
+acc += Math.sin(33855) + Math.cos(33856) * 2;
+acc += Math.sin(33856) + Math.cos(33857) * 3;
+acc += Math.sin(33857) + Math.cos(33858) * 4;
+acc += Math.sin(33858) + Math.cos(33859) * 5;
+acc += Math.sin(33859) + Math.cos(33860) * 6;
+acc += Math.sin(33860) + Math.cos(33861) * 7;
+acc += Math.sin(33861) + Math.cos(33862) * 8;
+acc += Math.sin(33862) + Math.cos(33863) * 9;
+acc += Math.sin(33863) + Math.cos(33864) * 10;
+acc += Math.sin(33864) + Math.cos(33865) * 11;
+acc += Math.sin(33865) + Math.cos(33866) * 12;
+acc += Math.sin(33866) + Math.cos(33867) * 13;
+acc += Math.sin(33867) + Math.cos(33868) * 14;
+acc += Math.sin(33868) + Math.cos(33869) * 15;
+acc += Math.sin(33869) + Math.cos(33870) * 16;
+acc += Math.sin(33870) + Math.cos(33871) * 17;
+acc += Math.sin(33871) + Math.cos(33872) * 18;
+acc += Math.sin(33872) + Math.cos(33873) * 19;
+acc += Math.sin(33873) + Math.cos(33874) * 20;
+acc += Math.sin(33874) + Math.cos(33875) * 21;
+acc += Math.sin(33875) + Math.cos(33876) * 22;
+acc += Math.sin(33876) + Math.cos(33877) * 23;
+acc += Math.sin(33877) + Math.cos(33878) * 24;
+acc += Math.sin(33878) + Math.cos(33879) * 25;
+acc += Math.sin(33879) + Math.cos(33880) * 26;
+acc += Math.sin(33880) + Math.cos(33881) * 27;
+acc += Math.sin(33881) + Math.cos(33882) * 28;
+acc += Math.sin(33882) + Math.cos(33883) * 29;
+acc += Math.sin(33883) + Math.cos(33884) * 30;
+acc += Math.sin(33884) + Math.cos(33885) * 31;
+acc += Math.sin(33885) + Math.cos(33886) * 32;
+acc += Math.sin(33886) + Math.cos(33887) * 33;
+acc += Math.sin(33887) + Math.cos(33888) * 34;
+acc += Math.sin(33888) + Math.cos(33889) * 35;
+acc += Math.sin(33889) + Math.cos(33890) * 36;
+acc += Math.sin(33890) + Math.cos(33891) * 37;
+acc += Math.sin(33891) + Math.cos(33892) * 38;
+acc += Math.sin(33892) + Math.cos(33893) * 39;
+acc += Math.sin(33893) + Math.cos(33894) * 40;
+acc += Math.sin(33894) + Math.cos(33895) * 41;
+acc += Math.sin(33895) + Math.cos(33896) * 42;
+acc += Math.sin(33896) + Math.cos(33897) * 43;
+acc += Math.sin(33897) + Math.cos(33898) * 44;
+acc += Math.sin(33898) + Math.cos(33899) * 45;
+acc += Math.sin(33899) + Math.cos(33900) * 46;
+acc += Math.sin(33900) + Math.cos(33901) * 47;
+acc += Math.sin(33901) + Math.cos(33902) * 48;
+acc += Math.sin(33902) + Math.cos(33903) * 49;
+acc += Math.sin(33903) + Math.cos(33904) * 50;
+acc += Math.sin(33904) + Math.cos(33905) * 51;
+acc += Math.sin(33905) + Math.cos(33906) * 52;
+acc += Math.sin(33906) + Math.cos(33907) * 53;
+acc += Math.sin(33907) + Math.cos(33908) * 54;
+acc += Math.sin(33908) + Math.cos(33909) * 55;
+acc += Math.sin(33909) + Math.cos(33910) * 56;
+acc += Math.sin(33910) + Math.cos(33911) * 57;
+acc += Math.sin(33911) + Math.cos(33912) * 58;
+acc += Math.sin(33912) + Math.cos(33913) * 59;
+acc += Math.sin(33913) + Math.cos(33914) * 60;
+acc += Math.sin(33914) + Math.cos(33915) * 61;
+acc += Math.sin(33915) + Math.cos(33916) * 62;
+acc += Math.sin(33916) + Math.cos(33917) * 63;
+acc += Math.sin(33917) + Math.cos(33918) * 64;
+acc += Math.sin(33918) + Math.cos(33919) * 65;
+acc += Math.sin(33919) + Math.cos(33920) * 66;
+acc += Math.sin(33920) + Math.cos(33921) * 67;
+acc += Math.sin(33921) + Math.cos(33922) * 68;
+acc += Math.sin(33922) + Math.cos(33923) * 69;
+acc += Math.sin(33923) + Math.cos(33924) * 70;
+acc += Math.sin(33924) + Math.cos(33925) * 71;
+acc += Math.sin(33925) + Math.cos(33926) * 72;
+acc += Math.sin(33926) + Math.cos(33927) * 73;
+acc += Math.sin(33927) + Math.cos(33928) * 74;
+acc += Math.sin(33928) + Math.cos(33929) * 75;
+acc += Math.sin(33929) + Math.cos(33930) * 76;
+acc += Math.sin(33930) + Math.cos(33931) * 77;
+acc += Math.sin(33931) + Math.cos(33932) * 78;
+acc += Math.sin(33932) + Math.cos(33933) * 79;
+acc += Math.sin(33933) + Math.cos(33934) * 80;
+acc += Math.sin(33934) + Math.cos(33935) * 81;
+acc += Math.sin(33935) + Math.cos(33936) * 82;
+acc += Math.sin(33936) + Math.cos(33937) * 83;
+acc += Math.sin(33937) + Math.cos(33938) * 84;
+acc += Math.sin(33938) + Math.cos(33939) * 85;
+acc += Math.sin(33939) + Math.cos(33940) * 86;
+acc += Math.sin(33940) + Math.cos(33941) * 87;
+acc += Math.sin(33941) + Math.cos(33942) * 88;
+acc += Math.sin(33942) + Math.cos(33943) * 89;
+acc += Math.sin(33943) + Math.cos(33944) * 90;
+acc += Math.sin(33944) + Math.cos(33945) * 91;
+acc += Math.sin(33945) + Math.cos(33946) * 92;
+acc += Math.sin(33946) + Math.cos(33947) * 93;
+acc += Math.sin(33947) + Math.cos(33948) * 94;
+acc += Math.sin(33948) + Math.cos(33949) * 95;
+acc += Math.sin(33949) + Math.cos(33950) * 96;
+acc += Math.sin(33950) + Math.cos(33951) * 0;
+acc += Math.sin(33951) + Math.cos(33952) * 1;
+acc += Math.sin(33952) + Math.cos(33953) * 2;
+acc += Math.sin(33953) + Math.cos(33954) * 3;
+acc += Math.sin(33954) + Math.cos(33955) * 4;
+acc += Math.sin(33955) + Math.cos(33956) * 5;
+acc += Math.sin(33956) + Math.cos(33957) * 6;
+acc += Math.sin(33957) + Math.cos(33958) * 7;
+acc += Math.sin(33958) + Math.cos(33959) * 8;
+acc += Math.sin(33959) + Math.cos(33960) * 9;
+acc += Math.sin(33960) + Math.cos(33961) * 10;
+acc += Math.sin(33961) + Math.cos(33962) * 11;
+acc += Math.sin(33962) + Math.cos(33963) * 12;
+acc += Math.sin(33963) + Math.cos(33964) * 13;
+acc += Math.sin(33964) + Math.cos(33965) * 14;
+acc += Math.sin(33965) + Math.cos(33966) * 15;
+acc += Math.sin(33966) + Math.cos(33967) * 16;
+acc += Math.sin(33967) + Math.cos(33968) * 17;
+acc += Math.sin(33968) + Math.cos(33969) * 18;
+acc += Math.sin(33969) + Math.cos(33970) * 19;
+acc += Math.sin(33970) + Math.cos(33971) * 20;
+acc += Math.sin(33971) + Math.cos(33972) * 21;
+acc += Math.sin(33972) + Math.cos(33973) * 22;
+acc += Math.sin(33973) + Math.cos(33974) * 23;
+acc += Math.sin(33974) + Math.cos(33975) * 24;
+acc += Math.sin(33975) + Math.cos(33976) * 25;
+acc += Math.sin(33976) + Math.cos(33977) * 26;
+acc += Math.sin(33977) + Math.cos(33978) * 27;
+acc += Math.sin(33978) + Math.cos(33979) * 28;
+acc += Math.sin(33979) + Math.cos(33980) * 29;
+acc += Math.sin(33980) + Math.cos(33981) * 30;
+acc += Math.sin(33981) + Math.cos(33982) * 31;
+acc += Math.sin(33982) + Math.cos(33983) * 32;
+acc += Math.sin(33983) + Math.cos(33984) * 33;
+acc += Math.sin(33984) + Math.cos(33985) * 34;
+acc += Math.sin(33985) + Math.cos(33986) * 35;
+acc += Math.sin(33986) + Math.cos(33987) * 36;
+acc += Math.sin(33987) + Math.cos(33988) * 37;
+acc += Math.sin(33988) + Math.cos(33989) * 38;
+acc += Math.sin(33989) + Math.cos(33990) * 39;
+acc += Math.sin(33990) + Math.cos(33991) * 40;
+acc += Math.sin(33991) + Math.cos(33992) * 41;
+acc += Math.sin(33992) + Math.cos(33993) * 42;
+acc += Math.sin(33993) + Math.cos(33994) * 43;
+acc += Math.sin(33994) + Math.cos(33995) * 44;
+acc += Math.sin(33995) + Math.cos(33996) * 45;
+acc += Math.sin(33996) + Math.cos(33997) * 46;
+acc += Math.sin(33997) + Math.cos(33998) * 47;
+acc += Math.sin(33998) + Math.cos(33999) * 48;
+acc += Math.sin(33999) + Math.cos(34000) * 49;
+acc += Math.sin(34000) + Math.cos(34001) * 50;
+acc += Math.sin(34001) + Math.cos(34002) * 51;
+acc += Math.sin(34002) + Math.cos(34003) * 52;
+acc += Math.sin(34003) + Math.cos(34004) * 53;
+acc += Math.sin(34004) + Math.cos(34005) * 54;
+acc += Math.sin(34005) + Math.cos(34006) * 55;
+acc += Math.sin(34006) + Math.cos(34007) * 56;
+acc += Math.sin(34007) + Math.cos(34008) * 57;
+acc += Math.sin(34008) + Math.cos(34009) * 58;
+acc += Math.sin(34009) + Math.cos(34010) * 59;
+acc += Math.sin(34010) + Math.cos(34011) * 60;
+acc += Math.sin(34011) + Math.cos(34012) * 61;
+acc += Math.sin(34012) + Math.cos(34013) * 62;
+acc += Math.sin(34013) + Math.cos(34014) * 63;
+acc += Math.sin(34014) + Math.cos(34015) * 64;
+acc += Math.sin(34015) + Math.cos(34016) * 65;
+acc += Math.sin(34016) + Math.cos(34017) * 66;
+acc += Math.sin(34017) + Math.cos(34018) * 67;
+acc += Math.sin(34018) + Math.cos(34019) * 68;
+acc += Math.sin(34019) + Math.cos(34020) * 69;
+acc += Math.sin(34020) + Math.cos(34021) * 70;
+acc += Math.sin(34021) + Math.cos(34022) * 71;
+acc += Math.sin(34022) + Math.cos(34023) * 72;
+acc += Math.sin(34023) + Math.cos(34024) * 73;
+acc += Math.sin(34024) + Math.cos(34025) * 74;
+acc += Math.sin(34025) + Math.cos(34026) * 75;
+acc += Math.sin(34026) + Math.cos(34027) * 76;
+acc += Math.sin(34027) + Math.cos(34028) * 77;
+acc += Math.sin(34028) + Math.cos(34029) * 78;
+acc += Math.sin(34029) + Math.cos(34030) * 79;
+acc += Math.sin(34030) + Math.cos(34031) * 80;
+acc += Math.sin(34031) + Math.cos(34032) * 81;
+acc += Math.sin(34032) + Math.cos(34033) * 82;
+acc += Math.sin(34033) + Math.cos(34034) * 83;
+acc += Math.sin(34034) + Math.cos(34035) * 84;
+acc += Math.sin(34035) + Math.cos(34036) * 85;
+acc += Math.sin(34036) + Math.cos(34037) * 86;
+acc += Math.sin(34037) + Math.cos(34038) * 87;
+acc += Math.sin(34038) + Math.cos(34039) * 88;
+acc += Math.sin(34039) + Math.cos(34040) * 89;
+acc += Math.sin(34040) + Math.cos(34041) * 90;
+acc += Math.sin(34041) + Math.cos(34042) * 91;
+acc += Math.sin(34042) + Math.cos(34043) * 92;
+acc += Math.sin(34043) + Math.cos(34044) * 93;
+acc += Math.sin(34044) + Math.cos(34045) * 94;
+acc += Math.sin(34045) + Math.cos(34046) * 95;
+acc += Math.sin(34046) + Math.cos(34047) * 96;
+acc += Math.sin(34047) + Math.cos(34048) * 0;
+acc += Math.sin(34048) + Math.cos(34049) * 1;
+acc += Math.sin(34049) + Math.cos(34050) * 2;
+acc += Math.sin(34050) + Math.cos(34051) * 3;
+acc += Math.sin(34051) + Math.cos(34052) * 4;
+acc += Math.sin(34052) + Math.cos(34053) * 5;
+acc += Math.sin(34053) + Math.cos(34054) * 6;
+acc += Math.sin(34054) + Math.cos(34055) * 7;
+acc += Math.sin(34055) + Math.cos(34056) * 8;
+acc += Math.sin(34056) + Math.cos(34057) * 9;
+acc += Math.sin(34057) + Math.cos(34058) * 10;
+acc += Math.sin(34058) + Math.cos(34059) * 11;
+acc += Math.sin(34059) + Math.cos(34060) * 12;
+acc += Math.sin(34060) + Math.cos(34061) * 13;
+acc += Math.sin(34061) + Math.cos(34062) * 14;
+acc += Math.sin(34062) + Math.cos(34063) * 15;
+acc += Math.sin(34063) + Math.cos(34064) * 16;
+acc += Math.sin(34064) + Math.cos(34065) * 17;
+acc += Math.sin(34065) + Math.cos(34066) * 18;
+acc += Math.sin(34066) + Math.cos(34067) * 19;
+acc += Math.sin(34067) + Math.cos(34068) * 20;
+acc += Math.sin(34068) + Math.cos(34069) * 21;
+acc += Math.sin(34069) + Math.cos(34070) * 22;
+acc += Math.sin(34070) + Math.cos(34071) * 23;
+acc += Math.sin(34071) + Math.cos(34072) * 24;
+acc += Math.sin(34072) + Math.cos(34073) * 25;
+acc += Math.sin(34073) + Math.cos(34074) * 26;
+acc += Math.sin(34074) + Math.cos(34075) * 27;
+acc += Math.sin(34075) + Math.cos(34076) * 28;
+acc += Math.sin(34076) + Math.cos(34077) * 29;
+acc += Math.sin(34077) + Math.cos(34078) * 30;
+acc += Math.sin(34078) + Math.cos(34079) * 31;
+acc += Math.sin(34079) + Math.cos(34080) * 32;
+acc += Math.sin(34080) + Math.cos(34081) * 33;
+acc += Math.sin(34081) + Math.cos(34082) * 34;
+acc += Math.sin(34082) + Math.cos(34083) * 35;
+acc += Math.sin(34083) + Math.cos(34084) * 36;
+acc += Math.sin(34084) + Math.cos(34085) * 37;
+acc += Math.sin(34085) + Math.cos(34086) * 38;
+acc += Math.sin(34086) + Math.cos(34087) * 39;
+acc += Math.sin(34087) + Math.cos(34088) * 40;
+acc += Math.sin(34088) + Math.cos(34089) * 41;
+acc += Math.sin(34089) + Math.cos(34090) * 42;
+acc += Math.sin(34090) + Math.cos(34091) * 43;
+acc += Math.sin(34091) + Math.cos(34092) * 44;
+acc += Math.sin(34092) + Math.cos(34093) * 45;
+acc += Math.sin(34093) + Math.cos(34094) * 46;
+acc += Math.sin(34094) + Math.cos(34095) * 47;
+acc += Math.sin(34095) + Math.cos(34096) * 48;
+acc += Math.sin(34096) + Math.cos(34097) * 49;
+acc += Math.sin(34097) + Math.cos(34098) * 50;
+acc += Math.sin(34098) + Math.cos(34099) * 51;
+acc += Math.sin(34099) + Math.cos(34100) * 52;
+acc += Math.sin(34100) + Math.cos(34101) * 53;
+acc += Math.sin(34101) + Math.cos(34102) * 54;
+acc += Math.sin(34102) + Math.cos(34103) * 55;
+acc += Math.sin(34103) + Math.cos(34104) * 56;
+acc += Math.sin(34104) + Math.cos(34105) * 57;
+acc += Math.sin(34105) + Math.cos(34106) * 58;
+acc += Math.sin(34106) + Math.cos(34107) * 59;
+acc += Math.sin(34107) + Math.cos(34108) * 60;
+acc += Math.sin(34108) + Math.cos(34109) * 61;
+acc += Math.sin(34109) + Math.cos(34110) * 62;
+acc += Math.sin(34110) + Math.cos(34111) * 63;
+acc += Math.sin(34111) + Math.cos(34112) * 64;
+acc += Math.sin(34112) + Math.cos(34113) * 65;
+acc += Math.sin(34113) + Math.cos(34114) * 66;
+acc += Math.sin(34114) + Math.cos(34115) * 67;
+acc += Math.sin(34115) + Math.cos(34116) * 68;
+acc += Math.sin(34116) + Math.cos(34117) * 69;
+acc += Math.sin(34117) + Math.cos(34118) * 70;
+acc += Math.sin(34118) + Math.cos(34119) * 71;
+acc += Math.sin(34119) + Math.cos(34120) * 72;
+acc += Math.sin(34120) + Math.cos(34121) * 73;
+acc += Math.sin(34121) + Math.cos(34122) * 74;
+acc += Math.sin(34122) + Math.cos(34123) * 75;
+acc += Math.sin(34123) + Math.cos(34124) * 76;
+acc += Math.sin(34124) + Math.cos(34125) * 77;
+acc += Math.sin(34125) + Math.cos(34126) * 78;
+acc += Math.sin(34126) + Math.cos(34127) * 79;
+acc += Math.sin(34127) + Math.cos(34128) * 80;
+acc += Math.sin(34128) + Math.cos(34129) * 81;
+acc += Math.sin(34129) + Math.cos(34130) * 82;
+acc += Math.sin(34130) + Math.cos(34131) * 83;
+acc += Math.sin(34131) + Math.cos(34132) * 84;
+acc += Math.sin(34132) + Math.cos(34133) * 85;
+acc += Math.sin(34133) + Math.cos(34134) * 86;
+acc += Math.sin(34134) + Math.cos(34135) * 87;
+acc += Math.sin(34135) + Math.cos(34136) * 88;
+acc += Math.sin(34136) + Math.cos(34137) * 89;
+acc += Math.sin(34137) + Math.cos(34138) * 90;
+acc += Math.sin(34138) + Math.cos(34139) * 91;
+acc += Math.sin(34139) + Math.cos(34140) * 92;
+acc += Math.sin(34140) + Math.cos(34141) * 93;
+acc += Math.sin(34141) + Math.cos(34142) * 94;
+acc += Math.sin(34142) + Math.cos(34143) * 95;
+acc += Math.sin(34143) + Math.cos(34144) * 96;
+acc += Math.sin(34144) + Math.cos(34145) * 0;
+acc += Math.sin(34145) + Math.cos(34146) * 1;
+acc += Math.sin(34146) + Math.cos(34147) * 2;
+acc += Math.sin(34147) + Math.cos(34148) * 3;
+acc += Math.sin(34148) + Math.cos(34149) * 4;
+acc += Math.sin(34149) + Math.cos(34150) * 5;
+acc += Math.sin(34150) + Math.cos(34151) * 6;
+acc += Math.sin(34151) + Math.cos(34152) * 7;
+acc += Math.sin(34152) + Math.cos(34153) * 8;
+acc += Math.sin(34153) + Math.cos(34154) * 9;
+acc += Math.sin(34154) + Math.cos(34155) * 10;
+acc += Math.sin(34155) + Math.cos(34156) * 11;
+acc += Math.sin(34156) + Math.cos(34157) * 12;
+acc += Math.sin(34157) + Math.cos(34158) * 13;
+acc += Math.sin(34158) + Math.cos(34159) * 14;
+acc += Math.sin(34159) + Math.cos(34160) * 15;
+acc += Math.sin(34160) + Math.cos(34161) * 16;
+acc += Math.sin(34161) + Math.cos(34162) * 17;
+acc += Math.sin(34162) + Math.cos(34163) * 18;
+acc += Math.sin(34163) + Math.cos(34164) * 19;
+acc += Math.sin(34164) + Math.cos(34165) * 20;
+acc += Math.sin(34165) + Math.cos(34166) * 21;
+acc += Math.sin(34166) + Math.cos(34167) * 22;
+acc += Math.sin(34167) + Math.cos(34168) * 23;
+acc += Math.sin(34168) + Math.cos(34169) * 24;
+acc += Math.sin(34169) + Math.cos(34170) * 25;
+acc += Math.sin(34170) + Math.cos(34171) * 26;
+acc += Math.sin(34171) + Math.cos(34172) * 27;
+acc += Math.sin(34172) + Math.cos(34173) * 28;
+acc += Math.sin(34173) + Math.cos(34174) * 29;
+acc += Math.sin(34174) + Math.cos(34175) * 30;
+acc += Math.sin(34175) + Math.cos(34176) * 31;
+acc += Math.sin(34176) + Math.cos(34177) * 32;
+acc += Math.sin(34177) + Math.cos(34178) * 33;
+acc += Math.sin(34178) + Math.cos(34179) * 34;
+acc += Math.sin(34179) + Math.cos(34180) * 35;
+acc += Math.sin(34180) + Math.cos(34181) * 36;
+acc += Math.sin(34181) + Math.cos(34182) * 37;
+acc += Math.sin(34182) + Math.cos(34183) * 38;
+acc += Math.sin(34183) + Math.cos(34184) * 39;
+acc += Math.sin(34184) + Math.cos(34185) * 40;
+acc += Math.sin(34185) + Math.cos(34186) * 41;
+acc += Math.sin(34186) + Math.cos(34187) * 42;
+acc += Math.sin(34187) + Math.cos(34188) * 43;
+acc += Math.sin(34188) + Math.cos(34189) * 44;
+acc += Math.sin(34189) + Math.cos(34190) * 45;
+acc += Math.sin(34190) + Math.cos(34191) * 46;
+acc += Math.sin(34191) + Math.cos(34192) * 47;
+acc += Math.sin(34192) + Math.cos(34193) * 48;
+acc += Math.sin(34193) + Math.cos(34194) * 49;
+acc += Math.sin(34194) + Math.cos(34195) * 50;
+acc += Math.sin(34195) + Math.cos(34196) * 51;
+acc += Math.sin(34196) + Math.cos(34197) * 52;
+acc += Math.sin(34197) + Math.cos(34198) * 53;
+acc += Math.sin(34198) + Math.cos(34199) * 54;
+acc += Math.sin(34199) + Math.cos(34200) * 55;
+acc += Math.sin(34200) + Math.cos(34201) * 56;
+acc += Math.sin(34201) + Math.cos(34202) * 57;
+acc += Math.sin(34202) + Math.cos(34203) * 58;
+acc += Math.sin(34203) + Math.cos(34204) * 59;
+acc += Math.sin(34204) + Math.cos(34205) * 60;
+acc += Math.sin(34205) + Math.cos(34206) * 61;
+acc += Math.sin(34206) + Math.cos(34207) * 62;
+acc += Math.sin(34207) + Math.cos(34208) * 63;
+acc += Math.sin(34208) + Math.cos(34209) * 64;
+acc += Math.sin(34209) + Math.cos(34210) * 65;
+acc += Math.sin(34210) + Math.cos(34211) * 66;
+acc += Math.sin(34211) + Math.cos(34212) * 67;
+acc += Math.sin(34212) + Math.cos(34213) * 68;
+acc += Math.sin(34213) + Math.cos(34214) * 69;
+acc += Math.sin(34214) + Math.cos(34215) * 70;
+acc += Math.sin(34215) + Math.cos(34216) * 71;
+acc += Math.sin(34216) + Math.cos(34217) * 72;
+acc += Math.sin(34217) + Math.cos(34218) * 73;
+acc += Math.sin(34218) + Math.cos(34219) * 74;
+acc += Math.sin(34219) + Math.cos(34220) * 75;
+acc += Math.sin(34220) + Math.cos(34221) * 76;
+acc += Math.sin(34221) + Math.cos(34222) * 77;
+acc += Math.sin(34222) + Math.cos(34223) * 78;
+acc += Math.sin(34223) + Math.cos(34224) * 79;
+acc += Math.sin(34224) + Math.cos(34225) * 80;
+acc += Math.sin(34225) + Math.cos(34226) * 81;
+acc += Math.sin(34226) + Math.cos(34227) * 82;
+acc += Math.sin(34227) + Math.cos(34228) * 83;
+acc += Math.sin(34228) + Math.cos(34229) * 84;
+acc += Math.sin(34229) + Math.cos(34230) * 85;
+acc += Math.sin(34230) + Math.cos(34231) * 86;
+acc += Math.sin(34231) + Math.cos(34232) * 87;
+acc += Math.sin(34232) + Math.cos(34233) * 88;
+acc += Math.sin(34233) + Math.cos(34234) * 89;
+acc += Math.sin(34234) + Math.cos(34235) * 90;
+acc += Math.sin(34235) + Math.cos(34236) * 91;
+acc += Math.sin(34236) + Math.cos(34237) * 92;
+acc += Math.sin(34237) + Math.cos(34238) * 93;
+acc += Math.sin(34238) + Math.cos(34239) * 94;
+acc += Math.sin(34239) + Math.cos(34240) * 95;
+acc += Math.sin(34240) + Math.cos(34241) * 96;
+acc += Math.sin(34241) + Math.cos(34242) * 0;
+acc += Math.sin(34242) + Math.cos(34243) * 1;
+acc += Math.sin(34243) + Math.cos(34244) * 2;
+acc += Math.sin(34244) + Math.cos(34245) * 3;
+acc += Math.sin(34245) + Math.cos(34246) * 4;
+acc += Math.sin(34246) + Math.cos(34247) * 5;
+acc += Math.sin(34247) + Math.cos(34248) * 6;
+acc += Math.sin(34248) + Math.cos(34249) * 7;
+acc += Math.sin(34249) + Math.cos(34250) * 8;
+acc += Math.sin(34250) + Math.cos(34251) * 9;
+acc += Math.sin(34251) + Math.cos(34252) * 10;
+acc += Math.sin(34252) + Math.cos(34253) * 11;
+acc += Math.sin(34253) + Math.cos(34254) * 12;
+acc += Math.sin(34254) + Math.cos(34255) * 13;
+acc += Math.sin(34255) + Math.cos(34256) * 14;
+acc += Math.sin(34256) + Math.cos(34257) * 15;
+acc += Math.sin(34257) + Math.cos(34258) * 16;
+acc += Math.sin(34258) + Math.cos(34259) * 17;
+acc += Math.sin(34259) + Math.cos(34260) * 18;
+acc += Math.sin(34260) + Math.cos(34261) * 19;
+acc += Math.sin(34261) + Math.cos(34262) * 20;
+acc += Math.sin(34262) + Math.cos(34263) * 21;
+acc += Math.sin(34263) + Math.cos(34264) * 22;
+acc += Math.sin(34264) + Math.cos(34265) * 23;
+acc += Math.sin(34265) + Math.cos(34266) * 24;
+acc += Math.sin(34266) + Math.cos(34267) * 25;
+acc += Math.sin(34267) + Math.cos(34268) * 26;
+acc += Math.sin(34268) + Math.cos(34269) * 27;
+acc += Math.sin(34269) + Math.cos(34270) * 28;
+acc += Math.sin(34270) + Math.cos(34271) * 29;
+acc += Math.sin(34271) + Math.cos(34272) * 30;
+acc += Math.sin(34272) + Math.cos(34273) * 31;
+acc += Math.sin(34273) + Math.cos(34274) * 32;
+acc += Math.sin(34274) + Math.cos(34275) * 33;
+acc += Math.sin(34275) + Math.cos(34276) * 34;
+acc += Math.sin(34276) + Math.cos(34277) * 35;
+acc += Math.sin(34277) + Math.cos(34278) * 36;
+acc += Math.sin(34278) + Math.cos(34279) * 37;
+acc += Math.sin(34279) + Math.cos(34280) * 38;
+acc += Math.sin(34280) + Math.cos(34281) * 39;
+acc += Math.sin(34281) + Math.cos(34282) * 40;
+acc += Math.sin(34282) + Math.cos(34283) * 41;
+acc += Math.sin(34283) + Math.cos(34284) * 42;
+acc += Math.sin(34284) + Math.cos(34285) * 43;
+acc += Math.sin(34285) + Math.cos(34286) * 44;
+acc += Math.sin(34286) + Math.cos(34287) * 45;
+acc += Math.sin(34287) + Math.cos(34288) * 46;
+acc += Math.sin(34288) + Math.cos(34289) * 47;
+acc += Math.sin(34289) + Math.cos(34290) * 48;
+acc += Math.sin(34290) + Math.cos(34291) * 49;
+acc += Math.sin(34291) + Math.cos(34292) * 50;
+acc += Math.sin(34292) + Math.cos(34293) * 51;
+acc += Math.sin(34293) + Math.cos(34294) * 52;
+acc += Math.sin(34294) + Math.cos(34295) * 53;
+acc += Math.sin(34295) + Math.cos(34296) * 54;
+acc += Math.sin(34296) + Math.cos(34297) * 55;
+acc += Math.sin(34297) + Math.cos(34298) * 56;
+acc += Math.sin(34298) + Math.cos(34299) * 57;
+acc += Math.sin(34299) + Math.cos(34300) * 58;
+acc += Math.sin(34300) + Math.cos(34301) * 59;
+acc += Math.sin(34301) + Math.cos(34302) * 60;
+acc += Math.sin(34302) + Math.cos(34303) * 61;
+acc += Math.sin(34303) + Math.cos(34304) * 62;
+acc += Math.sin(34304) + Math.cos(34305) * 63;
+acc += Math.sin(34305) + Math.cos(34306) * 64;
+acc += Math.sin(34306) + Math.cos(34307) * 65;
+acc += Math.sin(34307) + Math.cos(34308) * 66;
+acc += Math.sin(34308) + Math.cos(34309) * 67;
+acc += Math.sin(34309) + Math.cos(34310) * 68;
+acc += Math.sin(34310) + Math.cos(34311) * 69;
+acc += Math.sin(34311) + Math.cos(34312) * 70;
+acc += Math.sin(34312) + Math.cos(34313) * 71;
+acc += Math.sin(34313) + Math.cos(34314) * 72;
+acc += Math.sin(34314) + Math.cos(34315) * 73;
+acc += Math.sin(34315) + Math.cos(34316) * 74;
+acc += Math.sin(34316) + Math.cos(34317) * 75;
+acc += Math.sin(34317) + Math.cos(34318) * 76;
+acc += Math.sin(34318) + Math.cos(34319) * 77;
+acc += Math.sin(34319) + Math.cos(34320) * 78;
+acc += Math.sin(34320) + Math.cos(34321) * 79;
+acc += Math.sin(34321) + Math.cos(34322) * 80;
+acc += Math.sin(34322) + Math.cos(34323) * 81;
+acc += Math.sin(34323) + Math.cos(34324) * 82;
+acc += Math.sin(34324) + Math.cos(34325) * 83;
+acc += Math.sin(34325) + Math.cos(34326) * 84;
+acc += Math.sin(34326) + Math.cos(34327) * 85;
+acc += Math.sin(34327) + Math.cos(34328) * 86;
+acc += Math.sin(34328) + Math.cos(34329) * 87;
+acc += Math.sin(34329) + Math.cos(34330) * 88;
+acc += Math.sin(34330) + Math.cos(34331) * 89;
+acc += Math.sin(34331) + Math.cos(34332) * 90;
+acc += Math.sin(34332) + Math.cos(34333) * 91;
+acc += Math.sin(34333) + Math.cos(34334) * 92;
+acc += Math.sin(34334) + Math.cos(34335) * 93;
+acc += Math.sin(34335) + Math.cos(34336) * 94;
+acc += Math.sin(34336) + Math.cos(34337) * 95;
+acc += Math.sin(34337) + Math.cos(34338) * 96;
+acc += Math.sin(34338) + Math.cos(34339) * 0;
+acc += Math.sin(34339) + Math.cos(34340) * 1;
+acc += Math.sin(34340) + Math.cos(34341) * 2;
+acc += Math.sin(34341) + Math.cos(34342) * 3;
+acc += Math.sin(34342) + Math.cos(34343) * 4;
+acc += Math.sin(34343) + Math.cos(34344) * 5;
+acc += Math.sin(34344) + Math.cos(34345) * 6;
+acc += Math.sin(34345) + Math.cos(34346) * 7;
+acc += Math.sin(34346) + Math.cos(34347) * 8;
+acc += Math.sin(34347) + Math.cos(34348) * 9;
+acc += Math.sin(34348) + Math.cos(34349) * 10;
+acc += Math.sin(34349) + Math.cos(34350) * 11;
+acc += Math.sin(34350) + Math.cos(34351) * 12;
+acc += Math.sin(34351) + Math.cos(34352) * 13;
+acc += Math.sin(34352) + Math.cos(34353) * 14;
+acc += Math.sin(34353) + Math.cos(34354) * 15;
+acc += Math.sin(34354) + Math.cos(34355) * 16;
+acc += Math.sin(34355) + Math.cos(34356) * 17;
+acc += Math.sin(34356) + Math.cos(34357) * 18;
+acc += Math.sin(34357) + Math.cos(34358) * 19;
+acc += Math.sin(34358) + Math.cos(34359) * 20;
+acc += Math.sin(34359) + Math.cos(34360) * 21;
+acc += Math.sin(34360) + Math.cos(34361) * 22;
+acc += Math.sin(34361) + Math.cos(34362) * 23;
+acc += Math.sin(34362) + Math.cos(34363) * 24;
+acc += Math.sin(34363) + Math.cos(34364) * 25;
+acc += Math.sin(34364) + Math.cos(34365) * 26;
+acc += Math.sin(34365) + Math.cos(34366) * 27;
+acc += Math.sin(34366) + Math.cos(34367) * 28;
+acc += Math.sin(34367) + Math.cos(34368) * 29;
+acc += Math.sin(34368) + Math.cos(34369) * 30;
+acc += Math.sin(34369) + Math.cos(34370) * 31;
+acc += Math.sin(34370) + Math.cos(34371) * 32;
+acc += Math.sin(34371) + Math.cos(34372) * 33;
+acc += Math.sin(34372) + Math.cos(34373) * 34;
+acc += Math.sin(34373) + Math.cos(34374) * 35;
+acc += Math.sin(34374) + Math.cos(34375) * 36;
+acc += Math.sin(34375) + Math.cos(34376) * 37;
+acc += Math.sin(34376) + Math.cos(34377) * 38;
+acc += Math.sin(34377) + Math.cos(34378) * 39;
+acc += Math.sin(34378) + Math.cos(34379) * 40;
+acc += Math.sin(34379) + Math.cos(34380) * 41;
+acc += Math.sin(34380) + Math.cos(34381) * 42;
+acc += Math.sin(34381) + Math.cos(34382) * 43;
+acc += Math.sin(34382) + Math.cos(34383) * 44;
+acc += Math.sin(34383) + Math.cos(34384) * 45;
+acc += Math.sin(34384) + Math.cos(34385) * 46;
+acc += Math.sin(34385) + Math.cos(34386) * 47;
+acc += Math.sin(34386) + Math.cos(34387) * 48;
+acc += Math.sin(34387) + Math.cos(34388) * 49;
+acc += Math.sin(34388) + Math.cos(34389) * 50;
+acc += Math.sin(34389) + Math.cos(34390) * 51;
+acc += Math.sin(34390) + Math.cos(34391) * 52;
+acc += Math.sin(34391) + Math.cos(34392) * 53;
+acc += Math.sin(34392) + Math.cos(34393) * 54;
+acc += Math.sin(34393) + Math.cos(34394) * 55;
+acc += Math.sin(34394) + Math.cos(34395) * 56;
+acc += Math.sin(34395) + Math.cos(34396) * 57;
+acc += Math.sin(34396) + Math.cos(34397) * 58;
+acc += Math.sin(34397) + Math.cos(34398) * 59;
+acc += Math.sin(34398) + Math.cos(34399) * 60;
+acc += Math.sin(34399) + Math.cos(34400) * 61;
+acc += Math.sin(34400) + Math.cos(34401) * 62;
+acc += Math.sin(34401) + Math.cos(34402) * 63;
+acc += Math.sin(34402) + Math.cos(34403) * 64;
+acc += Math.sin(34403) + Math.cos(34404) * 65;
+acc += Math.sin(34404) + Math.cos(34405) * 66;
+acc += Math.sin(34405) + Math.cos(34406) * 67;
+acc += Math.sin(34406) + Math.cos(34407) * 68;
+acc += Math.sin(34407) + Math.cos(34408) * 69;
+acc += Math.sin(34408) + Math.cos(34409) * 70;
+acc += Math.sin(34409) + Math.cos(34410) * 71;
+acc += Math.sin(34410) + Math.cos(34411) * 72;
+acc += Math.sin(34411) + Math.cos(34412) * 73;
+acc += Math.sin(34412) + Math.cos(34413) * 74;
+acc += Math.sin(34413) + Math.cos(34414) * 75;
+acc += Math.sin(34414) + Math.cos(34415) * 76;
+acc += Math.sin(34415) + Math.cos(34416) * 77;
+acc += Math.sin(34416) + Math.cos(34417) * 78;
+acc += Math.sin(34417) + Math.cos(34418) * 79;
+acc += Math.sin(34418) + Math.cos(34419) * 80;
+acc += Math.sin(34419) + Math.cos(34420) * 81;
+acc += Math.sin(34420) + Math.cos(34421) * 82;
+acc += Math.sin(34421) + Math.cos(34422) * 83;
+acc += Math.sin(34422) + Math.cos(34423) * 84;
+acc += Math.sin(34423) + Math.cos(34424) * 85;
+acc += Math.sin(34424) + Math.cos(34425) * 86;
+acc += Math.sin(34425) + Math.cos(34426) * 87;
+acc += Math.sin(34426) + Math.cos(34427) * 88;
+acc += Math.sin(34427) + Math.cos(34428) * 89;
+acc += Math.sin(34428) + Math.cos(34429) * 90;
+acc += Math.sin(34429) + Math.cos(34430) * 91;
+acc += Math.sin(34430) + Math.cos(34431) * 92;
+acc += Math.sin(34431) + Math.cos(34432) * 93;
+acc += Math.sin(34432) + Math.cos(34433) * 94;
+acc += Math.sin(34433) + Math.cos(34434) * 95;
+acc += Math.sin(34434) + Math.cos(34435) * 96;
+acc += Math.sin(34435) + Math.cos(34436) * 0;
+acc += Math.sin(34436) + Math.cos(34437) * 1;
+acc += Math.sin(34437) + Math.cos(34438) * 2;
+acc += Math.sin(34438) + Math.cos(34439) * 3;
+acc += Math.sin(34439) + Math.cos(34440) * 4;
+acc += Math.sin(34440) + Math.cos(34441) * 5;
+acc += Math.sin(34441) + Math.cos(34442) * 6;
+acc += Math.sin(34442) + Math.cos(34443) * 7;
+acc += Math.sin(34443) + Math.cos(34444) * 8;
+acc += Math.sin(34444) + Math.cos(34445) * 9;
+acc += Math.sin(34445) + Math.cos(34446) * 10;
+acc += Math.sin(34446) + Math.cos(34447) * 11;
+acc += Math.sin(34447) + Math.cos(34448) * 12;
+acc += Math.sin(34448) + Math.cos(34449) * 13;
+acc += Math.sin(34449) + Math.cos(34450) * 14;
+acc += Math.sin(34450) + Math.cos(34451) * 15;
+acc += Math.sin(34451) + Math.cos(34452) * 16;
+acc += Math.sin(34452) + Math.cos(34453) * 17;
+acc += Math.sin(34453) + Math.cos(34454) * 18;
+acc += Math.sin(34454) + Math.cos(34455) * 19;
+acc += Math.sin(34455) + Math.cos(34456) * 20;
+acc += Math.sin(34456) + Math.cos(34457) * 21;
+acc += Math.sin(34457) + Math.cos(34458) * 22;
+acc += Math.sin(34458) + Math.cos(34459) * 23;
+acc += Math.sin(34459) + Math.cos(34460) * 24;
+acc += Math.sin(34460) + Math.cos(34461) * 25;
+acc += Math.sin(34461) + Math.cos(34462) * 26;
+acc += Math.sin(34462) + Math.cos(34463) * 27;
+acc += Math.sin(34463) + Math.cos(34464) * 28;
+acc += Math.sin(34464) + Math.cos(34465) * 29;
+acc += Math.sin(34465) + Math.cos(34466) * 30;
+acc += Math.sin(34466) + Math.cos(34467) * 31;
+acc += Math.sin(34467) + Math.cos(34468) * 32;
+acc += Math.sin(34468) + Math.cos(34469) * 33;
+acc += Math.sin(34469) + Math.cos(34470) * 34;
+acc += Math.sin(34470) + Math.cos(34471) * 35;
+acc += Math.sin(34471) + Math.cos(34472) * 36;
+acc += Math.sin(34472) + Math.cos(34473) * 37;
+acc += Math.sin(34473) + Math.cos(34474) * 38;
+acc += Math.sin(34474) + Math.cos(34475) * 39;
+acc += Math.sin(34475) + Math.cos(34476) * 40;
+acc += Math.sin(34476) + Math.cos(34477) * 41;
+acc += Math.sin(34477) + Math.cos(34478) * 42;
+acc += Math.sin(34478) + Math.cos(34479) * 43;
+acc += Math.sin(34479) + Math.cos(34480) * 44;
+acc += Math.sin(34480) + Math.cos(34481) * 45;
+acc += Math.sin(34481) + Math.cos(34482) * 46;
+acc += Math.sin(34482) + Math.cos(34483) * 47;
+acc += Math.sin(34483) + Math.cos(34484) * 48;
+acc += Math.sin(34484) + Math.cos(34485) * 49;
+acc += Math.sin(34485) + Math.cos(34486) * 50;
+acc += Math.sin(34486) + Math.cos(34487) * 51;
+acc += Math.sin(34487) + Math.cos(34488) * 52;
+acc += Math.sin(34488) + Math.cos(34489) * 53;
+acc += Math.sin(34489) + Math.cos(34490) * 54;
+acc += Math.sin(34490) + Math.cos(34491) * 55;
+acc += Math.sin(34491) + Math.cos(34492) * 56;
+acc += Math.sin(34492) + Math.cos(34493) * 57;
+acc += Math.sin(34493) + Math.cos(34494) * 58;
+acc += Math.sin(34494) + Math.cos(34495) * 59;
+acc += Math.sin(34495) + Math.cos(34496) * 60;
+acc += Math.sin(34496) + Math.cos(34497) * 61;
+acc += Math.sin(34497) + Math.cos(34498) * 62;
+acc += Math.sin(34498) + Math.cos(34499) * 63;
+acc += Math.sin(34499) + Math.cos(34500) * 64;
+acc += Math.sin(34500) + Math.cos(34501) * 65;
+acc += Math.sin(34501) + Math.cos(34502) * 66;
+acc += Math.sin(34502) + Math.cos(34503) * 67;
+acc += Math.sin(34503) + Math.cos(34504) * 68;
+acc += Math.sin(34504) + Math.cos(34505) * 69;
+acc += Math.sin(34505) + Math.cos(34506) * 70;
+acc += Math.sin(34506) + Math.cos(34507) * 71;
+acc += Math.sin(34507) + Math.cos(34508) * 72;
+acc += Math.sin(34508) + Math.cos(34509) * 73;
+acc += Math.sin(34509) + Math.cos(34510) * 74;
+acc += Math.sin(34510) + Math.cos(34511) * 75;
+acc += Math.sin(34511) + Math.cos(34512) * 76;
+acc += Math.sin(34512) + Math.cos(34513) * 77;
+acc += Math.sin(34513) + Math.cos(34514) * 78;
+acc += Math.sin(34514) + Math.cos(34515) * 79;
+acc += Math.sin(34515) + Math.cos(34516) * 80;
+acc += Math.sin(34516) + Math.cos(34517) * 81;
+acc += Math.sin(34517) + Math.cos(34518) * 82;
+acc += Math.sin(34518) + Math.cos(34519) * 83;
+acc += Math.sin(34519) + Math.cos(34520) * 84;
+acc += Math.sin(34520) + Math.cos(34521) * 85;
+acc += Math.sin(34521) + Math.cos(34522) * 86;
+acc += Math.sin(34522) + Math.cos(34523) * 87;
+acc += Math.sin(34523) + Math.cos(34524) * 88;
+acc += Math.sin(34524) + Math.cos(34525) * 89;
+acc += Math.sin(34525) + Math.cos(34526) * 90;
+acc += Math.sin(34526) + Math.cos(34527) * 91;
+acc += Math.sin(34527) + Math.cos(34528) * 92;
+acc += Math.sin(34528) + Math.cos(34529) * 93;
+acc += Math.sin(34529) + Math.cos(34530) * 94;
+acc += Math.sin(34530) + Math.cos(34531) * 95;
+acc += Math.sin(34531) + Math.cos(34532) * 96;
+acc += Math.sin(34532) + Math.cos(34533) * 0;
+acc += Math.sin(34533) + Math.cos(34534) * 1;
+acc += Math.sin(34534) + Math.cos(34535) * 2;
+acc += Math.sin(34535) + Math.cos(34536) * 3;
+acc += Math.sin(34536) + Math.cos(34537) * 4;
+acc += Math.sin(34537) + Math.cos(34538) * 5;
+acc += Math.sin(34538) + Math.cos(34539) * 6;
+acc += Math.sin(34539) + Math.cos(34540) * 7;
+acc += Math.sin(34540) + Math.cos(34541) * 8;
+acc += Math.sin(34541) + Math.cos(34542) * 9;
+acc += Math.sin(34542) + Math.cos(34543) * 10;
+acc += Math.sin(34543) + Math.cos(34544) * 11;
+acc += Math.sin(34544) + Math.cos(34545) * 12;
+acc += Math.sin(34545) + Math.cos(34546) * 13;
+acc += Math.sin(34546) + Math.cos(34547) * 14;
+acc += Math.sin(34547) + Math.cos(34548) * 15;
+acc += Math.sin(34548) + Math.cos(34549) * 16;
+acc += Math.sin(34549) + Math.cos(34550) * 17;
+acc += Math.sin(34550) + Math.cos(34551) * 18;
+acc += Math.sin(34551) + Math.cos(34552) * 19;
+acc += Math.sin(34552) + Math.cos(34553) * 20;
+acc += Math.sin(34553) + Math.cos(34554) * 21;
+acc += Math.sin(34554) + Math.cos(34555) * 22;
+acc += Math.sin(34555) + Math.cos(34556) * 23;
+acc += Math.sin(34556) + Math.cos(34557) * 24;
+acc += Math.sin(34557) + Math.cos(34558) * 25;
+acc += Math.sin(34558) + Math.cos(34559) * 26;
+acc += Math.sin(34559) + Math.cos(34560) * 27;
+acc += Math.sin(34560) + Math.cos(34561) * 28;
+acc += Math.sin(34561) + Math.cos(34562) * 29;
+acc += Math.sin(34562) + Math.cos(34563) * 30;
+acc += Math.sin(34563) + Math.cos(34564) * 31;
+acc += Math.sin(34564) + Math.cos(34565) * 32;
+acc += Math.sin(34565) + Math.cos(34566) * 33;
+acc += Math.sin(34566) + Math.cos(34567) * 34;
+acc += Math.sin(34567) + Math.cos(34568) * 35;
+acc += Math.sin(34568) + Math.cos(34569) * 36;
+acc += Math.sin(34569) + Math.cos(34570) * 37;
+acc += Math.sin(34570) + Math.cos(34571) * 38;
+acc += Math.sin(34571) + Math.cos(34572) * 39;
+acc += Math.sin(34572) + Math.cos(34573) * 40;
+acc += Math.sin(34573) + Math.cos(34574) * 41;
+acc += Math.sin(34574) + Math.cos(34575) * 42;
+acc += Math.sin(34575) + Math.cos(34576) * 43;
+acc += Math.sin(34576) + Math.cos(34577) * 44;
+acc += Math.sin(34577) + Math.cos(34578) * 45;
+acc += Math.sin(34578) + Math.cos(34579) * 46;
+acc += Math.sin(34579) + Math.cos(34580) * 47;
+acc += Math.sin(34580) + Math.cos(34581) * 48;
+acc += Math.sin(34581) + Math.cos(34582) * 49;
+acc += Math.sin(34582) + Math.cos(34583) * 50;
+acc += Math.sin(34583) + Math.cos(34584) * 51;
+acc += Math.sin(34584) + Math.cos(34585) * 52;
+acc += Math.sin(34585) + Math.cos(34586) * 53;
+acc += Math.sin(34586) + Math.cos(34587) * 54;
+acc += Math.sin(34587) + Math.cos(34588) * 55;
+acc += Math.sin(34588) + Math.cos(34589) * 56;
+acc += Math.sin(34589) + Math.cos(34590) * 57;
+acc += Math.sin(34590) + Math.cos(34591) * 58;
+acc += Math.sin(34591) + Math.cos(34592) * 59;
+acc += Math.sin(34592) + Math.cos(34593) * 60;
+acc += Math.sin(34593) + Math.cos(34594) * 61;
+acc += Math.sin(34594) + Math.cos(34595) * 62;
+acc += Math.sin(34595) + Math.cos(34596) * 63;
+acc += Math.sin(34596) + Math.cos(34597) * 64;
+acc += Math.sin(34597) + Math.cos(34598) * 65;
+acc += Math.sin(34598) + Math.cos(34599) * 66;
+acc += Math.sin(34599) + Math.cos(34600) * 67;
+acc += Math.sin(34600) + Math.cos(34601) * 68;
+acc += Math.sin(34601) + Math.cos(34602) * 69;
+acc += Math.sin(34602) + Math.cos(34603) * 70;
+acc += Math.sin(34603) + Math.cos(34604) * 71;
+acc += Math.sin(34604) + Math.cos(34605) * 72;
+acc += Math.sin(34605) + Math.cos(34606) * 73;
+acc += Math.sin(34606) + Math.cos(34607) * 74;
+acc += Math.sin(34607) + Math.cos(34608) * 75;
+acc += Math.sin(34608) + Math.cos(34609) * 76;
+acc += Math.sin(34609) + Math.cos(34610) * 77;
+acc += Math.sin(34610) + Math.cos(34611) * 78;
+acc += Math.sin(34611) + Math.cos(34612) * 79;
+acc += Math.sin(34612) + Math.cos(34613) * 80;
+acc += Math.sin(34613) + Math.cos(34614) * 81;
+acc += Math.sin(34614) + Math.cos(34615) * 82;
+acc += Math.sin(34615) + Math.cos(34616) * 83;
+acc += Math.sin(34616) + Math.cos(34617) * 84;
+acc += Math.sin(34617) + Math.cos(34618) * 85;
+acc += Math.sin(34618) + Math.cos(34619) * 86;
+acc += Math.sin(34619) + Math.cos(34620) * 87;
+acc += Math.sin(34620) + Math.cos(34621) * 88;
+acc += Math.sin(34621) + Math.cos(34622) * 89;
+acc += Math.sin(34622) + Math.cos(34623) * 90;
+acc += Math.sin(34623) + Math.cos(34624) * 91;
+acc += Math.sin(34624) + Math.cos(34625) * 92;
+acc += Math.sin(34625) + Math.cos(34626) * 93;
+acc += Math.sin(34626) + Math.cos(34627) * 94;
+acc += Math.sin(34627) + Math.cos(34628) * 95;
+acc += Math.sin(34628) + Math.cos(34629) * 96;
+acc += Math.sin(34629) + Math.cos(34630) * 0;
+acc += Math.sin(34630) + Math.cos(34631) * 1;
+acc += Math.sin(34631) + Math.cos(34632) * 2;
+acc += Math.sin(34632) + Math.cos(34633) * 3;
+acc += Math.sin(34633) + Math.cos(34634) * 4;
+acc += Math.sin(34634) + Math.cos(34635) * 5;
+acc += Math.sin(34635) + Math.cos(34636) * 6;
+acc += Math.sin(34636) + Math.cos(34637) * 7;
+acc += Math.sin(34637) + Math.cos(34638) * 8;
+acc += Math.sin(34638) + Math.cos(34639) * 9;
+acc += Math.sin(34639) + Math.cos(34640) * 10;
+acc += Math.sin(34640) + Math.cos(34641) * 11;
+acc += Math.sin(34641) + Math.cos(34642) * 12;
+acc += Math.sin(34642) + Math.cos(34643) * 13;
+acc += Math.sin(34643) + Math.cos(34644) * 14;
+acc += Math.sin(34644) + Math.cos(34645) * 15;
+acc += Math.sin(34645) + Math.cos(34646) * 16;
+acc += Math.sin(34646) + Math.cos(34647) * 17;
+acc += Math.sin(34647) + Math.cos(34648) * 18;
+acc += Math.sin(34648) + Math.cos(34649) * 19;
+acc += Math.sin(34649) + Math.cos(34650) * 20;
+acc += Math.sin(34650) + Math.cos(34651) * 21;
+acc += Math.sin(34651) + Math.cos(34652) * 22;
+acc += Math.sin(34652) + Math.cos(34653) * 23;
+acc += Math.sin(34653) + Math.cos(34654) * 24;
+acc += Math.sin(34654) + Math.cos(34655) * 25;
+acc += Math.sin(34655) + Math.cos(34656) * 26;
+acc += Math.sin(34656) + Math.cos(34657) * 27;
+acc += Math.sin(34657) + Math.cos(34658) * 28;
+acc += Math.sin(34658) + Math.cos(34659) * 29;
+acc += Math.sin(34659) + Math.cos(34660) * 30;
+acc += Math.sin(34660) + Math.cos(34661) * 31;
+acc += Math.sin(34661) + Math.cos(34662) * 32;
+acc += Math.sin(34662) + Math.cos(34663) * 33;
+acc += Math.sin(34663) + Math.cos(34664) * 34;
+acc += Math.sin(34664) + Math.cos(34665) * 35;
+acc += Math.sin(34665) + Math.cos(34666) * 36;
+acc += Math.sin(34666) + Math.cos(34667) * 37;
+acc += Math.sin(34667) + Math.cos(34668) * 38;
+acc += Math.sin(34668) + Math.cos(34669) * 39;
+acc += Math.sin(34669) + Math.cos(34670) * 40;
+acc += Math.sin(34670) + Math.cos(34671) * 41;
+acc += Math.sin(34671) + Math.cos(34672) * 42;
+acc += Math.sin(34672) + Math.cos(34673) * 43;
+acc += Math.sin(34673) + Math.cos(34674) * 44;
+acc += Math.sin(34674) + Math.cos(34675) * 45;
+acc += Math.sin(34675) + Math.cos(34676) * 46;
+acc += Math.sin(34676) + Math.cos(34677) * 47;
+acc += Math.sin(34677) + Math.cos(34678) * 48;
+acc += Math.sin(34678) + Math.cos(34679) * 49;
+acc += Math.sin(34679) + Math.cos(34680) * 50;
+acc += Math.sin(34680) + Math.cos(34681) * 51;
+acc += Math.sin(34681) + Math.cos(34682) * 52;
+acc += Math.sin(34682) + Math.cos(34683) * 53;
+acc += Math.sin(34683) + Math.cos(34684) * 54;
+acc += Math.sin(34684) + Math.cos(34685) * 55;
+acc += Math.sin(34685) + Math.cos(34686) * 56;
+acc += Math.sin(34686) + Math.cos(34687) * 57;
+acc += Math.sin(34687) + Math.cos(34688) * 58;
+acc += Math.sin(34688) + Math.cos(34689) * 59;
+acc += Math.sin(34689) + Math.cos(34690) * 60;
+acc += Math.sin(34690) + Math.cos(34691) * 61;
+acc += Math.sin(34691) + Math.cos(34692) * 62;
+acc += Math.sin(34692) + Math.cos(34693) * 63;
+acc += Math.sin(34693) + Math.cos(34694) * 64;
+acc += Math.sin(34694) + Math.cos(34695) * 65;
+acc += Math.sin(34695) + Math.cos(34696) * 66;
+acc += Math.sin(34696) + Math.cos(34697) * 67;
+acc += Math.sin(34697) + Math.cos(34698) * 68;
+acc += Math.sin(34698) + Math.cos(34699) * 69;
+acc += Math.sin(34699) + Math.cos(34700) * 70;
+acc += Math.sin(34700) + Math.cos(34701) * 71;
+acc += Math.sin(34701) + Math.cos(34702) * 72;
+acc += Math.sin(34702) + Math.cos(34703) * 73;
+acc += Math.sin(34703) + Math.cos(34704) * 74;
+acc += Math.sin(34704) + Math.cos(34705) * 75;
+acc += Math.sin(34705) + Math.cos(34706) * 76;
+acc += Math.sin(34706) + Math.cos(34707) * 77;
+acc += Math.sin(34707) + Math.cos(34708) * 78;
+acc += Math.sin(34708) + Math.cos(34709) * 79;
+acc += Math.sin(34709) + Math.cos(34710) * 80;
+acc += Math.sin(34710) + Math.cos(34711) * 81;
+acc += Math.sin(34711) + Math.cos(34712) * 82;
+acc += Math.sin(34712) + Math.cos(34713) * 83;
+acc += Math.sin(34713) + Math.cos(34714) * 84;
+acc += Math.sin(34714) + Math.cos(34715) * 85;
+acc += Math.sin(34715) + Math.cos(34716) * 86;
+acc += Math.sin(34716) + Math.cos(34717) * 87;
+acc += Math.sin(34717) + Math.cos(34718) * 88;
+acc += Math.sin(34718) + Math.cos(34719) * 89;
+acc += Math.sin(34719) + Math.cos(34720) * 90;
+acc += Math.sin(34720) + Math.cos(34721) * 91;
+acc += Math.sin(34721) + Math.cos(34722) * 92;
+acc += Math.sin(34722) + Math.cos(34723) * 93;
+acc += Math.sin(34723) + Math.cos(34724) * 94;
+acc += Math.sin(34724) + Math.cos(34725) * 95;
+acc += Math.sin(34725) + Math.cos(34726) * 96;
+acc += Math.sin(34726) + Math.cos(34727) * 0;
+acc += Math.sin(34727) + Math.cos(34728) * 1;
+acc += Math.sin(34728) + Math.cos(34729) * 2;
+acc += Math.sin(34729) + Math.cos(34730) * 3;
+acc += Math.sin(34730) + Math.cos(34731) * 4;
+acc += Math.sin(34731) + Math.cos(34732) * 5;
+acc += Math.sin(34732) + Math.cos(34733) * 6;
+acc += Math.sin(34733) + Math.cos(34734) * 7;
+acc += Math.sin(34734) + Math.cos(34735) * 8;
+acc += Math.sin(34735) + Math.cos(34736) * 9;
+acc += Math.sin(34736) + Math.cos(34737) * 10;
+acc += Math.sin(34737) + Math.cos(34738) * 11;
+acc += Math.sin(34738) + Math.cos(34739) * 12;
+acc += Math.sin(34739) + Math.cos(34740) * 13;
+acc += Math.sin(34740) + Math.cos(34741) * 14;
+acc += Math.sin(34741) + Math.cos(34742) * 15;
+acc += Math.sin(34742) + Math.cos(34743) * 16;
+acc += Math.sin(34743) + Math.cos(34744) * 17;
+acc += Math.sin(34744) + Math.cos(34745) * 18;
+acc += Math.sin(34745) + Math.cos(34746) * 19;
+acc += Math.sin(34746) + Math.cos(34747) * 20;
+acc += Math.sin(34747) + Math.cos(34748) * 21;
+acc += Math.sin(34748) + Math.cos(34749) * 22;
+acc += Math.sin(34749) + Math.cos(34750) * 23;
+acc += Math.sin(34750) + Math.cos(34751) * 24;
+acc += Math.sin(34751) + Math.cos(34752) * 25;
+acc += Math.sin(34752) + Math.cos(34753) * 26;
+acc += Math.sin(34753) + Math.cos(34754) * 27;
+acc += Math.sin(34754) + Math.cos(34755) * 28;
+acc += Math.sin(34755) + Math.cos(34756) * 29;
+acc += Math.sin(34756) + Math.cos(34757) * 30;
+acc += Math.sin(34757) + Math.cos(34758) * 31;
+acc += Math.sin(34758) + Math.cos(34759) * 32;
+acc += Math.sin(34759) + Math.cos(34760) * 33;
+acc += Math.sin(34760) + Math.cos(34761) * 34;
+acc += Math.sin(34761) + Math.cos(34762) * 35;
+acc += Math.sin(34762) + Math.cos(34763) * 36;
+acc += Math.sin(34763) + Math.cos(34764) * 37;
+acc += Math.sin(34764) + Math.cos(34765) * 38;
+acc += Math.sin(34765) + Math.cos(34766) * 39;
+acc += Math.sin(34766) + Math.cos(34767) * 40;
+acc += Math.sin(34767) + Math.cos(34768) * 41;
+acc += Math.sin(34768) + Math.cos(34769) * 42;
+acc += Math.sin(34769) + Math.cos(34770) * 43;
+acc += Math.sin(34770) + Math.cos(34771) * 44;
+acc += Math.sin(34771) + Math.cos(34772) * 45;
+acc += Math.sin(34772) + Math.cos(34773) * 46;
+acc += Math.sin(34773) + Math.cos(34774) * 47;
+acc += Math.sin(34774) + Math.cos(34775) * 48;
+acc += Math.sin(34775) + Math.cos(34776) * 49;
+acc += Math.sin(34776) + Math.cos(34777) * 50;
+acc += Math.sin(34777) + Math.cos(34778) * 51;
+acc += Math.sin(34778) + Math.cos(34779) * 52;
+acc += Math.sin(34779) + Math.cos(34780) * 53;
+acc += Math.sin(34780) + Math.cos(34781) * 54;
+acc += Math.sin(34781) + Math.cos(34782) * 55;
+acc += Math.sin(34782) + Math.cos(34783) * 56;
+acc += Math.sin(34783) + Math.cos(34784) * 57;
+acc += Math.sin(34784) + Math.cos(34785) * 58;
+acc += Math.sin(34785) + Math.cos(34786) * 59;
+acc += Math.sin(34786) + Math.cos(34787) * 60;
+acc += Math.sin(34787) + Math.cos(34788) * 61;
+acc += Math.sin(34788) + Math.cos(34789) * 62;
+acc += Math.sin(34789) + Math.cos(34790) * 63;
+acc += Math.sin(34790) + Math.cos(34791) * 64;
+acc += Math.sin(34791) + Math.cos(34792) * 65;
+acc += Math.sin(34792) + Math.cos(34793) * 66;
+acc += Math.sin(34793) + Math.cos(34794) * 67;
+acc += Math.sin(34794) + Math.cos(34795) * 68;
+acc += Math.sin(34795) + Math.cos(34796) * 69;
+acc += Math.sin(34796) + Math.cos(34797) * 70;
+acc += Math.sin(34797) + Math.cos(34798) * 71;
+acc += Math.sin(34798) + Math.cos(34799) * 72;
+acc += Math.sin(34799) + Math.cos(34800) * 73;
+acc += Math.sin(34800) + Math.cos(34801) * 74;
+acc += Math.sin(34801) + Math.cos(34802) * 75;
+acc += Math.sin(34802) + Math.cos(34803) * 76;
+acc += Math.sin(34803) + Math.cos(34804) * 77;
+acc += Math.sin(34804) + Math.cos(34805) * 78;
+acc += Math.sin(34805) + Math.cos(34806) * 79;
+acc += Math.sin(34806) + Math.cos(34807) * 80;
+acc += Math.sin(34807) + Math.cos(34808) * 81;
+acc += Math.sin(34808) + Math.cos(34809) * 82;
+acc += Math.sin(34809) + Math.cos(34810) * 83;
+acc += Math.sin(34810) + Math.cos(34811) * 84;
+acc += Math.sin(34811) + Math.cos(34812) * 85;
+acc += Math.sin(34812) + Math.cos(34813) * 86;
+acc += Math.sin(34813) + Math.cos(34814) * 87;
+acc += Math.sin(34814) + Math.cos(34815) * 88;
+acc += Math.sin(34815) + Math.cos(34816) * 89;
+acc += Math.sin(34816) + Math.cos(34817) * 90;
+acc += Math.sin(34817) + Math.cos(34818) * 91;
+acc += Math.sin(34818) + Math.cos(34819) * 92;
+acc += Math.sin(34819) + Math.cos(34820) * 93;
+acc += Math.sin(34820) + Math.cos(34821) * 94;
+acc += Math.sin(34821) + Math.cos(34822) * 95;
+acc += Math.sin(34822) + Math.cos(34823) * 96;
+acc += Math.sin(34823) + Math.cos(34824) * 0;
+acc += Math.sin(34824) + Math.cos(34825) * 1;
+acc += Math.sin(34825) + Math.cos(34826) * 2;
+acc += Math.sin(34826) + Math.cos(34827) * 3;
+acc += Math.sin(34827) + Math.cos(34828) * 4;
+acc += Math.sin(34828) + Math.cos(34829) * 5;
+acc += Math.sin(34829) + Math.cos(34830) * 6;
+acc += Math.sin(34830) + Math.cos(34831) * 7;
+acc += Math.sin(34831) + Math.cos(34832) * 8;
+acc += Math.sin(34832) + Math.cos(34833) * 9;
+acc += Math.sin(34833) + Math.cos(34834) * 10;
+acc += Math.sin(34834) + Math.cos(34835) * 11;
+acc += Math.sin(34835) + Math.cos(34836) * 12;
+acc += Math.sin(34836) + Math.cos(34837) * 13;
+acc += Math.sin(34837) + Math.cos(34838) * 14;
+acc += Math.sin(34838) + Math.cos(34839) * 15;
+acc += Math.sin(34839) + Math.cos(34840) * 16;
+acc += Math.sin(34840) + Math.cos(34841) * 17;
+acc += Math.sin(34841) + Math.cos(34842) * 18;
+acc += Math.sin(34842) + Math.cos(34843) * 19;
+acc += Math.sin(34843) + Math.cos(34844) * 20;
+acc += Math.sin(34844) + Math.cos(34845) * 21;
+acc += Math.sin(34845) + Math.cos(34846) * 22;
+acc += Math.sin(34846) + Math.cos(34847) * 23;
+acc += Math.sin(34847) + Math.cos(34848) * 24;
+acc += Math.sin(34848) + Math.cos(34849) * 25;
+acc += Math.sin(34849) + Math.cos(34850) * 26;
+acc += Math.sin(34850) + Math.cos(34851) * 27;
+acc += Math.sin(34851) + Math.cos(34852) * 28;
+acc += Math.sin(34852) + Math.cos(34853) * 29;
+acc += Math.sin(34853) + Math.cos(34854) * 30;
+acc += Math.sin(34854) + Math.cos(34855) * 31;
+acc += Math.sin(34855) + Math.cos(34856) * 32;
+acc += Math.sin(34856) + Math.cos(34857) * 33;
+acc += Math.sin(34857) + Math.cos(34858) * 34;
+acc += Math.sin(34858) + Math.cos(34859) * 35;
+acc += Math.sin(34859) + Math.cos(34860) * 36;
+acc += Math.sin(34860) + Math.cos(34861) * 37;
+acc += Math.sin(34861) + Math.cos(34862) * 38;
+acc += Math.sin(34862) + Math.cos(34863) * 39;
+acc += Math.sin(34863) + Math.cos(34864) * 40;
+acc += Math.sin(34864) + Math.cos(34865) * 41;
+acc += Math.sin(34865) + Math.cos(34866) * 42;
+acc += Math.sin(34866) + Math.cos(34867) * 43;
+acc += Math.sin(34867) + Math.cos(34868) * 44;
+acc += Math.sin(34868) + Math.cos(34869) * 45;
+acc += Math.sin(34869) + Math.cos(34870) * 46;
+acc += Math.sin(34870) + Math.cos(34871) * 47;
+acc += Math.sin(34871) + Math.cos(34872) * 48;
+acc += Math.sin(34872) + Math.cos(34873) * 49;
+acc += Math.sin(34873) + Math.cos(34874) * 50;
+acc += Math.sin(34874) + Math.cos(34875) * 51;
+acc += Math.sin(34875) + Math.cos(34876) * 52;
+acc += Math.sin(34876) + Math.cos(34877) * 53;
+acc += Math.sin(34877) + Math.cos(34878) * 54;
+acc += Math.sin(34878) + Math.cos(34879) * 55;
+acc += Math.sin(34879) + Math.cos(34880) * 56;
+acc += Math.sin(34880) + Math.cos(34881) * 57;
+acc += Math.sin(34881) + Math.cos(34882) * 58;
+acc += Math.sin(34882) + Math.cos(34883) * 59;
+acc += Math.sin(34883) + Math.cos(34884) * 60;
+acc += Math.sin(34884) + Math.cos(34885) * 61;
+acc += Math.sin(34885) + Math.cos(34886) * 62;
+acc += Math.sin(34886) + Math.cos(34887) * 63;
+acc += Math.sin(34887) + Math.cos(34888) * 64;
+acc += Math.sin(34888) + Math.cos(34889) * 65;
+acc += Math.sin(34889) + Math.cos(34890) * 66;
+acc += Math.sin(34890) + Math.cos(34891) * 67;
+acc += Math.sin(34891) + Math.cos(34892) * 68;
+acc += Math.sin(34892) + Math.cos(34893) * 69;
+acc += Math.sin(34893) + Math.cos(34894) * 70;
+acc += Math.sin(34894) + Math.cos(34895) * 71;
+acc += Math.sin(34895) + Math.cos(34896) * 72;
+acc += Math.sin(34896) + Math.cos(34897) * 73;
+acc += Math.sin(34897) + Math.cos(34898) * 74;
+acc += Math.sin(34898) + Math.cos(34899) * 75;
+acc += Math.sin(34899) + Math.cos(34900) * 76;
+acc += Math.sin(34900) + Math.cos(34901) * 77;
+acc += Math.sin(34901) + Math.cos(34902) * 78;
+acc += Math.sin(34902) + Math.cos(34903) * 79;
+acc += Math.sin(34903) + Math.cos(34904) * 80;
+acc += Math.sin(34904) + Math.cos(34905) * 81;
+acc += Math.sin(34905) + Math.cos(34906) * 82;
+acc += Math.sin(34906) + Math.cos(34907) * 83;
+acc += Math.sin(34907) + Math.cos(34908) * 84;
+acc += Math.sin(34908) + Math.cos(34909) * 85;
+acc += Math.sin(34909) + Math.cos(34910) * 86;
+acc += Math.sin(34910) + Math.cos(34911) * 87;
+acc += Math.sin(34911) + Math.cos(34912) * 88;
+acc += Math.sin(34912) + Math.cos(34913) * 89;
+acc += Math.sin(34913) + Math.cos(34914) * 90;
+acc += Math.sin(34914) + Math.cos(34915) * 91;
+acc += Math.sin(34915) + Math.cos(34916) * 92;
+acc += Math.sin(34916) + Math.cos(34917) * 93;
+acc += Math.sin(34917) + Math.cos(34918) * 94;
+acc += Math.sin(34918) + Math.cos(34919) * 95;
+acc += Math.sin(34919) + Math.cos(34920) * 96;
+acc += Math.sin(34920) + Math.cos(34921) * 0;
+acc += Math.sin(34921) + Math.cos(34922) * 1;
+acc += Math.sin(34922) + Math.cos(34923) * 2;
+acc += Math.sin(34923) + Math.cos(34924) * 3;
+acc += Math.sin(34924) + Math.cos(34925) * 4;
+acc += Math.sin(34925) + Math.cos(34926) * 5;
+acc += Math.sin(34926) + Math.cos(34927) * 6;
+acc += Math.sin(34927) + Math.cos(34928) * 7;
+acc += Math.sin(34928) + Math.cos(34929) * 8;
+acc += Math.sin(34929) + Math.cos(34930) * 9;
+acc += Math.sin(34930) + Math.cos(34931) * 10;
+acc += Math.sin(34931) + Math.cos(34932) * 11;
+acc += Math.sin(34932) + Math.cos(34933) * 12;
+acc += Math.sin(34933) + Math.cos(34934) * 13;
+acc += Math.sin(34934) + Math.cos(34935) * 14;
+acc += Math.sin(34935) + Math.cos(34936) * 15;
+acc += Math.sin(34936) + Math.cos(34937) * 16;
+acc += Math.sin(34937) + Math.cos(34938) * 17;
+acc += Math.sin(34938) + Math.cos(34939) * 18;
+acc += Math.sin(34939) + Math.cos(34940) * 19;
+acc += Math.sin(34940) + Math.cos(34941) * 20;
+acc += Math.sin(34941) + Math.cos(34942) * 21;
+acc += Math.sin(34942) + Math.cos(34943) * 22;
+acc += Math.sin(34943) + Math.cos(34944) * 23;
+acc += Math.sin(34944) + Math.cos(34945) * 24;
+acc += Math.sin(34945) + Math.cos(34946) * 25;
+acc += Math.sin(34946) + Math.cos(34947) * 26;
+acc += Math.sin(34947) + Math.cos(34948) * 27;
+acc += Math.sin(34948) + Math.cos(34949) * 28;
+acc += Math.sin(34949) + Math.cos(34950) * 29;
+acc += Math.sin(34950) + Math.cos(34951) * 30;
+acc += Math.sin(34951) + Math.cos(34952) * 31;
+acc += Math.sin(34952) + Math.cos(34953) * 32;
+acc += Math.sin(34953) + Math.cos(34954) * 33;
+acc += Math.sin(34954) + Math.cos(34955) * 34;
+acc += Math.sin(34955) + Math.cos(34956) * 35;
+acc += Math.sin(34956) + Math.cos(34957) * 36;
+acc += Math.sin(34957) + Math.cos(34958) * 37;
+acc += Math.sin(34958) + Math.cos(34959) * 38;
+acc += Math.sin(34959) + Math.cos(34960) * 39;
+acc += Math.sin(34960) + Math.cos(34961) * 40;
+acc += Math.sin(34961) + Math.cos(34962) * 41;
+acc += Math.sin(34962) + Math.cos(34963) * 42;
+acc += Math.sin(34963) + Math.cos(34964) * 43;
+acc += Math.sin(34964) + Math.cos(34965) * 44;
+acc += Math.sin(34965) + Math.cos(34966) * 45;
+acc += Math.sin(34966) + Math.cos(34967) * 46;
+acc += Math.sin(34967) + Math.cos(34968) * 47;
+acc += Math.sin(34968) + Math.cos(34969) * 48;
+acc += Math.sin(34969) + Math.cos(34970) * 49;
+acc += Math.sin(34970) + Math.cos(34971) * 50;
+acc += Math.sin(34971) + Math.cos(34972) * 51;
+acc += Math.sin(34972) + Math.cos(34973) * 52;
+acc += Math.sin(34973) + Math.cos(34974) * 53;
+acc += Math.sin(34974) + Math.cos(34975) * 54;
+acc += Math.sin(34975) + Math.cos(34976) * 55;
+acc += Math.sin(34976) + Math.cos(34977) * 56;
+acc += Math.sin(34977) + Math.cos(34978) * 57;
+acc += Math.sin(34978) + Math.cos(34979) * 58;
+acc += Math.sin(34979) + Math.cos(34980) * 59;
+acc += Math.sin(34980) + Math.cos(34981) * 60;
+acc += Math.sin(34981) + Math.cos(34982) * 61;
+acc += Math.sin(34982) + Math.cos(34983) * 62;
+acc += Math.sin(34983) + Math.cos(34984) * 63;
+acc += Math.sin(34984) + Math.cos(34985) * 64;
+acc += Math.sin(34985) + Math.cos(34986) * 65;
+acc += Math.sin(34986) + Math.cos(34987) * 66;
+acc += Math.sin(34987) + Math.cos(34988) * 67;
+acc += Math.sin(34988) + Math.cos(34989) * 68;
+acc += Math.sin(34989) + Math.cos(34990) * 69;
+acc += Math.sin(34990) + Math.cos(34991) * 70;
+acc += Math.sin(34991) + Math.cos(34992) * 71;
+acc += Math.sin(34992) + Math.cos(34993) * 72;
+acc += Math.sin(34993) + Math.cos(34994) * 73;
+acc += Math.sin(34994) + Math.cos(34995) * 74;
+acc += Math.sin(34995) + Math.cos(34996) * 75;
+acc += Math.sin(34996) + Math.cos(34997) * 76;
+acc += Math.sin(34997) + Math.cos(34998) * 77;
+acc += Math.sin(34998) + Math.cos(34999) * 78;
+acc += Math.sin(34999) + Math.cos(35000) * 79;
+acc += Math.sin(35000) + Math.cos(35001) * 80;
+acc += Math.sin(35001) + Math.cos(35002) * 81;
+acc += Math.sin(35002) + Math.cos(35003) * 82;
+acc += Math.sin(35003) + Math.cos(35004) * 83;
+acc += Math.sin(35004) + Math.cos(35005) * 84;
+acc += Math.sin(35005) + Math.cos(35006) * 85;
+acc += Math.sin(35006) + Math.cos(35007) * 86;
+acc += Math.sin(35007) + Math.cos(35008) * 87;
+acc += Math.sin(35008) + Math.cos(35009) * 88;
+acc += Math.sin(35009) + Math.cos(35010) * 89;
+acc += Math.sin(35010) + Math.cos(35011) * 90;
+acc += Math.sin(35011) + Math.cos(35012) * 91;
+acc += Math.sin(35012) + Math.cos(35013) * 92;
+acc += Math.sin(35013) + Math.cos(35014) * 93;
+acc += Math.sin(35014) + Math.cos(35015) * 94;
+acc += Math.sin(35015) + Math.cos(35016) * 95;
+acc += Math.sin(35016) + Math.cos(35017) * 96;
+acc += Math.sin(35017) + Math.cos(35018) * 0;
+acc += Math.sin(35018) + Math.cos(35019) * 1;
+acc += Math.sin(35019) + Math.cos(35020) * 2;
+acc += Math.sin(35020) + Math.cos(35021) * 3;
+acc += Math.sin(35021) + Math.cos(35022) * 4;
+acc += Math.sin(35022) + Math.cos(35023) * 5;
+acc += Math.sin(35023) + Math.cos(35024) * 6;
+acc += Math.sin(35024) + Math.cos(35025) * 7;
+acc += Math.sin(35025) + Math.cos(35026) * 8;
+acc += Math.sin(35026) + Math.cos(35027) * 9;
+acc += Math.sin(35027) + Math.cos(35028) * 10;
+acc += Math.sin(35028) + Math.cos(35029) * 11;
+acc += Math.sin(35029) + Math.cos(35030) * 12;
+acc += Math.sin(35030) + Math.cos(35031) * 13;
+acc += Math.sin(35031) + Math.cos(35032) * 14;
+acc += Math.sin(35032) + Math.cos(35033) * 15;
+acc += Math.sin(35033) + Math.cos(35034) * 16;
+acc += Math.sin(35034) + Math.cos(35035) * 17;
+acc += Math.sin(35035) + Math.cos(35036) * 18;
+acc += Math.sin(35036) + Math.cos(35037) * 19;
+acc += Math.sin(35037) + Math.cos(35038) * 20;
+acc += Math.sin(35038) + Math.cos(35039) * 21;
+acc += Math.sin(35039) + Math.cos(35040) * 22;
+acc += Math.sin(35040) + Math.cos(35041) * 23;
+acc += Math.sin(35041) + Math.cos(35042) * 24;
+acc += Math.sin(35042) + Math.cos(35043) * 25;
+acc += Math.sin(35043) + Math.cos(35044) * 26;
+acc += Math.sin(35044) + Math.cos(35045) * 27;
+acc += Math.sin(35045) + Math.cos(35046) * 28;
+acc += Math.sin(35046) + Math.cos(35047) * 29;
+acc += Math.sin(35047) + Math.cos(35048) * 30;
+acc += Math.sin(35048) + Math.cos(35049) * 31;
+acc += Math.sin(35049) + Math.cos(35050) * 32;
+acc += Math.sin(35050) + Math.cos(35051) * 33;
+acc += Math.sin(35051) + Math.cos(35052) * 34;
+acc += Math.sin(35052) + Math.cos(35053) * 35;
+acc += Math.sin(35053) + Math.cos(35054) * 36;
+acc += Math.sin(35054) + Math.cos(35055) * 37;
+acc += Math.sin(35055) + Math.cos(35056) * 38;
+acc += Math.sin(35056) + Math.cos(35057) * 39;
+acc += Math.sin(35057) + Math.cos(35058) * 40;
+acc += Math.sin(35058) + Math.cos(35059) * 41;
+acc += Math.sin(35059) + Math.cos(35060) * 42;
+acc += Math.sin(35060) + Math.cos(35061) * 43;
+acc += Math.sin(35061) + Math.cos(35062) * 44;
+acc += Math.sin(35062) + Math.cos(35063) * 45;
+acc += Math.sin(35063) + Math.cos(35064) * 46;
+acc += Math.sin(35064) + Math.cos(35065) * 47;
+acc += Math.sin(35065) + Math.cos(35066) * 48;
+acc += Math.sin(35066) + Math.cos(35067) * 49;
+acc += Math.sin(35067) + Math.cos(35068) * 50;
+acc += Math.sin(35068) + Math.cos(35069) * 51;
+acc += Math.sin(35069) + Math.cos(35070) * 52;
+acc += Math.sin(35070) + Math.cos(35071) * 53;
+acc += Math.sin(35071) + Math.cos(35072) * 54;
+acc += Math.sin(35072) + Math.cos(35073) * 55;
+acc += Math.sin(35073) + Math.cos(35074) * 56;
+acc += Math.sin(35074) + Math.cos(35075) * 57;
+acc += Math.sin(35075) + Math.cos(35076) * 58;
+acc += Math.sin(35076) + Math.cos(35077) * 59;
+acc += Math.sin(35077) + Math.cos(35078) * 60;
+acc += Math.sin(35078) + Math.cos(35079) * 61;
+acc += Math.sin(35079) + Math.cos(35080) * 62;
+acc += Math.sin(35080) + Math.cos(35081) * 63;
+acc += Math.sin(35081) + Math.cos(35082) * 64;
+acc += Math.sin(35082) + Math.cos(35083) * 65;
+acc += Math.sin(35083) + Math.cos(35084) * 66;
+acc += Math.sin(35084) + Math.cos(35085) * 67;
+acc += Math.sin(35085) + Math.cos(35086) * 68;
+acc += Math.sin(35086) + Math.cos(35087) * 69;
+acc += Math.sin(35087) + Math.cos(35088) * 70;
+acc += Math.sin(35088) + Math.cos(35089) * 71;
+acc += Math.sin(35089) + Math.cos(35090) * 72;
+acc += Math.sin(35090) + Math.cos(35091) * 73;
+acc += Math.sin(35091) + Math.cos(35092) * 74;
+acc += Math.sin(35092) + Math.cos(35093) * 75;
+acc += Math.sin(35093) + Math.cos(35094) * 76;
+acc += Math.sin(35094) + Math.cos(35095) * 77;
+acc += Math.sin(35095) + Math.cos(35096) * 78;
+acc += Math.sin(35096) + Math.cos(35097) * 79;
+acc += Math.sin(35097) + Math.cos(35098) * 80;
+acc += Math.sin(35098) + Math.cos(35099) * 81;
+acc += Math.sin(35099) + Math.cos(35100) * 82;
+acc += Math.sin(35100) + Math.cos(35101) * 83;
+acc += Math.sin(35101) + Math.cos(35102) * 84;
+acc += Math.sin(35102) + Math.cos(35103) * 85;
+acc += Math.sin(35103) + Math.cos(35104) * 86;
+acc += Math.sin(35104) + Math.cos(35105) * 87;
+acc += Math.sin(35105) + Math.cos(35106) * 88;
+acc += Math.sin(35106) + Math.cos(35107) * 89;
+acc += Math.sin(35107) + Math.cos(35108) * 90;
+acc += Math.sin(35108) + Math.cos(35109) * 91;
+acc += Math.sin(35109) + Math.cos(35110) * 92;
+acc += Math.sin(35110) + Math.cos(35111) * 93;
+acc += Math.sin(35111) + Math.cos(35112) * 94;
+acc += Math.sin(35112) + Math.cos(35113) * 95;
+acc += Math.sin(35113) + Math.cos(35114) * 96;
+acc += Math.sin(35114) + Math.cos(35115) * 0;
+acc += Math.sin(35115) + Math.cos(35116) * 1;
+acc += Math.sin(35116) + Math.cos(35117) * 2;
+acc += Math.sin(35117) + Math.cos(35118) * 3;
+acc += Math.sin(35118) + Math.cos(35119) * 4;
+acc += Math.sin(35119) + Math.cos(35120) * 5;
+acc += Math.sin(35120) + Math.cos(35121) * 6;
+acc += Math.sin(35121) + Math.cos(35122) * 7;
+acc += Math.sin(35122) + Math.cos(35123) * 8;
+acc += Math.sin(35123) + Math.cos(35124) * 9;
+acc += Math.sin(35124) + Math.cos(35125) * 10;
+acc += Math.sin(35125) + Math.cos(35126) * 11;
+acc += Math.sin(35126) + Math.cos(35127) * 12;
+acc += Math.sin(35127) + Math.cos(35128) * 13;
+acc += Math.sin(35128) + Math.cos(35129) * 14;
+acc += Math.sin(35129) + Math.cos(35130) * 15;
+acc += Math.sin(35130) + Math.cos(35131) * 16;
+acc += Math.sin(35131) + Math.cos(35132) * 17;
+acc += Math.sin(35132) + Math.cos(35133) * 18;
+acc += Math.sin(35133) + Math.cos(35134) * 19;
+acc += Math.sin(35134) + Math.cos(35135) * 20;
+acc += Math.sin(35135) + Math.cos(35136) * 21;
+acc += Math.sin(35136) + Math.cos(35137) * 22;
+acc += Math.sin(35137) + Math.cos(35138) * 23;
+acc += Math.sin(35138) + Math.cos(35139) * 24;
+acc += Math.sin(35139) + Math.cos(35140) * 25;
+acc += Math.sin(35140) + Math.cos(35141) * 26;
+acc += Math.sin(35141) + Math.cos(35142) * 27;
+acc += Math.sin(35142) + Math.cos(35143) * 28;
+acc += Math.sin(35143) + Math.cos(35144) * 29;
+acc += Math.sin(35144) + Math.cos(35145) * 30;
+acc += Math.sin(35145) + Math.cos(35146) * 31;
+acc += Math.sin(35146) + Math.cos(35147) * 32;
+acc += Math.sin(35147) + Math.cos(35148) * 33;
+acc += Math.sin(35148) + Math.cos(35149) * 34;
+acc += Math.sin(35149) + Math.cos(35150) * 35;
+acc += Math.sin(35150) + Math.cos(35151) * 36;
+acc += Math.sin(35151) + Math.cos(35152) * 37;
+acc += Math.sin(35152) + Math.cos(35153) * 38;
+acc += Math.sin(35153) + Math.cos(35154) * 39;
+acc += Math.sin(35154) + Math.cos(35155) * 40;
+acc += Math.sin(35155) + Math.cos(35156) * 41;
+acc += Math.sin(35156) + Math.cos(35157) * 42;
+acc += Math.sin(35157) + Math.cos(35158) * 43;
+acc += Math.sin(35158) + Math.cos(35159) * 44;
+acc += Math.sin(35159) + Math.cos(35160) * 45;
+acc += Math.sin(35160) + Math.cos(35161) * 46;
+acc += Math.sin(35161) + Math.cos(35162) * 47;
+acc += Math.sin(35162) + Math.cos(35163) * 48;
+acc += Math.sin(35163) + Math.cos(35164) * 49;
+acc += Math.sin(35164) + Math.cos(35165) * 50;
+acc += Math.sin(35165) + Math.cos(35166) * 51;
+acc += Math.sin(35166) + Math.cos(35167) * 52;
+acc += Math.sin(35167) + Math.cos(35168) * 53;
+acc += Math.sin(35168) + Math.cos(35169) * 54;
+acc += Math.sin(35169) + Math.cos(35170) * 55;
+acc += Math.sin(35170) + Math.cos(35171) * 56;
+acc += Math.sin(35171) + Math.cos(35172) * 57;
+acc += Math.sin(35172) + Math.cos(35173) * 58;
+acc += Math.sin(35173) + Math.cos(35174) * 59;
+acc += Math.sin(35174) + Math.cos(35175) * 60;
+acc += Math.sin(35175) + Math.cos(35176) * 61;
+acc += Math.sin(35176) + Math.cos(35177) * 62;
+acc += Math.sin(35177) + Math.cos(35178) * 63;
+acc += Math.sin(35178) + Math.cos(35179) * 64;
+acc += Math.sin(35179) + Math.cos(35180) * 65;
+acc += Math.sin(35180) + Math.cos(35181) * 66;
+acc += Math.sin(35181) + Math.cos(35182) * 67;
+acc += Math.sin(35182) + Math.cos(35183) * 68;
+acc += Math.sin(35183) + Math.cos(35184) * 69;
+acc += Math.sin(35184) + Math.cos(35185) * 70;
+acc += Math.sin(35185) + Math.cos(35186) * 71;
+acc += Math.sin(35186) + Math.cos(35187) * 72;
+acc += Math.sin(35187) + Math.cos(35188) * 73;
+acc += Math.sin(35188) + Math.cos(35189) * 74;
+acc += Math.sin(35189) + Math.cos(35190) * 75;
+acc += Math.sin(35190) + Math.cos(35191) * 76;
+acc += Math.sin(35191) + Math.cos(35192) * 77;
+acc += Math.sin(35192) + Math.cos(35193) * 78;
+acc += Math.sin(35193) + Math.cos(35194) * 79;
+acc += Math.sin(35194) + Math.cos(35195) * 80;
+acc += Math.sin(35195) + Math.cos(35196) * 81;
+acc += Math.sin(35196) + Math.cos(35197) * 82;
+acc += Math.sin(35197) + Math.cos(35198) * 83;
+acc += Math.sin(35198) + Math.cos(35199) * 84;
+acc += Math.sin(35199) + Math.cos(35200) * 85;
+acc += Math.sin(35200) + Math.cos(35201) * 86;
+acc += Math.sin(35201) + Math.cos(35202) * 87;
+acc += Math.sin(35202) + Math.cos(35203) * 88;
+acc += Math.sin(35203) + Math.cos(35204) * 89;
+acc += Math.sin(35204) + Math.cos(35205) * 90;
+acc += Math.sin(35205) + Math.cos(35206) * 91;
+acc += Math.sin(35206) + Math.cos(35207) * 92;
+acc += Math.sin(35207) + Math.cos(35208) * 93;
+acc += Math.sin(35208) + Math.cos(35209) * 94;
+acc += Math.sin(35209) + Math.cos(35210) * 95;
+acc += Math.sin(35210) + Math.cos(35211) * 96;
+acc += Math.sin(35211) + Math.cos(35212) * 0;
+acc += Math.sin(35212) + Math.cos(35213) * 1;
+acc += Math.sin(35213) + Math.cos(35214) * 2;
+acc += Math.sin(35214) + Math.cos(35215) * 3;
+acc += Math.sin(35215) + Math.cos(35216) * 4;
+acc += Math.sin(35216) + Math.cos(35217) * 5;
+acc += Math.sin(35217) + Math.cos(35218) * 6;
+acc += Math.sin(35218) + Math.cos(35219) * 7;
+acc += Math.sin(35219) + Math.cos(35220) * 8;
+acc += Math.sin(35220) + Math.cos(35221) * 9;
+acc += Math.sin(35221) + Math.cos(35222) * 10;
+acc += Math.sin(35222) + Math.cos(35223) * 11;
+acc += Math.sin(35223) + Math.cos(35224) * 12;
+acc += Math.sin(35224) + Math.cos(35225) * 13;
+acc += Math.sin(35225) + Math.cos(35226) * 14;
+acc += Math.sin(35226) + Math.cos(35227) * 15;
+acc += Math.sin(35227) + Math.cos(35228) * 16;
+acc += Math.sin(35228) + Math.cos(35229) * 17;
+acc += Math.sin(35229) + Math.cos(35230) * 18;
+acc += Math.sin(35230) + Math.cos(35231) * 19;
+acc += Math.sin(35231) + Math.cos(35232) * 20;
+acc += Math.sin(35232) + Math.cos(35233) * 21;
+acc += Math.sin(35233) + Math.cos(35234) * 22;
+acc += Math.sin(35234) + Math.cos(35235) * 23;
+acc += Math.sin(35235) + Math.cos(35236) * 24;
+acc += Math.sin(35236) + Math.cos(35237) * 25;
+acc += Math.sin(35237) + Math.cos(35238) * 26;
+acc += Math.sin(35238) + Math.cos(35239) * 27;
+acc += Math.sin(35239) + Math.cos(35240) * 28;
+acc += Math.sin(35240) + Math.cos(35241) * 29;
+acc += Math.sin(35241) + Math.cos(35242) * 30;
+acc += Math.sin(35242) + Math.cos(35243) * 31;
+acc += Math.sin(35243) + Math.cos(35244) * 32;
+acc += Math.sin(35244) + Math.cos(35245) * 33;
+acc += Math.sin(35245) + Math.cos(35246) * 34;
+acc += Math.sin(35246) + Math.cos(35247) * 35;
+acc += Math.sin(35247) + Math.cos(35248) * 36;
+acc += Math.sin(35248) + Math.cos(35249) * 37;
+acc += Math.sin(35249) + Math.cos(35250) * 38;
+acc += Math.sin(35250) + Math.cos(35251) * 39;
+acc += Math.sin(35251) + Math.cos(35252) * 40;
+acc += Math.sin(35252) + Math.cos(35253) * 41;
+acc += Math.sin(35253) + Math.cos(35254) * 42;
+acc += Math.sin(35254) + Math.cos(35255) * 43;
+acc += Math.sin(35255) + Math.cos(35256) * 44;
+acc += Math.sin(35256) + Math.cos(35257) * 45;
+acc += Math.sin(35257) + Math.cos(35258) * 46;
+acc += Math.sin(35258) + Math.cos(35259) * 47;
+acc += Math.sin(35259) + Math.cos(35260) * 48;
+acc += Math.sin(35260) + Math.cos(35261) * 49;
+acc += Math.sin(35261) + Math.cos(35262) * 50;
+acc += Math.sin(35262) + Math.cos(35263) * 51;
+acc += Math.sin(35263) + Math.cos(35264) * 52;
+acc += Math.sin(35264) + Math.cos(35265) * 53;
+acc += Math.sin(35265) + Math.cos(35266) * 54;
+acc += Math.sin(35266) + Math.cos(35267) * 55;
+acc += Math.sin(35267) + Math.cos(35268) * 56;
+acc += Math.sin(35268) + Math.cos(35269) * 57;
+acc += Math.sin(35269) + Math.cos(35270) * 58;
+acc += Math.sin(35270) + Math.cos(35271) * 59;
+acc += Math.sin(35271) + Math.cos(35272) * 60;
+acc += Math.sin(35272) + Math.cos(35273) * 61;
+acc += Math.sin(35273) + Math.cos(35274) * 62;
+acc += Math.sin(35274) + Math.cos(35275) * 63;
+acc += Math.sin(35275) + Math.cos(35276) * 64;
+acc += Math.sin(35276) + Math.cos(35277) * 65;
+acc += Math.sin(35277) + Math.cos(35278) * 66;
+acc += Math.sin(35278) + Math.cos(35279) * 67;
+acc += Math.sin(35279) + Math.cos(35280) * 68;
+acc += Math.sin(35280) + Math.cos(35281) * 69;
+acc += Math.sin(35281) + Math.cos(35282) * 70;
+acc += Math.sin(35282) + Math.cos(35283) * 71;
+acc += Math.sin(35283) + Math.cos(35284) * 72;
+acc += Math.sin(35284) + Math.cos(35285) * 73;
+acc += Math.sin(35285) + Math.cos(35286) * 74;
+acc += Math.sin(35286) + Math.cos(35287) * 75;
+acc += Math.sin(35287) + Math.cos(35288) * 76;
+acc += Math.sin(35288) + Math.cos(35289) * 77;
+acc += Math.sin(35289) + Math.cos(35290) * 78;
+acc += Math.sin(35290) + Math.cos(35291) * 79;
+acc += Math.sin(35291) + Math.cos(35292) * 80;
+acc += Math.sin(35292) + Math.cos(35293) * 81;
+acc += Math.sin(35293) + Math.cos(35294) * 82;
+acc += Math.sin(35294) + Math.cos(35295) * 83;
+acc += Math.sin(35295) + Math.cos(35296) * 84;
+acc += Math.sin(35296) + Math.cos(35297) * 85;
+acc += Math.sin(35297) + Math.cos(35298) * 86;
+acc += Math.sin(35298) + Math.cos(35299) * 87;
+acc += Math.sin(35299) + Math.cos(35300) * 88;
+acc += Math.sin(35300) + Math.cos(35301) * 89;
+acc += Math.sin(35301) + Math.cos(35302) * 90;
+acc += Math.sin(35302) + Math.cos(35303) * 91;
+acc += Math.sin(35303) + Math.cos(35304) * 92;
+acc += Math.sin(35304) + Math.cos(35305) * 93;
+acc += Math.sin(35305) + Math.cos(35306) * 94;
+acc += Math.sin(35306) + Math.cos(35307) * 95;
+acc += Math.sin(35307) + Math.cos(35308) * 96;
+acc += Math.sin(35308) + Math.cos(35309) * 0;
+acc += Math.sin(35309) + Math.cos(35310) * 1;
+acc += Math.sin(35310) + Math.cos(35311) * 2;
+acc += Math.sin(35311) + Math.cos(35312) * 3;
+acc += Math.sin(35312) + Math.cos(35313) * 4;
+acc += Math.sin(35313) + Math.cos(35314) * 5;
+acc += Math.sin(35314) + Math.cos(35315) * 6;
+acc += Math.sin(35315) + Math.cos(35316) * 7;
+acc += Math.sin(35316) + Math.cos(35317) * 8;
+acc += Math.sin(35317) + Math.cos(35318) * 9;
+acc += Math.sin(35318) + Math.cos(35319) * 10;
+acc += Math.sin(35319) + Math.cos(35320) * 11;
+acc += Math.sin(35320) + Math.cos(35321) * 12;
+acc += Math.sin(35321) + Math.cos(35322) * 13;
+acc += Math.sin(35322) + Math.cos(35323) * 14;
+acc += Math.sin(35323) + Math.cos(35324) * 15;
+acc += Math.sin(35324) + Math.cos(35325) * 16;
+acc += Math.sin(35325) + Math.cos(35326) * 17;
+acc += Math.sin(35326) + Math.cos(35327) * 18;
+acc += Math.sin(35327) + Math.cos(35328) * 19;
+acc += Math.sin(35328) + Math.cos(35329) * 20;
+acc += Math.sin(35329) + Math.cos(35330) * 21;
+acc += Math.sin(35330) + Math.cos(35331) * 22;
+acc += Math.sin(35331) + Math.cos(35332) * 23;
+acc += Math.sin(35332) + Math.cos(35333) * 24;
+acc += Math.sin(35333) + Math.cos(35334) * 25;
+acc += Math.sin(35334) + Math.cos(35335) * 26;
+acc += Math.sin(35335) + Math.cos(35336) * 27;
+acc += Math.sin(35336) + Math.cos(35337) * 28;
+acc += Math.sin(35337) + Math.cos(35338) * 29;
+acc += Math.sin(35338) + Math.cos(35339) * 30;
+acc += Math.sin(35339) + Math.cos(35340) * 31;
+acc += Math.sin(35340) + Math.cos(35341) * 32;
+acc += Math.sin(35341) + Math.cos(35342) * 33;
+acc += Math.sin(35342) + Math.cos(35343) * 34;
+acc += Math.sin(35343) + Math.cos(35344) * 35;
+acc += Math.sin(35344) + Math.cos(35345) * 36;
+acc += Math.sin(35345) + Math.cos(35346) * 37;
+acc += Math.sin(35346) + Math.cos(35347) * 38;
+acc += Math.sin(35347) + Math.cos(35348) * 39;
+acc += Math.sin(35348) + Math.cos(35349) * 40;
+acc += Math.sin(35349) + Math.cos(35350) * 41;
+acc += Math.sin(35350) + Math.cos(35351) * 42;
+acc += Math.sin(35351) + Math.cos(35352) * 43;
+acc += Math.sin(35352) + Math.cos(35353) * 44;
+acc += Math.sin(35353) + Math.cos(35354) * 45;
+acc += Math.sin(35354) + Math.cos(35355) * 46;
+acc += Math.sin(35355) + Math.cos(35356) * 47;
+acc += Math.sin(35356) + Math.cos(35357) * 48;
+acc += Math.sin(35357) + Math.cos(35358) * 49;
+acc += Math.sin(35358) + Math.cos(35359) * 50;
+acc += Math.sin(35359) + Math.cos(35360) * 51;
+acc += Math.sin(35360) + Math.cos(35361) * 52;
+acc += Math.sin(35361) + Math.cos(35362) * 53;
+acc += Math.sin(35362) + Math.cos(35363) * 54;
+acc += Math.sin(35363) + Math.cos(35364) * 55;
+acc += Math.sin(35364) + Math.cos(35365) * 56;
+acc += Math.sin(35365) + Math.cos(35366) * 57;
+acc += Math.sin(35366) + Math.cos(35367) * 58;
+acc += Math.sin(35367) + Math.cos(35368) * 59;
+acc += Math.sin(35368) + Math.cos(35369) * 60;
+acc += Math.sin(35369) + Math.cos(35370) * 61;
+acc += Math.sin(35370) + Math.cos(35371) * 62;
+acc += Math.sin(35371) + Math.cos(35372) * 63;
+acc += Math.sin(35372) + Math.cos(35373) * 64;
+acc += Math.sin(35373) + Math.cos(35374) * 65;
+acc += Math.sin(35374) + Math.cos(35375) * 66;
+acc += Math.sin(35375) + Math.cos(35376) * 67;
+acc += Math.sin(35376) + Math.cos(35377) * 68;
+acc += Math.sin(35377) + Math.cos(35378) * 69;
+acc += Math.sin(35378) + Math.cos(35379) * 70;
+acc += Math.sin(35379) + Math.cos(35380) * 71;
+acc += Math.sin(35380) + Math.cos(35381) * 72;
+acc += Math.sin(35381) + Math.cos(35382) * 73;
+acc += Math.sin(35382) + Math.cos(35383) * 74;
+acc += Math.sin(35383) + Math.cos(35384) * 75;
+acc += Math.sin(35384) + Math.cos(35385) * 76;
+acc += Math.sin(35385) + Math.cos(35386) * 77;
+acc += Math.sin(35386) + Math.cos(35387) * 78;
+acc += Math.sin(35387) + Math.cos(35388) * 79;
+acc += Math.sin(35388) + Math.cos(35389) * 80;
+acc += Math.sin(35389) + Math.cos(35390) * 81;
+acc += Math.sin(35390) + Math.cos(35391) * 82;
+acc += Math.sin(35391) + Math.cos(35392) * 83;
+acc += Math.sin(35392) + Math.cos(35393) * 84;
+acc += Math.sin(35393) + Math.cos(35394) * 85;
+acc += Math.sin(35394) + Math.cos(35395) * 86;
+acc += Math.sin(35395) + Math.cos(35396) * 87;
+acc += Math.sin(35396) + Math.cos(35397) * 88;
+acc += Math.sin(35397) + Math.cos(35398) * 89;
+acc += Math.sin(35398) + Math.cos(35399) * 90;
+acc += Math.sin(35399) + Math.cos(35400) * 91;
+acc += Math.sin(35400) + Math.cos(35401) * 92;
+acc += Math.sin(35401) + Math.cos(35402) * 93;
+acc += Math.sin(35402) + Math.cos(35403) * 94;
+acc += Math.sin(35403) + Math.cos(35404) * 95;
+acc += Math.sin(35404) + Math.cos(35405) * 96;
+acc += Math.sin(35405) + Math.cos(35406) * 0;
+acc += Math.sin(35406) + Math.cos(35407) * 1;
+acc += Math.sin(35407) + Math.cos(35408) * 2;
+acc += Math.sin(35408) + Math.cos(35409) * 3;
+acc += Math.sin(35409) + Math.cos(35410) * 4;
+acc += Math.sin(35410) + Math.cos(35411) * 5;
+acc += Math.sin(35411) + Math.cos(35412) * 6;
+acc += Math.sin(35412) + Math.cos(35413) * 7;
+acc += Math.sin(35413) + Math.cos(35414) * 8;
+acc += Math.sin(35414) + Math.cos(35415) * 9;
+acc += Math.sin(35415) + Math.cos(35416) * 10;
+acc += Math.sin(35416) + Math.cos(35417) * 11;
+acc += Math.sin(35417) + Math.cos(35418) * 12;
+acc += Math.sin(35418) + Math.cos(35419) * 13;
+acc += Math.sin(35419) + Math.cos(35420) * 14;
+acc += Math.sin(35420) + Math.cos(35421) * 15;
+acc += Math.sin(35421) + Math.cos(35422) * 16;
+acc += Math.sin(35422) + Math.cos(35423) * 17;
+acc += Math.sin(35423) + Math.cos(35424) * 18;
+acc += Math.sin(35424) + Math.cos(35425) * 19;
+acc += Math.sin(35425) + Math.cos(35426) * 20;
+acc += Math.sin(35426) + Math.cos(35427) * 21;
+acc += Math.sin(35427) + Math.cos(35428) * 22;
+acc += Math.sin(35428) + Math.cos(35429) * 23;
+acc += Math.sin(35429) + Math.cos(35430) * 24;
+acc += Math.sin(35430) + Math.cos(35431) * 25;
+acc += Math.sin(35431) + Math.cos(35432) * 26;
+acc += Math.sin(35432) + Math.cos(35433) * 27;
+acc += Math.sin(35433) + Math.cos(35434) * 28;
+acc += Math.sin(35434) + Math.cos(35435) * 29;
+acc += Math.sin(35435) + Math.cos(35436) * 30;
+acc += Math.sin(35436) + Math.cos(35437) * 31;
+acc += Math.sin(35437) + Math.cos(35438) * 32;
+acc += Math.sin(35438) + Math.cos(35439) * 33;
+acc += Math.sin(35439) + Math.cos(35440) * 34;
+acc += Math.sin(35440) + Math.cos(35441) * 35;
+acc += Math.sin(35441) + Math.cos(35442) * 36;
+acc += Math.sin(35442) + Math.cos(35443) * 37;
+acc += Math.sin(35443) + Math.cos(35444) * 38;
+acc += Math.sin(35444) + Math.cos(35445) * 39;
+acc += Math.sin(35445) + Math.cos(35446) * 40;
+acc += Math.sin(35446) + Math.cos(35447) * 41;
+acc += Math.sin(35447) + Math.cos(35448) * 42;
+acc += Math.sin(35448) + Math.cos(35449) * 43;
+acc += Math.sin(35449) + Math.cos(35450) * 44;
+acc += Math.sin(35450) + Math.cos(35451) * 45;
+acc += Math.sin(35451) + Math.cos(35452) * 46;
+acc += Math.sin(35452) + Math.cos(35453) * 47;
+acc += Math.sin(35453) + Math.cos(35454) * 48;
+acc += Math.sin(35454) + Math.cos(35455) * 49;
+acc += Math.sin(35455) + Math.cos(35456) * 50;
+acc += Math.sin(35456) + Math.cos(35457) * 51;
+acc += Math.sin(35457) + Math.cos(35458) * 52;
+acc += Math.sin(35458) + Math.cos(35459) * 53;
+acc += Math.sin(35459) + Math.cos(35460) * 54;
+acc += Math.sin(35460) + Math.cos(35461) * 55;
+acc += Math.sin(35461) + Math.cos(35462) * 56;
+acc += Math.sin(35462) + Math.cos(35463) * 57;
+acc += Math.sin(35463) + Math.cos(35464) * 58;
+acc += Math.sin(35464) + Math.cos(35465) * 59;
+acc += Math.sin(35465) + Math.cos(35466) * 60;
+acc += Math.sin(35466) + Math.cos(35467) * 61;
+acc += Math.sin(35467) + Math.cos(35468) * 62;
+acc += Math.sin(35468) + Math.cos(35469) * 63;
+acc += Math.sin(35469) + Math.cos(35470) * 64;
+acc += Math.sin(35470) + Math.cos(35471) * 65;
+acc += Math.sin(35471) + Math.cos(35472) * 66;
+acc += Math.sin(35472) + Math.cos(35473) * 67;
+acc += Math.sin(35473) + Math.cos(35474) * 68;
+acc += Math.sin(35474) + Math.cos(35475) * 69;
+acc += Math.sin(35475) + Math.cos(35476) * 70;
+acc += Math.sin(35476) + Math.cos(35477) * 71;
+acc += Math.sin(35477) + Math.cos(35478) * 72;
+acc += Math.sin(35478) + Math.cos(35479) * 73;
+acc += Math.sin(35479) + Math.cos(35480) * 74;
+acc += Math.sin(35480) + Math.cos(35481) * 75;
+acc += Math.sin(35481) + Math.cos(35482) * 76;
+acc += Math.sin(35482) + Math.cos(35483) * 77;
+acc += Math.sin(35483) + Math.cos(35484) * 78;
+acc += Math.sin(35484) + Math.cos(35485) * 79;
+acc += Math.sin(35485) + Math.cos(35486) * 80;
+acc += Math.sin(35486) + Math.cos(35487) * 81;
+acc += Math.sin(35487) + Math.cos(35488) * 82;
+acc += Math.sin(35488) + Math.cos(35489) * 83;
+acc += Math.sin(35489) + Math.cos(35490) * 84;
+acc += Math.sin(35490) + Math.cos(35491) * 85;
+acc += Math.sin(35491) + Math.cos(35492) * 86;
+acc += Math.sin(35492) + Math.cos(35493) * 87;
+acc += Math.sin(35493) + Math.cos(35494) * 88;
+acc += Math.sin(35494) + Math.cos(35495) * 89;
+acc += Math.sin(35495) + Math.cos(35496) * 90;
+acc += Math.sin(35496) + Math.cos(35497) * 91;
+acc += Math.sin(35497) + Math.cos(35498) * 92;
+acc += Math.sin(35498) + Math.cos(35499) * 93;
+acc += Math.sin(35499) + Math.cos(35500) * 94;
+acc += Math.sin(35500) + Math.cos(35501) * 95;
+acc += Math.sin(35501) + Math.cos(35502) * 96;
+acc += Math.sin(35502) + Math.cos(35503) * 0;
+acc += Math.sin(35503) + Math.cos(35504) * 1;
+acc += Math.sin(35504) + Math.cos(35505) * 2;
+acc += Math.sin(35505) + Math.cos(35506) * 3;
+acc += Math.sin(35506) + Math.cos(35507) * 4;
+acc += Math.sin(35507) + Math.cos(35508) * 5;
+acc += Math.sin(35508) + Math.cos(35509) * 6;
+acc += Math.sin(35509) + Math.cos(35510) * 7;
+acc += Math.sin(35510) + Math.cos(35511) * 8;
+acc += Math.sin(35511) + Math.cos(35512) * 9;
+acc += Math.sin(35512) + Math.cos(35513) * 10;
+acc += Math.sin(35513) + Math.cos(35514) * 11;
+acc += Math.sin(35514) + Math.cos(35515) * 12;
+acc += Math.sin(35515) + Math.cos(35516) * 13;
+acc += Math.sin(35516) + Math.cos(35517) * 14;
+acc += Math.sin(35517) + Math.cos(35518) * 15;
+acc += Math.sin(35518) + Math.cos(35519) * 16;
+acc += Math.sin(35519) + Math.cos(35520) * 17;
+acc += Math.sin(35520) + Math.cos(35521) * 18;
+acc += Math.sin(35521) + Math.cos(35522) * 19;
+acc += Math.sin(35522) + Math.cos(35523) * 20;
+acc += Math.sin(35523) + Math.cos(35524) * 21;
+acc += Math.sin(35524) + Math.cos(35525) * 22;
+acc += Math.sin(35525) + Math.cos(35526) * 23;
+acc += Math.sin(35526) + Math.cos(35527) * 24;
+acc += Math.sin(35527) + Math.cos(35528) * 25;
+acc += Math.sin(35528) + Math.cos(35529) * 26;
+acc += Math.sin(35529) + Math.cos(35530) * 27;
+acc += Math.sin(35530) + Math.cos(35531) * 28;
+acc += Math.sin(35531) + Math.cos(35532) * 29;
+acc += Math.sin(35532) + Math.cos(35533) * 30;
+acc += Math.sin(35533) + Math.cos(35534) * 31;
+acc += Math.sin(35534) + Math.cos(35535) * 32;
+acc += Math.sin(35535) + Math.cos(35536) * 33;
+acc += Math.sin(35536) + Math.cos(35537) * 34;
+acc += Math.sin(35537) + Math.cos(35538) * 35;
+acc += Math.sin(35538) + Math.cos(35539) * 36;
+acc += Math.sin(35539) + Math.cos(35540) * 37;
+acc += Math.sin(35540) + Math.cos(35541) * 38;
+acc += Math.sin(35541) + Math.cos(35542) * 39;
+acc += Math.sin(35542) + Math.cos(35543) * 40;
+acc += Math.sin(35543) + Math.cos(35544) * 41;
+acc += Math.sin(35544) + Math.cos(35545) * 42;
+acc += Math.sin(35545) + Math.cos(35546) * 43;
+acc += Math.sin(35546) + Math.cos(35547) * 44;
+acc += Math.sin(35547) + Math.cos(35548) * 45;
+acc += Math.sin(35548) + Math.cos(35549) * 46;
+acc += Math.sin(35549) + Math.cos(35550) * 47;
+acc += Math.sin(35550) + Math.cos(35551) * 48;
+acc += Math.sin(35551) + Math.cos(35552) * 49;
+acc += Math.sin(35552) + Math.cos(35553) * 50;
+acc += Math.sin(35553) + Math.cos(35554) * 51;
+acc += Math.sin(35554) + Math.cos(35555) * 52;
+acc += Math.sin(35555) + Math.cos(35556) * 53;
+acc += Math.sin(35556) + Math.cos(35557) * 54;
+acc += Math.sin(35557) + Math.cos(35558) * 55;
+acc += Math.sin(35558) + Math.cos(35559) * 56;
+acc += Math.sin(35559) + Math.cos(35560) * 57;
+acc += Math.sin(35560) + Math.cos(35561) * 58;
+acc += Math.sin(35561) + Math.cos(35562) * 59;
+acc += Math.sin(35562) + Math.cos(35563) * 60;
+acc += Math.sin(35563) + Math.cos(35564) * 61;
+acc += Math.sin(35564) + Math.cos(35565) * 62;
+acc += Math.sin(35565) + Math.cos(35566) * 63;
+acc += Math.sin(35566) + Math.cos(35567) * 64;
+acc += Math.sin(35567) + Math.cos(35568) * 65;
+acc += Math.sin(35568) + Math.cos(35569) * 66;
+acc += Math.sin(35569) + Math.cos(35570) * 67;
+acc += Math.sin(35570) + Math.cos(35571) * 68;
+acc += Math.sin(35571) + Math.cos(35572) * 69;
+acc += Math.sin(35572) + Math.cos(35573) * 70;
+acc += Math.sin(35573) + Math.cos(35574) * 71;
+acc += Math.sin(35574) + Math.cos(35575) * 72;
+acc += Math.sin(35575) + Math.cos(35576) * 73;
+acc += Math.sin(35576) + Math.cos(35577) * 74;
+acc += Math.sin(35577) + Math.cos(35578) * 75;
+acc += Math.sin(35578) + Math.cos(35579) * 76;
+acc += Math.sin(35579) + Math.cos(35580) * 77;
+acc += Math.sin(35580) + Math.cos(35581) * 78;
+acc += Math.sin(35581) + Math.cos(35582) * 79;
+acc += Math.sin(35582) + Math.cos(35583) * 80;
+acc += Math.sin(35583) + Math.cos(35584) * 81;
+acc += Math.sin(35584) + Math.cos(35585) * 82;
+acc += Math.sin(35585) + Math.cos(35586) * 83;
+acc += Math.sin(35586) + Math.cos(35587) * 84;
+acc += Math.sin(35587) + Math.cos(35588) * 85;
+acc += Math.sin(35588) + Math.cos(35589) * 86;
+acc += Math.sin(35589) + Math.cos(35590) * 87;
+acc += Math.sin(35590) + Math.cos(35591) * 88;
+acc += Math.sin(35591) + Math.cos(35592) * 89;
+acc += Math.sin(35592) + Math.cos(35593) * 90;
+acc += Math.sin(35593) + Math.cos(35594) * 91;
+acc += Math.sin(35594) + Math.cos(35595) * 92;
+acc += Math.sin(35595) + Math.cos(35596) * 93;
+acc += Math.sin(35596) + Math.cos(35597) * 94;
+acc += Math.sin(35597) + Math.cos(35598) * 95;
+acc += Math.sin(35598) + Math.cos(35599) * 96;
+acc += Math.sin(35599) + Math.cos(35600) * 0;
+acc += Math.sin(35600) + Math.cos(35601) * 1;
+acc += Math.sin(35601) + Math.cos(35602) * 2;
+acc += Math.sin(35602) + Math.cos(35603) * 3;
+acc += Math.sin(35603) + Math.cos(35604) * 4;
+acc += Math.sin(35604) + Math.cos(35605) * 5;
+acc += Math.sin(35605) + Math.cos(35606) * 6;
+acc += Math.sin(35606) + Math.cos(35607) * 7;
+acc += Math.sin(35607) + Math.cos(35608) * 8;
+acc += Math.sin(35608) + Math.cos(35609) * 9;
+acc += Math.sin(35609) + Math.cos(35610) * 10;
+acc += Math.sin(35610) + Math.cos(35611) * 11;
+acc += Math.sin(35611) + Math.cos(35612) * 12;
+acc += Math.sin(35612) + Math.cos(35613) * 13;
+acc += Math.sin(35613) + Math.cos(35614) * 14;
+acc += Math.sin(35614) + Math.cos(35615) * 15;
+acc += Math.sin(35615) + Math.cos(35616) * 16;
+acc += Math.sin(35616) + Math.cos(35617) * 17;
+acc += Math.sin(35617) + Math.cos(35618) * 18;
+acc += Math.sin(35618) + Math.cos(35619) * 19;
+acc += Math.sin(35619) + Math.cos(35620) * 20;
+acc += Math.sin(35620) + Math.cos(35621) * 21;
+acc += Math.sin(35621) + Math.cos(35622) * 22;
+acc += Math.sin(35622) + Math.cos(35623) * 23;
+acc += Math.sin(35623) + Math.cos(35624) * 24;
+acc += Math.sin(35624) + Math.cos(35625) * 25;
+acc += Math.sin(35625) + Math.cos(35626) * 26;
+acc += Math.sin(35626) + Math.cos(35627) * 27;
+acc += Math.sin(35627) + Math.cos(35628) * 28;
+acc += Math.sin(35628) + Math.cos(35629) * 29;
+acc += Math.sin(35629) + Math.cos(35630) * 30;
+acc += Math.sin(35630) + Math.cos(35631) * 31;
+acc += Math.sin(35631) + Math.cos(35632) * 32;
+acc += Math.sin(35632) + Math.cos(35633) * 33;
+acc += Math.sin(35633) + Math.cos(35634) * 34;
+acc += Math.sin(35634) + Math.cos(35635) * 35;
+acc += Math.sin(35635) + Math.cos(35636) * 36;
+acc += Math.sin(35636) + Math.cos(35637) * 37;
+acc += Math.sin(35637) + Math.cos(35638) * 38;
+acc += Math.sin(35638) + Math.cos(35639) * 39;
+acc += Math.sin(35639) + Math.cos(35640) * 40;
+acc += Math.sin(35640) + Math.cos(35641) * 41;
+acc += Math.sin(35641) + Math.cos(35642) * 42;
+acc += Math.sin(35642) + Math.cos(35643) * 43;
+acc += Math.sin(35643) + Math.cos(35644) * 44;
+acc += Math.sin(35644) + Math.cos(35645) * 45;
+acc += Math.sin(35645) + Math.cos(35646) * 46;
+acc += Math.sin(35646) + Math.cos(35647) * 47;
+acc += Math.sin(35647) + Math.cos(35648) * 48;
+acc += Math.sin(35648) + Math.cos(35649) * 49;
+acc += Math.sin(35649) + Math.cos(35650) * 50;
+acc += Math.sin(35650) + Math.cos(35651) * 51;
+acc += Math.sin(35651) + Math.cos(35652) * 52;
+acc += Math.sin(35652) + Math.cos(35653) * 53;
+acc += Math.sin(35653) + Math.cos(35654) * 54;
+acc += Math.sin(35654) + Math.cos(35655) * 55;
+acc += Math.sin(35655) + Math.cos(35656) * 56;
+acc += Math.sin(35656) + Math.cos(35657) * 57;
+acc += Math.sin(35657) + Math.cos(35658) * 58;
+acc += Math.sin(35658) + Math.cos(35659) * 59;
+acc += Math.sin(35659) + Math.cos(35660) * 60;
+acc += Math.sin(35660) + Math.cos(35661) * 61;
+acc += Math.sin(35661) + Math.cos(35662) * 62;
+acc += Math.sin(35662) + Math.cos(35663) * 63;
+acc += Math.sin(35663) + Math.cos(35664) * 64;
+acc += Math.sin(35664) + Math.cos(35665) * 65;
+acc += Math.sin(35665) + Math.cos(35666) * 66;
+acc += Math.sin(35666) + Math.cos(35667) * 67;
+acc += Math.sin(35667) + Math.cos(35668) * 68;
+acc += Math.sin(35668) + Math.cos(35669) * 69;
+acc += Math.sin(35669) + Math.cos(35670) * 70;
+acc += Math.sin(35670) + Math.cos(35671) * 71;
+acc += Math.sin(35671) + Math.cos(35672) * 72;
+acc += Math.sin(35672) + Math.cos(35673) * 73;
+acc += Math.sin(35673) + Math.cos(35674) * 74;
+acc += Math.sin(35674) + Math.cos(35675) * 75;
+acc += Math.sin(35675) + Math.cos(35676) * 76;
+acc += Math.sin(35676) + Math.cos(35677) * 77;
+acc += Math.sin(35677) + Math.cos(35678) * 78;
+acc += Math.sin(35678) + Math.cos(35679) * 79;
+acc += Math.sin(35679) + Math.cos(35680) * 80;
+acc += Math.sin(35680) + Math.cos(35681) * 81;
+acc += Math.sin(35681) + Math.cos(35682) * 82;
+acc += Math.sin(35682) + Math.cos(35683) * 83;
+acc += Math.sin(35683) + Math.cos(35684) * 84;
+acc += Math.sin(35684) + Math.cos(35685) * 85;
+acc += Math.sin(35685) + Math.cos(35686) * 86;
+acc += Math.sin(35686) + Math.cos(35687) * 87;
+acc += Math.sin(35687) + Math.cos(35688) * 88;
+acc += Math.sin(35688) + Math.cos(35689) * 89;
+acc += Math.sin(35689) + Math.cos(35690) * 90;
+acc += Math.sin(35690) + Math.cos(35691) * 91;
+acc += Math.sin(35691) + Math.cos(35692) * 92;
+acc += Math.sin(35692) + Math.cos(35693) * 93;
+acc += Math.sin(35693) + Math.cos(35694) * 94;
+acc += Math.sin(35694) + Math.cos(35695) * 95;
+acc += Math.sin(35695) + Math.cos(35696) * 96;
+acc += Math.sin(35696) + Math.cos(35697) * 0;
+acc += Math.sin(35697) + Math.cos(35698) * 1;
+acc += Math.sin(35698) + Math.cos(35699) * 2;
+acc += Math.sin(35699) + Math.cos(35700) * 3;
+acc += Math.sin(35700) + Math.cos(35701) * 4;
+acc += Math.sin(35701) + Math.cos(35702) * 5;
+acc += Math.sin(35702) + Math.cos(35703) * 6;
+acc += Math.sin(35703) + Math.cos(35704) * 7;
+acc += Math.sin(35704) + Math.cos(35705) * 8;
+acc += Math.sin(35705) + Math.cos(35706) * 9;
+acc += Math.sin(35706) + Math.cos(35707) * 10;
+acc += Math.sin(35707) + Math.cos(35708) * 11;
+acc += Math.sin(35708) + Math.cos(35709) * 12;
+acc += Math.sin(35709) + Math.cos(35710) * 13;
+acc += Math.sin(35710) + Math.cos(35711) * 14;
+acc += Math.sin(35711) + Math.cos(35712) * 15;
+acc += Math.sin(35712) + Math.cos(35713) * 16;
+acc += Math.sin(35713) + Math.cos(35714) * 17;
+acc += Math.sin(35714) + Math.cos(35715) * 18;
+acc += Math.sin(35715) + Math.cos(35716) * 19;
+acc += Math.sin(35716) + Math.cos(35717) * 20;
+acc += Math.sin(35717) + Math.cos(35718) * 21;
+acc += Math.sin(35718) + Math.cos(35719) * 22;
+acc += Math.sin(35719) + Math.cos(35720) * 23;
+acc += Math.sin(35720) + Math.cos(35721) * 24;
+acc += Math.sin(35721) + Math.cos(35722) * 25;
+acc += Math.sin(35722) + Math.cos(35723) * 26;
+acc += Math.sin(35723) + Math.cos(35724) * 27;
+acc += Math.sin(35724) + Math.cos(35725) * 28;
+acc += Math.sin(35725) + Math.cos(35726) * 29;
+acc += Math.sin(35726) + Math.cos(35727) * 30;
+acc += Math.sin(35727) + Math.cos(35728) * 31;
+acc += Math.sin(35728) + Math.cos(35729) * 32;
+acc += Math.sin(35729) + Math.cos(35730) * 33;
+acc += Math.sin(35730) + Math.cos(35731) * 34;
+acc += Math.sin(35731) + Math.cos(35732) * 35;
+acc += Math.sin(35732) + Math.cos(35733) * 36;
+acc += Math.sin(35733) + Math.cos(35734) * 37;
+acc += Math.sin(35734) + Math.cos(35735) * 38;
+acc += Math.sin(35735) + Math.cos(35736) * 39;
+acc += Math.sin(35736) + Math.cos(35737) * 40;
+acc += Math.sin(35737) + Math.cos(35738) * 41;
+acc += Math.sin(35738) + Math.cos(35739) * 42;
+acc += Math.sin(35739) + Math.cos(35740) * 43;
+acc += Math.sin(35740) + Math.cos(35741) * 44;
+acc += Math.sin(35741) + Math.cos(35742) * 45;
+acc += Math.sin(35742) + Math.cos(35743) * 46;
+acc += Math.sin(35743) + Math.cos(35744) * 47;
+acc += Math.sin(35744) + Math.cos(35745) * 48;
+acc += Math.sin(35745) + Math.cos(35746) * 49;
+acc += Math.sin(35746) + Math.cos(35747) * 50;
+acc += Math.sin(35747) + Math.cos(35748) * 51;
+acc += Math.sin(35748) + Math.cos(35749) * 52;
+acc += Math.sin(35749) + Math.cos(35750) * 53;
+acc += Math.sin(35750) + Math.cos(35751) * 54;
+acc += Math.sin(35751) + Math.cos(35752) * 55;
+acc += Math.sin(35752) + Math.cos(35753) * 56;
+acc += Math.sin(35753) + Math.cos(35754) * 57;
+acc += Math.sin(35754) + Math.cos(35755) * 58;
+acc += Math.sin(35755) + Math.cos(35756) * 59;
+acc += Math.sin(35756) + Math.cos(35757) * 60;
+acc += Math.sin(35757) + Math.cos(35758) * 61;
+acc += Math.sin(35758) + Math.cos(35759) * 62;
+acc += Math.sin(35759) + Math.cos(35760) * 63;
+acc += Math.sin(35760) + Math.cos(35761) * 64;
+acc += Math.sin(35761) + Math.cos(35762) * 65;
+acc += Math.sin(35762) + Math.cos(35763) * 66;
+acc += Math.sin(35763) + Math.cos(35764) * 67;
+acc += Math.sin(35764) + Math.cos(35765) * 68;
+acc += Math.sin(35765) + Math.cos(35766) * 69;
+acc += Math.sin(35766) + Math.cos(35767) * 70;
+acc += Math.sin(35767) + Math.cos(35768) * 71;
+acc += Math.sin(35768) + Math.cos(35769) * 72;
+acc += Math.sin(35769) + Math.cos(35770) * 73;
+acc += Math.sin(35770) + Math.cos(35771) * 74;
+acc += Math.sin(35771) + Math.cos(35772) * 75;
+acc += Math.sin(35772) + Math.cos(35773) * 76;
+acc += Math.sin(35773) + Math.cos(35774) * 77;
+acc += Math.sin(35774) + Math.cos(35775) * 78;
+acc += Math.sin(35775) + Math.cos(35776) * 79;
+acc += Math.sin(35776) + Math.cos(35777) * 80;
+acc += Math.sin(35777) + Math.cos(35778) * 81;
+acc += Math.sin(35778) + Math.cos(35779) * 82;
+acc += Math.sin(35779) + Math.cos(35780) * 83;
+acc += Math.sin(35780) + Math.cos(35781) * 84;
+acc += Math.sin(35781) + Math.cos(35782) * 85;
+acc += Math.sin(35782) + Math.cos(35783) * 86;
+acc += Math.sin(35783) + Math.cos(35784) * 87;
+acc += Math.sin(35784) + Math.cos(35785) * 88;
+acc += Math.sin(35785) + Math.cos(35786) * 89;
+acc += Math.sin(35786) + Math.cos(35787) * 90;
+acc += Math.sin(35787) + Math.cos(35788) * 91;
+acc += Math.sin(35788) + Math.cos(35789) * 92;
+acc += Math.sin(35789) + Math.cos(35790) * 93;
+acc += Math.sin(35790) + Math.cos(35791) * 94;
+acc += Math.sin(35791) + Math.cos(35792) * 95;
+acc += Math.sin(35792) + Math.cos(35793) * 96;
+acc += Math.sin(35793) + Math.cos(35794) * 0;
+acc += Math.sin(35794) + Math.cos(35795) * 1;
+acc += Math.sin(35795) + Math.cos(35796) * 2;
+acc += Math.sin(35796) + Math.cos(35797) * 3;
+acc += Math.sin(35797) + Math.cos(35798) * 4;
+acc += Math.sin(35798) + Math.cos(35799) * 5;
+acc += Math.sin(35799) + Math.cos(35800) * 6;
+acc += Math.sin(35800) + Math.cos(35801) * 7;
+acc += Math.sin(35801) + Math.cos(35802) * 8;
+acc += Math.sin(35802) + Math.cos(35803) * 9;
+acc += Math.sin(35803) + Math.cos(35804) * 10;
+acc += Math.sin(35804) + Math.cos(35805) * 11;
+acc += Math.sin(35805) + Math.cos(35806) * 12;
+acc += Math.sin(35806) + Math.cos(35807) * 13;
+acc += Math.sin(35807) + Math.cos(35808) * 14;
+acc += Math.sin(35808) + Math.cos(35809) * 15;
+acc += Math.sin(35809) + Math.cos(35810) * 16;
+acc += Math.sin(35810) + Math.cos(35811) * 17;
+acc += Math.sin(35811) + Math.cos(35812) * 18;
+acc += Math.sin(35812) + Math.cos(35813) * 19;
+acc += Math.sin(35813) + Math.cos(35814) * 20;
+acc += Math.sin(35814) + Math.cos(35815) * 21;
+acc += Math.sin(35815) + Math.cos(35816) * 22;
+acc += Math.sin(35816) + Math.cos(35817) * 23;
+acc += Math.sin(35817) + Math.cos(35818) * 24;
+acc += Math.sin(35818) + Math.cos(35819) * 25;
+acc += Math.sin(35819) + Math.cos(35820) * 26;
+acc += Math.sin(35820) + Math.cos(35821) * 27;
+acc += Math.sin(35821) + Math.cos(35822) * 28;
+acc += Math.sin(35822) + Math.cos(35823) * 29;
+acc += Math.sin(35823) + Math.cos(35824) * 30;
+acc += Math.sin(35824) + Math.cos(35825) * 31;
+acc += Math.sin(35825) + Math.cos(35826) * 32;
+acc += Math.sin(35826) + Math.cos(35827) * 33;
+acc += Math.sin(35827) + Math.cos(35828) * 34;
+acc += Math.sin(35828) + Math.cos(35829) * 35;
+acc += Math.sin(35829) + Math.cos(35830) * 36;
+acc += Math.sin(35830) + Math.cos(35831) * 37;
+acc += Math.sin(35831) + Math.cos(35832) * 38;
+acc += Math.sin(35832) + Math.cos(35833) * 39;
+acc += Math.sin(35833) + Math.cos(35834) * 40;
+acc += Math.sin(35834) + Math.cos(35835) * 41;
+acc += Math.sin(35835) + Math.cos(35836) * 42;
+acc += Math.sin(35836) + Math.cos(35837) * 43;
+acc += Math.sin(35837) + Math.cos(35838) * 44;
+acc += Math.sin(35838) + Math.cos(35839) * 45;
+acc += Math.sin(35839) + Math.cos(35840) * 46;
+acc += Math.sin(35840) + Math.cos(35841) * 47;
+acc += Math.sin(35841) + Math.cos(35842) * 48;
+acc += Math.sin(35842) + Math.cos(35843) * 49;
+acc += Math.sin(35843) + Math.cos(35844) * 50;
+acc += Math.sin(35844) + Math.cos(35845) * 51;
+acc += Math.sin(35845) + Math.cos(35846) * 52;
+acc += Math.sin(35846) + Math.cos(35847) * 53;
+acc += Math.sin(35847) + Math.cos(35848) * 54;
+acc += Math.sin(35848) + Math.cos(35849) * 55;
+acc += Math.sin(35849) + Math.cos(35850) * 56;
+acc += Math.sin(35850) + Math.cos(35851) * 57;
+acc += Math.sin(35851) + Math.cos(35852) * 58;
+acc += Math.sin(35852) + Math.cos(35853) * 59;
+acc += Math.sin(35853) + Math.cos(35854) * 60;
+acc += Math.sin(35854) + Math.cos(35855) * 61;
+acc += Math.sin(35855) + Math.cos(35856) * 62;
+acc += Math.sin(35856) + Math.cos(35857) * 63;
+acc += Math.sin(35857) + Math.cos(35858) * 64;
+acc += Math.sin(35858) + Math.cos(35859) * 65;
+acc += Math.sin(35859) + Math.cos(35860) * 66;
+acc += Math.sin(35860) + Math.cos(35861) * 67;
+acc += Math.sin(35861) + Math.cos(35862) * 68;
+acc += Math.sin(35862) + Math.cos(35863) * 69;
+acc += Math.sin(35863) + Math.cos(35864) * 70;
+acc += Math.sin(35864) + Math.cos(35865) * 71;
+acc += Math.sin(35865) + Math.cos(35866) * 72;
+acc += Math.sin(35866) + Math.cos(35867) * 73;
+acc += Math.sin(35867) + Math.cos(35868) * 74;
+acc += Math.sin(35868) + Math.cos(35869) * 75;
+acc += Math.sin(35869) + Math.cos(35870) * 76;
+acc += Math.sin(35870) + Math.cos(35871) * 77;
+acc += Math.sin(35871) + Math.cos(35872) * 78;
+acc += Math.sin(35872) + Math.cos(35873) * 79;
+acc += Math.sin(35873) + Math.cos(35874) * 80;
+acc += Math.sin(35874) + Math.cos(35875) * 81;
+acc += Math.sin(35875) + Math.cos(35876) * 82;
+acc += Math.sin(35876) + Math.cos(35877) * 83;
+acc += Math.sin(35877) + Math.cos(35878) * 84;
+acc += Math.sin(35878) + Math.cos(35879) * 85;
+acc += Math.sin(35879) + Math.cos(35880) * 86;
+acc += Math.sin(35880) + Math.cos(35881) * 87;
+acc += Math.sin(35881) + Math.cos(35882) * 88;
+acc += Math.sin(35882) + Math.cos(35883) * 89;
+acc += Math.sin(35883) + Math.cos(35884) * 90;
+acc += Math.sin(35884) + Math.cos(35885) * 91;
+acc += Math.sin(35885) + Math.cos(35886) * 92;
+acc += Math.sin(35886) + Math.cos(35887) * 93;
+acc += Math.sin(35887) + Math.cos(35888) * 94;
+acc += Math.sin(35888) + Math.cos(35889) * 95;
+acc += Math.sin(35889) + Math.cos(35890) * 96;
+acc += Math.sin(35890) + Math.cos(35891) * 0;
+acc += Math.sin(35891) + Math.cos(35892) * 1;
+acc += Math.sin(35892) + Math.cos(35893) * 2;
+acc += Math.sin(35893) + Math.cos(35894) * 3;
+acc += Math.sin(35894) + Math.cos(35895) * 4;
+acc += Math.sin(35895) + Math.cos(35896) * 5;
+acc += Math.sin(35896) + Math.cos(35897) * 6;
+acc += Math.sin(35897) + Math.cos(35898) * 7;
+acc += Math.sin(35898) + Math.cos(35899) * 8;
+acc += Math.sin(35899) + Math.cos(35900) * 9;
+acc += Math.sin(35900) + Math.cos(35901) * 10;
+acc += Math.sin(35901) + Math.cos(35902) * 11;
+acc += Math.sin(35902) + Math.cos(35903) * 12;
+acc += Math.sin(35903) + Math.cos(35904) * 13;
+acc += Math.sin(35904) + Math.cos(35905) * 14;
+acc += Math.sin(35905) + Math.cos(35906) * 15;
+acc += Math.sin(35906) + Math.cos(35907) * 16;
+acc += Math.sin(35907) + Math.cos(35908) * 17;
+acc += Math.sin(35908) + Math.cos(35909) * 18;
+acc += Math.sin(35909) + Math.cos(35910) * 19;
+acc += Math.sin(35910) + Math.cos(35911) * 20;
+acc += Math.sin(35911) + Math.cos(35912) * 21;
+acc += Math.sin(35912) + Math.cos(35913) * 22;
+acc += Math.sin(35913) + Math.cos(35914) * 23;
+acc += Math.sin(35914) + Math.cos(35915) * 24;
+acc += Math.sin(35915) + Math.cos(35916) * 25;
+acc += Math.sin(35916) + Math.cos(35917) * 26;
+acc += Math.sin(35917) + Math.cos(35918) * 27;
+acc += Math.sin(35918) + Math.cos(35919) * 28;
+acc += Math.sin(35919) + Math.cos(35920) * 29;
+acc += Math.sin(35920) + Math.cos(35921) * 30;
+acc += Math.sin(35921) + Math.cos(35922) * 31;
+acc += Math.sin(35922) + Math.cos(35923) * 32;
+acc += Math.sin(35923) + Math.cos(35924) * 33;
+acc += Math.sin(35924) + Math.cos(35925) * 34;
+acc += Math.sin(35925) + Math.cos(35926) * 35;
+acc += Math.sin(35926) + Math.cos(35927) * 36;
+acc += Math.sin(35927) + Math.cos(35928) * 37;
+acc += Math.sin(35928) + Math.cos(35929) * 38;
+acc += Math.sin(35929) + Math.cos(35930) * 39;
+acc += Math.sin(35930) + Math.cos(35931) * 40;
+acc += Math.sin(35931) + Math.cos(35932) * 41;
+acc += Math.sin(35932) + Math.cos(35933) * 42;
+acc += Math.sin(35933) + Math.cos(35934) * 43;
+acc += Math.sin(35934) + Math.cos(35935) * 44;
+acc += Math.sin(35935) + Math.cos(35936) * 45;
+acc += Math.sin(35936) + Math.cos(35937) * 46;
+acc += Math.sin(35937) + Math.cos(35938) * 47;
+acc += Math.sin(35938) + Math.cos(35939) * 48;
+acc += Math.sin(35939) + Math.cos(35940) * 49;
+acc += Math.sin(35940) + Math.cos(35941) * 50;
+acc += Math.sin(35941) + Math.cos(35942) * 51;
+acc += Math.sin(35942) + Math.cos(35943) * 52;
+acc += Math.sin(35943) + Math.cos(35944) * 53;
+acc += Math.sin(35944) + Math.cos(35945) * 54;
+acc += Math.sin(35945) + Math.cos(35946) * 55;
+acc += Math.sin(35946) + Math.cos(35947) * 56;
+acc += Math.sin(35947) + Math.cos(35948) * 57;
+acc += Math.sin(35948) + Math.cos(35949) * 58;
+acc += Math.sin(35949) + Math.cos(35950) * 59;
+acc += Math.sin(35950) + Math.cos(35951) * 60;
+acc += Math.sin(35951) + Math.cos(35952) * 61;
+acc += Math.sin(35952) + Math.cos(35953) * 62;
+acc += Math.sin(35953) + Math.cos(35954) * 63;
+acc += Math.sin(35954) + Math.cos(35955) * 64;
+acc += Math.sin(35955) + Math.cos(35956) * 65;
+acc += Math.sin(35956) + Math.cos(35957) * 66;
+acc += Math.sin(35957) + Math.cos(35958) * 67;
+acc += Math.sin(35958) + Math.cos(35959) * 68;
+acc += Math.sin(35959) + Math.cos(35960) * 69;
+acc += Math.sin(35960) + Math.cos(35961) * 70;
+acc += Math.sin(35961) + Math.cos(35962) * 71;
+acc += Math.sin(35962) + Math.cos(35963) * 72;
+acc += Math.sin(35963) + Math.cos(35964) * 73;
+acc += Math.sin(35964) + Math.cos(35965) * 74;
+acc += Math.sin(35965) + Math.cos(35966) * 75;
+acc += Math.sin(35966) + Math.cos(35967) * 76;
+acc += Math.sin(35967) + Math.cos(35968) * 77;
+acc += Math.sin(35968) + Math.cos(35969) * 78;
+acc += Math.sin(35969) + Math.cos(35970) * 79;
+acc += Math.sin(35970) + Math.cos(35971) * 80;
+acc += Math.sin(35971) + Math.cos(35972) * 81;
+acc += Math.sin(35972) + Math.cos(35973) * 82;
+acc += Math.sin(35973) + Math.cos(35974) * 83;
+acc += Math.sin(35974) + Math.cos(35975) * 84;
+acc += Math.sin(35975) + Math.cos(35976) * 85;
+acc += Math.sin(35976) + Math.cos(35977) * 86;
+acc += Math.sin(35977) + Math.cos(35978) * 87;
+acc += Math.sin(35978) + Math.cos(35979) * 88;
+acc += Math.sin(35979) + Math.cos(35980) * 89;
+acc += Math.sin(35980) + Math.cos(35981) * 90;
+acc += Math.sin(35981) + Math.cos(35982) * 91;
+acc += Math.sin(35982) + Math.cos(35983) * 92;
+acc += Math.sin(35983) + Math.cos(35984) * 93;
+acc += Math.sin(35984) + Math.cos(35985) * 94;
+acc += Math.sin(35985) + Math.cos(35986) * 95;
+acc += Math.sin(35986) + Math.cos(35987) * 96;
+acc += Math.sin(35987) + Math.cos(35988) * 0;
+acc += Math.sin(35988) + Math.cos(35989) * 1;
+acc += Math.sin(35989) + Math.cos(35990) * 2;
+acc += Math.sin(35990) + Math.cos(35991) * 3;
+acc += Math.sin(35991) + Math.cos(35992) * 4;
+acc += Math.sin(35992) + Math.cos(35993) * 5;
+acc += Math.sin(35993) + Math.cos(35994) * 6;
+acc += Math.sin(35994) + Math.cos(35995) * 7;
+acc += Math.sin(35995) + Math.cos(35996) * 8;
+acc += Math.sin(35996) + Math.cos(35997) * 9;
+acc += Math.sin(35997) + Math.cos(35998) * 10;
+acc += Math.sin(35998) + Math.cos(35999) * 11;
+acc += Math.sin(35999) + Math.cos(36000) * 12;
+acc += Math.sin(36000) + Math.cos(36001) * 13;
+acc += Math.sin(36001) + Math.cos(36002) * 14;
+acc += Math.sin(36002) + Math.cos(36003) * 15;
+acc += Math.sin(36003) + Math.cos(36004) * 16;
+acc += Math.sin(36004) + Math.cos(36005) * 17;
+acc += Math.sin(36005) + Math.cos(36006) * 18;
+acc += Math.sin(36006) + Math.cos(36007) * 19;
+acc += Math.sin(36007) + Math.cos(36008) * 20;
+acc += Math.sin(36008) + Math.cos(36009) * 21;
+acc += Math.sin(36009) + Math.cos(36010) * 22;
+acc += Math.sin(36010) + Math.cos(36011) * 23;
+acc += Math.sin(36011) + Math.cos(36012) * 24;
+acc += Math.sin(36012) + Math.cos(36013) * 25;
+acc += Math.sin(36013) + Math.cos(36014) * 26;
+acc += Math.sin(36014) + Math.cos(36015) * 27;
+acc += Math.sin(36015) + Math.cos(36016) * 28;
+acc += Math.sin(36016) + Math.cos(36017) * 29;
+acc += Math.sin(36017) + Math.cos(36018) * 30;
+acc += Math.sin(36018) + Math.cos(36019) * 31;
+acc += Math.sin(36019) + Math.cos(36020) * 32;
+acc += Math.sin(36020) + Math.cos(36021) * 33;
+acc += Math.sin(36021) + Math.cos(36022) * 34;
+acc += Math.sin(36022) + Math.cos(36023) * 35;
+acc += Math.sin(36023) + Math.cos(36024) * 36;
+acc += Math.sin(36024) + Math.cos(36025) * 37;
+acc += Math.sin(36025) + Math.cos(36026) * 38;
+acc += Math.sin(36026) + Math.cos(36027) * 39;
+acc += Math.sin(36027) + Math.cos(36028) * 40;
+acc += Math.sin(36028) + Math.cos(36029) * 41;
+acc += Math.sin(36029) + Math.cos(36030) * 42;
+acc += Math.sin(36030) + Math.cos(36031) * 43;
+acc += Math.sin(36031) + Math.cos(36032) * 44;
+acc += Math.sin(36032) + Math.cos(36033) * 45;
+acc += Math.sin(36033) + Math.cos(36034) * 46;
+acc += Math.sin(36034) + Math.cos(36035) * 47;
+acc += Math.sin(36035) + Math.cos(36036) * 48;
+acc += Math.sin(36036) + Math.cos(36037) * 49;
+acc += Math.sin(36037) + Math.cos(36038) * 50;
+acc += Math.sin(36038) + Math.cos(36039) * 51;
+acc += Math.sin(36039) + Math.cos(36040) * 52;
+acc += Math.sin(36040) + Math.cos(36041) * 53;
+acc += Math.sin(36041) + Math.cos(36042) * 54;
+acc += Math.sin(36042) + Math.cos(36043) * 55;
+acc += Math.sin(36043) + Math.cos(36044) * 56;
+acc += Math.sin(36044) + Math.cos(36045) * 57;
+acc += Math.sin(36045) + Math.cos(36046) * 58;
+acc += Math.sin(36046) + Math.cos(36047) * 59;
+acc += Math.sin(36047) + Math.cos(36048) * 60;
+acc += Math.sin(36048) + Math.cos(36049) * 61;
+acc += Math.sin(36049) + Math.cos(36050) * 62;
+acc += Math.sin(36050) + Math.cos(36051) * 63;
+acc += Math.sin(36051) + Math.cos(36052) * 64;
+acc += Math.sin(36052) + Math.cos(36053) * 65;
+acc += Math.sin(36053) + Math.cos(36054) * 66;
+acc += Math.sin(36054) + Math.cos(36055) * 67;
+acc += Math.sin(36055) + Math.cos(36056) * 68;
+acc += Math.sin(36056) + Math.cos(36057) * 69;
+acc += Math.sin(36057) + Math.cos(36058) * 70;
+acc += Math.sin(36058) + Math.cos(36059) * 71;
+acc += Math.sin(36059) + Math.cos(36060) * 72;
+acc += Math.sin(36060) + Math.cos(36061) * 73;
+acc += Math.sin(36061) + Math.cos(36062) * 74;
+acc += Math.sin(36062) + Math.cos(36063) * 75;
+acc += Math.sin(36063) + Math.cos(36064) * 76;
+acc += Math.sin(36064) + Math.cos(36065) * 77;
+acc += Math.sin(36065) + Math.cos(36066) * 78;
+acc += Math.sin(36066) + Math.cos(36067) * 79;
+acc += Math.sin(36067) + Math.cos(36068) * 80;
+acc += Math.sin(36068) + Math.cos(36069) * 81;
+acc += Math.sin(36069) + Math.cos(36070) * 82;
+acc += Math.sin(36070) + Math.cos(36071) * 83;
+acc += Math.sin(36071) + Math.cos(36072) * 84;
+acc += Math.sin(36072) + Math.cos(36073) * 85;
+acc += Math.sin(36073) + Math.cos(36074) * 86;
+acc += Math.sin(36074) + Math.cos(36075) * 87;
+acc += Math.sin(36075) + Math.cos(36076) * 88;
+acc += Math.sin(36076) + Math.cos(36077) * 89;
+acc += Math.sin(36077) + Math.cos(36078) * 90;
+acc += Math.sin(36078) + Math.cos(36079) * 91;
+acc += Math.sin(36079) + Math.cos(36080) * 92;
+acc += Math.sin(36080) + Math.cos(36081) * 93;
+acc += Math.sin(36081) + Math.cos(36082) * 94;
+acc += Math.sin(36082) + Math.cos(36083) * 95;
+acc += Math.sin(36083) + Math.cos(36084) * 96;
+acc += Math.sin(36084) + Math.cos(36085) * 0;
+acc += Math.sin(36085) + Math.cos(36086) * 1;
+acc += Math.sin(36086) + Math.cos(36087) * 2;
+acc += Math.sin(36087) + Math.cos(36088) * 3;
+acc += Math.sin(36088) + Math.cos(36089) * 4;
+acc += Math.sin(36089) + Math.cos(36090) * 5;
+acc += Math.sin(36090) + Math.cos(36091) * 6;
+acc += Math.sin(36091) + Math.cos(36092) * 7;
+acc += Math.sin(36092) + Math.cos(36093) * 8;
+acc += Math.sin(36093) + Math.cos(36094) * 9;
+acc += Math.sin(36094) + Math.cos(36095) * 10;
+acc += Math.sin(36095) + Math.cos(36096) * 11;
+acc += Math.sin(36096) + Math.cos(36097) * 12;
+acc += Math.sin(36097) + Math.cos(36098) * 13;
+acc += Math.sin(36098) + Math.cos(36099) * 14;
+acc += Math.sin(36099) + Math.cos(36100) * 15;
+acc += Math.sin(36100) + Math.cos(36101) * 16;
+acc += Math.sin(36101) + Math.cos(36102) * 17;
+acc += Math.sin(36102) + Math.cos(36103) * 18;
+acc += Math.sin(36103) + Math.cos(36104) * 19;
+acc += Math.sin(36104) + Math.cos(36105) * 20;
+acc += Math.sin(36105) + Math.cos(36106) * 21;
+acc += Math.sin(36106) + Math.cos(36107) * 22;
+acc += Math.sin(36107) + Math.cos(36108) * 23;
+acc += Math.sin(36108) + Math.cos(36109) * 24;
+acc += Math.sin(36109) + Math.cos(36110) * 25;
+acc += Math.sin(36110) + Math.cos(36111) * 26;
+acc += Math.sin(36111) + Math.cos(36112) * 27;
+acc += Math.sin(36112) + Math.cos(36113) * 28;
+acc += Math.sin(36113) + Math.cos(36114) * 29;
+acc += Math.sin(36114) + Math.cos(36115) * 30;
+acc += Math.sin(36115) + Math.cos(36116) * 31;
+acc += Math.sin(36116) + Math.cos(36117) * 32;
+acc += Math.sin(36117) + Math.cos(36118) * 33;
+acc += Math.sin(36118) + Math.cos(36119) * 34;
+acc += Math.sin(36119) + Math.cos(36120) * 35;
+acc += Math.sin(36120) + Math.cos(36121) * 36;
+acc += Math.sin(36121) + Math.cos(36122) * 37;
+acc += Math.sin(36122) + Math.cos(36123) * 38;
+acc += Math.sin(36123) + Math.cos(36124) * 39;
+acc += Math.sin(36124) + Math.cos(36125) * 40;
+acc += Math.sin(36125) + Math.cos(36126) * 41;
+acc += Math.sin(36126) + Math.cos(36127) * 42;
+acc += Math.sin(36127) + Math.cos(36128) * 43;
+acc += Math.sin(36128) + Math.cos(36129) * 44;
+acc += Math.sin(36129) + Math.cos(36130) * 45;
+acc += Math.sin(36130) + Math.cos(36131) * 46;
+acc += Math.sin(36131) + Math.cos(36132) * 47;
+acc += Math.sin(36132) + Math.cos(36133) * 48;
+acc += Math.sin(36133) + Math.cos(36134) * 49;
+acc += Math.sin(36134) + Math.cos(36135) * 50;
+acc += Math.sin(36135) + Math.cos(36136) * 51;
+acc += Math.sin(36136) + Math.cos(36137) * 52;
+acc += Math.sin(36137) + Math.cos(36138) * 53;
+acc += Math.sin(36138) + Math.cos(36139) * 54;
+acc += Math.sin(36139) + Math.cos(36140) * 55;
+acc += Math.sin(36140) + Math.cos(36141) * 56;
+acc += Math.sin(36141) + Math.cos(36142) * 57;
+acc += Math.sin(36142) + Math.cos(36143) * 58;
+acc += Math.sin(36143) + Math.cos(36144) * 59;
+acc += Math.sin(36144) + Math.cos(36145) * 60;
+acc += Math.sin(36145) + Math.cos(36146) * 61;
+acc += Math.sin(36146) + Math.cos(36147) * 62;
+acc += Math.sin(36147) + Math.cos(36148) * 63;
+acc += Math.sin(36148) + Math.cos(36149) * 64;
+acc += Math.sin(36149) + Math.cos(36150) * 65;
+acc += Math.sin(36150) + Math.cos(36151) * 66;
+acc += Math.sin(36151) + Math.cos(36152) * 67;
+acc += Math.sin(36152) + Math.cos(36153) * 68;
+acc += Math.sin(36153) + Math.cos(36154) * 69;
+acc += Math.sin(36154) + Math.cos(36155) * 70;
+acc += Math.sin(36155) + Math.cos(36156) * 71;
+acc += Math.sin(36156) + Math.cos(36157) * 72;
+acc += Math.sin(36157) + Math.cos(36158) * 73;
+acc += Math.sin(36158) + Math.cos(36159) * 74;
+acc += Math.sin(36159) + Math.cos(36160) * 75;
+acc += Math.sin(36160) + Math.cos(36161) * 76;
+acc += Math.sin(36161) + Math.cos(36162) * 77;
+acc += Math.sin(36162) + Math.cos(36163) * 78;
+acc += Math.sin(36163) + Math.cos(36164) * 79;
+acc += Math.sin(36164) + Math.cos(36165) * 80;
+acc += Math.sin(36165) + Math.cos(36166) * 81;
+acc += Math.sin(36166) + Math.cos(36167) * 82;
+acc += Math.sin(36167) + Math.cos(36168) * 83;
+acc += Math.sin(36168) + Math.cos(36169) * 84;
+acc += Math.sin(36169) + Math.cos(36170) * 85;
+acc += Math.sin(36170) + Math.cos(36171) * 86;
+acc += Math.sin(36171) + Math.cos(36172) * 87;
+acc += Math.sin(36172) + Math.cos(36173) * 88;
+acc += Math.sin(36173) + Math.cos(36174) * 89;
+acc += Math.sin(36174) + Math.cos(36175) * 90;
+acc += Math.sin(36175) + Math.cos(36176) * 91;
+acc += Math.sin(36176) + Math.cos(36177) * 92;
+acc += Math.sin(36177) + Math.cos(36178) * 93;
+acc += Math.sin(36178) + Math.cos(36179) * 94;
+acc += Math.sin(36179) + Math.cos(36180) * 95;
+acc += Math.sin(36180) + Math.cos(36181) * 96;
+acc += Math.sin(36181) + Math.cos(36182) * 0;
+acc += Math.sin(36182) + Math.cos(36183) * 1;
+acc += Math.sin(36183) + Math.cos(36184) * 2;
+acc += Math.sin(36184) + Math.cos(36185) * 3;
+acc += Math.sin(36185) + Math.cos(36186) * 4;
+acc += Math.sin(36186) + Math.cos(36187) * 5;
+acc += Math.sin(36187) + Math.cos(36188) * 6;
+acc += Math.sin(36188) + Math.cos(36189) * 7;
+acc += Math.sin(36189) + Math.cos(36190) * 8;
+acc += Math.sin(36190) + Math.cos(36191) * 9;
+acc += Math.sin(36191) + Math.cos(36192) * 10;
+acc += Math.sin(36192) + Math.cos(36193) * 11;
+acc += Math.sin(36193) + Math.cos(36194) * 12;
+acc += Math.sin(36194) + Math.cos(36195) * 13;
+acc += Math.sin(36195) + Math.cos(36196) * 14;
+acc += Math.sin(36196) + Math.cos(36197) * 15;
+acc += Math.sin(36197) + Math.cos(36198) * 16;
+acc += Math.sin(36198) + Math.cos(36199) * 17;
+acc += Math.sin(36199) + Math.cos(36200) * 18;
+acc += Math.sin(36200) + Math.cos(36201) * 19;
+acc += Math.sin(36201) + Math.cos(36202) * 20;
+acc += Math.sin(36202) + Math.cos(36203) * 21;
+acc += Math.sin(36203) + Math.cos(36204) * 22;
+acc += Math.sin(36204) + Math.cos(36205) * 23;
+acc += Math.sin(36205) + Math.cos(36206) * 24;
+acc += Math.sin(36206) + Math.cos(36207) * 25;
+acc += Math.sin(36207) + Math.cos(36208) * 26;
+acc += Math.sin(36208) + Math.cos(36209) * 27;
+acc += Math.sin(36209) + Math.cos(36210) * 28;
+acc += Math.sin(36210) + Math.cos(36211) * 29;
+acc += Math.sin(36211) + Math.cos(36212) * 30;
+acc += Math.sin(36212) + Math.cos(36213) * 31;
+acc += Math.sin(36213) + Math.cos(36214) * 32;
+acc += Math.sin(36214) + Math.cos(36215) * 33;
+acc += Math.sin(36215) + Math.cos(36216) * 34;
+acc += Math.sin(36216) + Math.cos(36217) * 35;
+acc += Math.sin(36217) + Math.cos(36218) * 36;
+acc += Math.sin(36218) + Math.cos(36219) * 37;
+acc += Math.sin(36219) + Math.cos(36220) * 38;
+acc += Math.sin(36220) + Math.cos(36221) * 39;
+acc += Math.sin(36221) + Math.cos(36222) * 40;
+acc += Math.sin(36222) + Math.cos(36223) * 41;
+acc += Math.sin(36223) + Math.cos(36224) * 42;
+acc += Math.sin(36224) + Math.cos(36225) * 43;
+acc += Math.sin(36225) + Math.cos(36226) * 44;
+acc += Math.sin(36226) + Math.cos(36227) * 45;
+acc += Math.sin(36227) + Math.cos(36228) * 46;
+acc += Math.sin(36228) + Math.cos(36229) * 47;
+acc += Math.sin(36229) + Math.cos(36230) * 48;
+acc += Math.sin(36230) + Math.cos(36231) * 49;
+acc += Math.sin(36231) + Math.cos(36232) * 50;
+acc += Math.sin(36232) + Math.cos(36233) * 51;
+acc += Math.sin(36233) + Math.cos(36234) * 52;
+acc += Math.sin(36234) + Math.cos(36235) * 53;
+acc += Math.sin(36235) + Math.cos(36236) * 54;
+acc += Math.sin(36236) + Math.cos(36237) * 55;
+acc += Math.sin(36237) + Math.cos(36238) * 56;
+acc += Math.sin(36238) + Math.cos(36239) * 57;
+acc += Math.sin(36239) + Math.cos(36240) * 58;
+acc += Math.sin(36240) + Math.cos(36241) * 59;
+acc += Math.sin(36241) + Math.cos(36242) * 60;
+acc += Math.sin(36242) + Math.cos(36243) * 61;
+acc += Math.sin(36243) + Math.cos(36244) * 62;
+acc += Math.sin(36244) + Math.cos(36245) * 63;
+acc += Math.sin(36245) + Math.cos(36246) * 64;
+acc += Math.sin(36246) + Math.cos(36247) * 65;
+acc += Math.sin(36247) + Math.cos(36248) * 66;
+acc += Math.sin(36248) + Math.cos(36249) * 67;
+acc += Math.sin(36249) + Math.cos(36250) * 68;
+acc += Math.sin(36250) + Math.cos(36251) * 69;
+acc += Math.sin(36251) + Math.cos(36252) * 70;
+acc += Math.sin(36252) + Math.cos(36253) * 71;
+acc += Math.sin(36253) + Math.cos(36254) * 72;
+acc += Math.sin(36254) + Math.cos(36255) * 73;
+acc += Math.sin(36255) + Math.cos(36256) * 74;
+acc += Math.sin(36256) + Math.cos(36257) * 75;
+acc += Math.sin(36257) + Math.cos(36258) * 76;
+acc += Math.sin(36258) + Math.cos(36259) * 77;
+acc += Math.sin(36259) + Math.cos(36260) * 78;
+acc += Math.sin(36260) + Math.cos(36261) * 79;
+acc += Math.sin(36261) + Math.cos(36262) * 80;
+acc += Math.sin(36262) + Math.cos(36263) * 81;
+acc += Math.sin(36263) + Math.cos(36264) * 82;
+acc += Math.sin(36264) + Math.cos(36265) * 83;
+acc += Math.sin(36265) + Math.cos(36266) * 84;
+acc += Math.sin(36266) + Math.cos(36267) * 85;
+acc += Math.sin(36267) + Math.cos(36268) * 86;
+acc += Math.sin(36268) + Math.cos(36269) * 87;
+acc += Math.sin(36269) + Math.cos(36270) * 88;
+acc += Math.sin(36270) + Math.cos(36271) * 89;
+acc += Math.sin(36271) + Math.cos(36272) * 90;
+acc += Math.sin(36272) + Math.cos(36273) * 91;
+acc += Math.sin(36273) + Math.cos(36274) * 92;
+acc += Math.sin(36274) + Math.cos(36275) * 93;
+acc += Math.sin(36275) + Math.cos(36276) * 94;
+acc += Math.sin(36276) + Math.cos(36277) * 95;
+acc += Math.sin(36277) + Math.cos(36278) * 96;
+acc += Math.sin(36278) + Math.cos(36279) * 0;
+acc += Math.sin(36279) + Math.cos(36280) * 1;
+acc += Math.sin(36280) + Math.cos(36281) * 2;
+acc += Math.sin(36281) + Math.cos(36282) * 3;
+acc += Math.sin(36282) + Math.cos(36283) * 4;
+acc += Math.sin(36283) + Math.cos(36284) * 5;
+acc += Math.sin(36284) + Math.cos(36285) * 6;
+acc += Math.sin(36285) + Math.cos(36286) * 7;
+acc += Math.sin(36286) + Math.cos(36287) * 8;
+acc += Math.sin(36287) + Math.cos(36288) * 9;
+acc += Math.sin(36288) + Math.cos(36289) * 10;
+acc += Math.sin(36289) + Math.cos(36290) * 11;
+acc += Math.sin(36290) + Math.cos(36291) * 12;
+acc += Math.sin(36291) + Math.cos(36292) * 13;
+acc += Math.sin(36292) + Math.cos(36293) * 14;
+acc += Math.sin(36293) + Math.cos(36294) * 15;
+acc += Math.sin(36294) + Math.cos(36295) * 16;
+acc += Math.sin(36295) + Math.cos(36296) * 17;
+acc += Math.sin(36296) + Math.cos(36297) * 18;
+acc += Math.sin(36297) + Math.cos(36298) * 19;
+acc += Math.sin(36298) + Math.cos(36299) * 20;
+acc += Math.sin(36299) + Math.cos(36300) * 21;
+acc += Math.sin(36300) + Math.cos(36301) * 22;
+acc += Math.sin(36301) + Math.cos(36302) * 23;
+acc += Math.sin(36302) + Math.cos(36303) * 24;
+acc += Math.sin(36303) + Math.cos(36304) * 25;
+acc += Math.sin(36304) + Math.cos(36305) * 26;
+acc += Math.sin(36305) + Math.cos(36306) * 27;
+acc += Math.sin(36306) + Math.cos(36307) * 28;
+acc += Math.sin(36307) + Math.cos(36308) * 29;
+acc += Math.sin(36308) + Math.cos(36309) * 30;
+acc += Math.sin(36309) + Math.cos(36310) * 31;
+acc += Math.sin(36310) + Math.cos(36311) * 32;
+acc += Math.sin(36311) + Math.cos(36312) * 33;
+acc += Math.sin(36312) + Math.cos(36313) * 34;
+acc += Math.sin(36313) + Math.cos(36314) * 35;
+acc += Math.sin(36314) + Math.cos(36315) * 36;
+acc += Math.sin(36315) + Math.cos(36316) * 37;
+acc += Math.sin(36316) + Math.cos(36317) * 38;
+acc += Math.sin(36317) + Math.cos(36318) * 39;
+acc += Math.sin(36318) + Math.cos(36319) * 40;
+acc += Math.sin(36319) + Math.cos(36320) * 41;
+acc += Math.sin(36320) + Math.cos(36321) * 42;
+acc += Math.sin(36321) + Math.cos(36322) * 43;
+acc += Math.sin(36322) + Math.cos(36323) * 44;
+acc += Math.sin(36323) + Math.cos(36324) * 45;
+acc += Math.sin(36324) + Math.cos(36325) * 46;
+acc += Math.sin(36325) + Math.cos(36326) * 47;
+acc += Math.sin(36326) + Math.cos(36327) * 48;
+acc += Math.sin(36327) + Math.cos(36328) * 49;
+acc += Math.sin(36328) + Math.cos(36329) * 50;
+acc += Math.sin(36329) + Math.cos(36330) * 51;
+acc += Math.sin(36330) + Math.cos(36331) * 52;
+acc += Math.sin(36331) + Math.cos(36332) * 53;
+acc += Math.sin(36332) + Math.cos(36333) * 54;
+acc += Math.sin(36333) + Math.cos(36334) * 55;
+acc += Math.sin(36334) + Math.cos(36335) * 56;
+acc += Math.sin(36335) + Math.cos(36336) * 57;
+acc += Math.sin(36336) + Math.cos(36337) * 58;
+acc += Math.sin(36337) + Math.cos(36338) * 59;
+acc += Math.sin(36338) + Math.cos(36339) * 60;
+acc += Math.sin(36339) + Math.cos(36340) * 61;
+acc += Math.sin(36340) + Math.cos(36341) * 62;
+acc += Math.sin(36341) + Math.cos(36342) * 63;
+acc += Math.sin(36342) + Math.cos(36343) * 64;
+acc += Math.sin(36343) + Math.cos(36344) * 65;
+acc += Math.sin(36344) + Math.cos(36345) * 66;
+acc += Math.sin(36345) + Math.cos(36346) * 67;
+acc += Math.sin(36346) + Math.cos(36347) * 68;
+acc += Math.sin(36347) + Math.cos(36348) * 69;
+acc += Math.sin(36348) + Math.cos(36349) * 70;
+acc += Math.sin(36349) + Math.cos(36350) * 71;
+acc += Math.sin(36350) + Math.cos(36351) * 72;
+acc += Math.sin(36351) + Math.cos(36352) * 73;
+acc += Math.sin(36352) + Math.cos(36353) * 74;
+acc += Math.sin(36353) + Math.cos(36354) * 75;
+acc += Math.sin(36354) + Math.cos(36355) * 76;
+acc += Math.sin(36355) + Math.cos(36356) * 77;
+acc += Math.sin(36356) + Math.cos(36357) * 78;
+acc += Math.sin(36357) + Math.cos(36358) * 79;
+acc += Math.sin(36358) + Math.cos(36359) * 80;
+acc += Math.sin(36359) + Math.cos(36360) * 81;
+acc += Math.sin(36360) + Math.cos(36361) * 82;
+acc += Math.sin(36361) + Math.cos(36362) * 83;
+acc += Math.sin(36362) + Math.cos(36363) * 84;
+acc += Math.sin(36363) + Math.cos(36364) * 85;
+acc += Math.sin(36364) + Math.cos(36365) * 86;
+acc += Math.sin(36365) + Math.cos(36366) * 87;
+acc += Math.sin(36366) + Math.cos(36367) * 88;
+acc += Math.sin(36367) + Math.cos(36368) * 89;
+acc += Math.sin(36368) + Math.cos(36369) * 90;
+acc += Math.sin(36369) + Math.cos(36370) * 91;
+acc += Math.sin(36370) + Math.cos(36371) * 92;
+acc += Math.sin(36371) + Math.cos(36372) * 93;
+acc += Math.sin(36372) + Math.cos(36373) * 94;
+acc += Math.sin(36373) + Math.cos(36374) * 95;
+acc += Math.sin(36374) + Math.cos(36375) * 96;
+acc += Math.sin(36375) + Math.cos(36376) * 0;
+acc += Math.sin(36376) + Math.cos(36377) * 1;
+acc += Math.sin(36377) + Math.cos(36378) * 2;
+acc += Math.sin(36378) + Math.cos(36379) * 3;
+acc += Math.sin(36379) + Math.cos(36380) * 4;
+acc += Math.sin(36380) + Math.cos(36381) * 5;
+acc += Math.sin(36381) + Math.cos(36382) * 6;
+acc += Math.sin(36382) + Math.cos(36383) * 7;
+acc += Math.sin(36383) + Math.cos(36384) * 8;
+acc += Math.sin(36384) + Math.cos(36385) * 9;
+acc += Math.sin(36385) + Math.cos(36386) * 10;
+acc += Math.sin(36386) + Math.cos(36387) * 11;
+acc += Math.sin(36387) + Math.cos(36388) * 12;
+acc += Math.sin(36388) + Math.cos(36389) * 13;
+acc += Math.sin(36389) + Math.cos(36390) * 14;
+acc += Math.sin(36390) + Math.cos(36391) * 15;
+acc += Math.sin(36391) + Math.cos(36392) * 16;
+acc += Math.sin(36392) + Math.cos(36393) * 17;
+acc += Math.sin(36393) + Math.cos(36394) * 18;
+acc += Math.sin(36394) + Math.cos(36395) * 19;
+acc += Math.sin(36395) + Math.cos(36396) * 20;
+acc += Math.sin(36396) + Math.cos(36397) * 21;
+acc += Math.sin(36397) + Math.cos(36398) * 22;
+acc += Math.sin(36398) + Math.cos(36399) * 23;
+acc += Math.sin(36399) + Math.cos(36400) * 24;
+acc += Math.sin(36400) + Math.cos(36401) * 25;
+acc += Math.sin(36401) + Math.cos(36402) * 26;
+acc += Math.sin(36402) + Math.cos(36403) * 27;
+acc += Math.sin(36403) + Math.cos(36404) * 28;
+acc += Math.sin(36404) + Math.cos(36405) * 29;
+acc += Math.sin(36405) + Math.cos(36406) * 30;
+acc += Math.sin(36406) + Math.cos(36407) * 31;
+acc += Math.sin(36407) + Math.cos(36408) * 32;
+acc += Math.sin(36408) + Math.cos(36409) * 33;
+acc += Math.sin(36409) + Math.cos(36410) * 34;
+acc += Math.sin(36410) + Math.cos(36411) * 35;
+acc += Math.sin(36411) + Math.cos(36412) * 36;
+acc += Math.sin(36412) + Math.cos(36413) * 37;
+acc += Math.sin(36413) + Math.cos(36414) * 38;
+acc += Math.sin(36414) + Math.cos(36415) * 39;
+acc += Math.sin(36415) + Math.cos(36416) * 40;
+acc += Math.sin(36416) + Math.cos(36417) * 41;
+acc += Math.sin(36417) + Math.cos(36418) * 42;
+acc += Math.sin(36418) + Math.cos(36419) * 43;
+acc += Math.sin(36419) + Math.cos(36420) * 44;
+acc += Math.sin(36420) + Math.cos(36421) * 45;
+acc += Math.sin(36421) + Math.cos(36422) * 46;
+acc += Math.sin(36422) + Math.cos(36423) * 47;
+acc += Math.sin(36423) + Math.cos(36424) * 48;
+acc += Math.sin(36424) + Math.cos(36425) * 49;
+acc += Math.sin(36425) + Math.cos(36426) * 50;
+acc += Math.sin(36426) + Math.cos(36427) * 51;
+acc += Math.sin(36427) + Math.cos(36428) * 52;
+acc += Math.sin(36428) + Math.cos(36429) * 53;
+acc += Math.sin(36429) + Math.cos(36430) * 54;
+acc += Math.sin(36430) + Math.cos(36431) * 55;
+acc += Math.sin(36431) + Math.cos(36432) * 56;
+acc += Math.sin(36432) + Math.cos(36433) * 57;
+acc += Math.sin(36433) + Math.cos(36434) * 58;
+acc += Math.sin(36434) + Math.cos(36435) * 59;
+acc += Math.sin(36435) + Math.cos(36436) * 60;
+acc += Math.sin(36436) + Math.cos(36437) * 61;
+acc += Math.sin(36437) + Math.cos(36438) * 62;
+acc += Math.sin(36438) + Math.cos(36439) * 63;
+acc += Math.sin(36439) + Math.cos(36440) * 64;
+acc += Math.sin(36440) + Math.cos(36441) * 65;
+acc += Math.sin(36441) + Math.cos(36442) * 66;
+acc += Math.sin(36442) + Math.cos(36443) * 67;
+acc += Math.sin(36443) + Math.cos(36444) * 68;
+acc += Math.sin(36444) + Math.cos(36445) * 69;
+acc += Math.sin(36445) + Math.cos(36446) * 70;
+acc += Math.sin(36446) + Math.cos(36447) * 71;
+acc += Math.sin(36447) + Math.cos(36448) * 72;
+acc += Math.sin(36448) + Math.cos(36449) * 73;
+acc += Math.sin(36449) + Math.cos(36450) * 74;
+acc += Math.sin(36450) + Math.cos(36451) * 75;
+acc += Math.sin(36451) + Math.cos(36452) * 76;
+acc += Math.sin(36452) + Math.cos(36453) * 77;
+acc += Math.sin(36453) + Math.cos(36454) * 78;
+acc += Math.sin(36454) + Math.cos(36455) * 79;
+acc += Math.sin(36455) + Math.cos(36456) * 80;
+acc += Math.sin(36456) + Math.cos(36457) * 81;
+acc += Math.sin(36457) + Math.cos(36458) * 82;
+acc += Math.sin(36458) + Math.cos(36459) * 83;
+acc += Math.sin(36459) + Math.cos(36460) * 84;
+acc += Math.sin(36460) + Math.cos(36461) * 85;
+acc += Math.sin(36461) + Math.cos(36462) * 86;
+acc += Math.sin(36462) + Math.cos(36463) * 87;
+acc += Math.sin(36463) + Math.cos(36464) * 88;
+acc += Math.sin(36464) + Math.cos(36465) * 89;
+acc += Math.sin(36465) + Math.cos(36466) * 90;
+acc += Math.sin(36466) + Math.cos(36467) * 91;
+acc += Math.sin(36467) + Math.cos(36468) * 92;
+acc += Math.sin(36468) + Math.cos(36469) * 93;
+acc += Math.sin(36469) + Math.cos(36470) * 94;
+acc += Math.sin(36470) + Math.cos(36471) * 95;
+acc += Math.sin(36471) + Math.cos(36472) * 96;
+acc += Math.sin(36472) + Math.cos(36473) * 0;
+acc += Math.sin(36473) + Math.cos(36474) * 1;
+acc += Math.sin(36474) + Math.cos(36475) * 2;
+acc += Math.sin(36475) + Math.cos(36476) * 3;
+acc += Math.sin(36476) + Math.cos(36477) * 4;
+acc += Math.sin(36477) + Math.cos(36478) * 5;
+acc += Math.sin(36478) + Math.cos(36479) * 6;
+acc += Math.sin(36479) + Math.cos(36480) * 7;
+acc += Math.sin(36480) + Math.cos(36481) * 8;
+acc += Math.sin(36481) + Math.cos(36482) * 9;
+acc += Math.sin(36482) + Math.cos(36483) * 10;
+acc += Math.sin(36483) + Math.cos(36484) * 11;
+acc += Math.sin(36484) + Math.cos(36485) * 12;
+acc += Math.sin(36485) + Math.cos(36486) * 13;
+acc += Math.sin(36486) + Math.cos(36487) * 14;
+acc += Math.sin(36487) + Math.cos(36488) * 15;
+acc += Math.sin(36488) + Math.cos(36489) * 16;
+acc += Math.sin(36489) + Math.cos(36490) * 17;
+acc += Math.sin(36490) + Math.cos(36491) * 18;
+acc += Math.sin(36491) + Math.cos(36492) * 19;
+acc += Math.sin(36492) + Math.cos(36493) * 20;
+acc += Math.sin(36493) + Math.cos(36494) * 21;
+acc += Math.sin(36494) + Math.cos(36495) * 22;
+acc += Math.sin(36495) + Math.cos(36496) * 23;
+acc += Math.sin(36496) + Math.cos(36497) * 24;
+acc += Math.sin(36497) + Math.cos(36498) * 25;
+acc += Math.sin(36498) + Math.cos(36499) * 26;
+acc += Math.sin(36499) + Math.cos(36500) * 27;
+acc += Math.sin(36500) + Math.cos(36501) * 28;
+acc += Math.sin(36501) + Math.cos(36502) * 29;
+acc += Math.sin(36502) + Math.cos(36503) * 30;
+acc += Math.sin(36503) + Math.cos(36504) * 31;
+acc += Math.sin(36504) + Math.cos(36505) * 32;
+acc += Math.sin(36505) + Math.cos(36506) * 33;
+acc += Math.sin(36506) + Math.cos(36507) * 34;
+acc += Math.sin(36507) + Math.cos(36508) * 35;
+acc += Math.sin(36508) + Math.cos(36509) * 36;
+acc += Math.sin(36509) + Math.cos(36510) * 37;
+acc += Math.sin(36510) + Math.cos(36511) * 38;
+acc += Math.sin(36511) + Math.cos(36512) * 39;
+acc += Math.sin(36512) + Math.cos(36513) * 40;
+acc += Math.sin(36513) + Math.cos(36514) * 41;
+acc += Math.sin(36514) + Math.cos(36515) * 42;
+acc += Math.sin(36515) + Math.cos(36516) * 43;
+acc += Math.sin(36516) + Math.cos(36517) * 44;
+acc += Math.sin(36517) + Math.cos(36518) * 45;
+acc += Math.sin(36518) + Math.cos(36519) * 46;
+acc += Math.sin(36519) + Math.cos(36520) * 47;
+acc += Math.sin(36520) + Math.cos(36521) * 48;
+acc += Math.sin(36521) + Math.cos(36522) * 49;
+acc += Math.sin(36522) + Math.cos(36523) * 50;
+acc += Math.sin(36523) + Math.cos(36524) * 51;
+acc += Math.sin(36524) + Math.cos(36525) * 52;
+acc += Math.sin(36525) + Math.cos(36526) * 53;
+acc += Math.sin(36526) + Math.cos(36527) * 54;
+acc += Math.sin(36527) + Math.cos(36528) * 55;
+acc += Math.sin(36528) + Math.cos(36529) * 56;
+acc += Math.sin(36529) + Math.cos(36530) * 57;
+acc += Math.sin(36530) + Math.cos(36531) * 58;
+acc += Math.sin(36531) + Math.cos(36532) * 59;
+acc += Math.sin(36532) + Math.cos(36533) * 60;
+acc += Math.sin(36533) + Math.cos(36534) * 61;
+acc += Math.sin(36534) + Math.cos(36535) * 62;
+acc += Math.sin(36535) + Math.cos(36536) * 63;
+acc += Math.sin(36536) + Math.cos(36537) * 64;
+acc += Math.sin(36537) + Math.cos(36538) * 65;
+acc += Math.sin(36538) + Math.cos(36539) * 66;
+acc += Math.sin(36539) + Math.cos(36540) * 67;
+acc += Math.sin(36540) + Math.cos(36541) * 68;
+acc += Math.sin(36541) + Math.cos(36542) * 69;
+acc += Math.sin(36542) + Math.cos(36543) * 70;
+acc += Math.sin(36543) + Math.cos(36544) * 71;
+acc += Math.sin(36544) + Math.cos(36545) * 72;
+acc += Math.sin(36545) + Math.cos(36546) * 73;
+acc += Math.sin(36546) + Math.cos(36547) * 74;
+acc += Math.sin(36547) + Math.cos(36548) * 75;
+acc += Math.sin(36548) + Math.cos(36549) * 76;
+acc += Math.sin(36549) + Math.cos(36550) * 77;
+acc += Math.sin(36550) + Math.cos(36551) * 78;
+acc += Math.sin(36551) + Math.cos(36552) * 79;
+acc += Math.sin(36552) + Math.cos(36553) * 80;
+acc += Math.sin(36553) + Math.cos(36554) * 81;
+acc += Math.sin(36554) + Math.cos(36555) * 82;
+acc += Math.sin(36555) + Math.cos(36556) * 83;
+acc += Math.sin(36556) + Math.cos(36557) * 84;
+acc += Math.sin(36557) + Math.cos(36558) * 85;
+acc += Math.sin(36558) + Math.cos(36559) * 86;
+acc += Math.sin(36559) + Math.cos(36560) * 87;
+acc += Math.sin(36560) + Math.cos(36561) * 88;
+acc += Math.sin(36561) + Math.cos(36562) * 89;
+acc += Math.sin(36562) + Math.cos(36563) * 90;
+acc += Math.sin(36563) + Math.cos(36564) * 91;
+acc += Math.sin(36564) + Math.cos(36565) * 92;
+acc += Math.sin(36565) + Math.cos(36566) * 93;
+acc += Math.sin(36566) + Math.cos(36567) * 94;
+acc += Math.sin(36567) + Math.cos(36568) * 95;
+acc += Math.sin(36568) + Math.cos(36569) * 96;
+acc += Math.sin(36569) + Math.cos(36570) * 0;
+acc += Math.sin(36570) + Math.cos(36571) * 1;
+acc += Math.sin(36571) + Math.cos(36572) * 2;
+acc += Math.sin(36572) + Math.cos(36573) * 3;
+acc += Math.sin(36573) + Math.cos(36574) * 4;
+acc += Math.sin(36574) + Math.cos(36575) * 5;
+acc += Math.sin(36575) + Math.cos(36576) * 6;
+acc += Math.sin(36576) + Math.cos(36577) * 7;
+acc += Math.sin(36577) + Math.cos(36578) * 8;
+acc += Math.sin(36578) + Math.cos(36579) * 9;
+acc += Math.sin(36579) + Math.cos(36580) * 10;
+acc += Math.sin(36580) + Math.cos(36581) * 11;
+acc += Math.sin(36581) + Math.cos(36582) * 12;
+acc += Math.sin(36582) + Math.cos(36583) * 13;
+acc += Math.sin(36583) + Math.cos(36584) * 14;
+acc += Math.sin(36584) + Math.cos(36585) * 15;
+acc += Math.sin(36585) + Math.cos(36586) * 16;
+acc += Math.sin(36586) + Math.cos(36587) * 17;
+acc += Math.sin(36587) + Math.cos(36588) * 18;
+acc += Math.sin(36588) + Math.cos(36589) * 19;
+acc += Math.sin(36589) + Math.cos(36590) * 20;
+acc += Math.sin(36590) + Math.cos(36591) * 21;
+acc += Math.sin(36591) + Math.cos(36592) * 22;
+acc += Math.sin(36592) + Math.cos(36593) * 23;
+acc += Math.sin(36593) + Math.cos(36594) * 24;
+acc += Math.sin(36594) + Math.cos(36595) * 25;
+acc += Math.sin(36595) + Math.cos(36596) * 26;
+acc += Math.sin(36596) + Math.cos(36597) * 27;
+acc += Math.sin(36597) + Math.cos(36598) * 28;
+acc += Math.sin(36598) + Math.cos(36599) * 29;
+acc += Math.sin(36599) + Math.cos(36600) * 30;
+acc += Math.sin(36600) + Math.cos(36601) * 31;
+acc += Math.sin(36601) + Math.cos(36602) * 32;
+acc += Math.sin(36602) + Math.cos(36603) * 33;
+acc += Math.sin(36603) + Math.cos(36604) * 34;
+acc += Math.sin(36604) + Math.cos(36605) * 35;
+acc += Math.sin(36605) + Math.cos(36606) * 36;
+acc += Math.sin(36606) + Math.cos(36607) * 37;
+acc += Math.sin(36607) + Math.cos(36608) * 38;
+acc += Math.sin(36608) + Math.cos(36609) * 39;
+acc += Math.sin(36609) + Math.cos(36610) * 40;
+acc += Math.sin(36610) + Math.cos(36611) * 41;
+acc += Math.sin(36611) + Math.cos(36612) * 42;
+acc += Math.sin(36612) + Math.cos(36613) * 43;
+acc += Math.sin(36613) + Math.cos(36614) * 44;
+acc += Math.sin(36614) + Math.cos(36615) * 45;
+acc += Math.sin(36615) + Math.cos(36616) * 46;
+acc += Math.sin(36616) + Math.cos(36617) * 47;
+acc += Math.sin(36617) + Math.cos(36618) * 48;
+acc += Math.sin(36618) + Math.cos(36619) * 49;
+acc += Math.sin(36619) + Math.cos(36620) * 50;
+acc += Math.sin(36620) + Math.cos(36621) * 51;
+acc += Math.sin(36621) + Math.cos(36622) * 52;
+acc += Math.sin(36622) + Math.cos(36623) * 53;
+acc += Math.sin(36623) + Math.cos(36624) * 54;
+acc += Math.sin(36624) + Math.cos(36625) * 55;
+acc += Math.sin(36625) + Math.cos(36626) * 56;
+acc += Math.sin(36626) + Math.cos(36627) * 57;
+acc += Math.sin(36627) + Math.cos(36628) * 58;
+acc += Math.sin(36628) + Math.cos(36629) * 59;
+acc += Math.sin(36629) + Math.cos(36630) * 60;
+acc += Math.sin(36630) + Math.cos(36631) * 61;
+acc += Math.sin(36631) + Math.cos(36632) * 62;
+acc += Math.sin(36632) + Math.cos(36633) * 63;
+acc += Math.sin(36633) + Math.cos(36634) * 64;
+acc += Math.sin(36634) + Math.cos(36635) * 65;
+acc += Math.sin(36635) + Math.cos(36636) * 66;
+acc += Math.sin(36636) + Math.cos(36637) * 67;
+acc += Math.sin(36637) + Math.cos(36638) * 68;
+acc += Math.sin(36638) + Math.cos(36639) * 69;
+acc += Math.sin(36639) + Math.cos(36640) * 70;
+acc += Math.sin(36640) + Math.cos(36641) * 71;
+acc += Math.sin(36641) + Math.cos(36642) * 72;
+acc += Math.sin(36642) + Math.cos(36643) * 73;
+acc += Math.sin(36643) + Math.cos(36644) * 74;
+acc += Math.sin(36644) + Math.cos(36645) * 75;
+acc += Math.sin(36645) + Math.cos(36646) * 76;
+acc += Math.sin(36646) + Math.cos(36647) * 77;
+acc += Math.sin(36647) + Math.cos(36648) * 78;
+acc += Math.sin(36648) + Math.cos(36649) * 79;
+acc += Math.sin(36649) + Math.cos(36650) * 80;
+acc += Math.sin(36650) + Math.cos(36651) * 81;
+acc += Math.sin(36651) + Math.cos(36652) * 82;
+acc += Math.sin(36652) + Math.cos(36653) * 83;
+acc += Math.sin(36653) + Math.cos(36654) * 84;
+acc += Math.sin(36654) + Math.cos(36655) * 85;
+acc += Math.sin(36655) + Math.cos(36656) * 86;
+acc += Math.sin(36656) + Math.cos(36657) * 87;
+acc += Math.sin(36657) + Math.cos(36658) * 88;
+acc += Math.sin(36658) + Math.cos(36659) * 89;
+acc += Math.sin(36659) + Math.cos(36660) * 90;
+acc += Math.sin(36660) + Math.cos(36661) * 91;
+acc += Math.sin(36661) + Math.cos(36662) * 92;
+acc += Math.sin(36662) + Math.cos(36663) * 93;
+acc += Math.sin(36663) + Math.cos(36664) * 94;
+acc += Math.sin(36664) + Math.cos(36665) * 95;
+acc += Math.sin(36665) + Math.cos(36666) * 96;
+acc += Math.sin(36666) + Math.cos(36667) * 0;
+acc += Math.sin(36667) + Math.cos(36668) * 1;
+acc += Math.sin(36668) + Math.cos(36669) * 2;
+acc += Math.sin(36669) + Math.cos(36670) * 3;
+acc += Math.sin(36670) + Math.cos(36671) * 4;
+acc += Math.sin(36671) + Math.cos(36672) * 5;
+acc += Math.sin(36672) + Math.cos(36673) * 6;
+acc += Math.sin(36673) + Math.cos(36674) * 7;
+acc += Math.sin(36674) + Math.cos(36675) * 8;
+acc += Math.sin(36675) + Math.cos(36676) * 9;
+acc += Math.sin(36676) + Math.cos(36677) * 10;
+acc += Math.sin(36677) + Math.cos(36678) * 11;
+acc += Math.sin(36678) + Math.cos(36679) * 12;
+acc += Math.sin(36679) + Math.cos(36680) * 13;
+acc += Math.sin(36680) + Math.cos(36681) * 14;
+acc += Math.sin(36681) + Math.cos(36682) * 15;
+acc += Math.sin(36682) + Math.cos(36683) * 16;
+acc += Math.sin(36683) + Math.cos(36684) * 17;
+acc += Math.sin(36684) + Math.cos(36685) * 18;
+acc += Math.sin(36685) + Math.cos(36686) * 19;
+acc += Math.sin(36686) + Math.cos(36687) * 20;
+acc += Math.sin(36687) + Math.cos(36688) * 21;
+acc += Math.sin(36688) + Math.cos(36689) * 22;
+acc += Math.sin(36689) + Math.cos(36690) * 23;
+acc += Math.sin(36690) + Math.cos(36691) * 24;
+acc += Math.sin(36691) + Math.cos(36692) * 25;
+acc += Math.sin(36692) + Math.cos(36693) * 26;
+acc += Math.sin(36693) + Math.cos(36694) * 27;
+acc += Math.sin(36694) + Math.cos(36695) * 28;
+acc += Math.sin(36695) + Math.cos(36696) * 29;
+acc += Math.sin(36696) + Math.cos(36697) * 30;
+acc += Math.sin(36697) + Math.cos(36698) * 31;
+acc += Math.sin(36698) + Math.cos(36699) * 32;
+acc += Math.sin(36699) + Math.cos(36700) * 33;
+acc += Math.sin(36700) + Math.cos(36701) * 34;
+acc += Math.sin(36701) + Math.cos(36702) * 35;
+acc += Math.sin(36702) + Math.cos(36703) * 36;
+acc += Math.sin(36703) + Math.cos(36704) * 37;
+acc += Math.sin(36704) + Math.cos(36705) * 38;
+acc += Math.sin(36705) + Math.cos(36706) * 39;
+acc += Math.sin(36706) + Math.cos(36707) * 40;
+acc += Math.sin(36707) + Math.cos(36708) * 41;
+acc += Math.sin(36708) + Math.cos(36709) * 42;
+acc += Math.sin(36709) + Math.cos(36710) * 43;
+acc += Math.sin(36710) + Math.cos(36711) * 44;
+acc += Math.sin(36711) + Math.cos(36712) * 45;
+acc += Math.sin(36712) + Math.cos(36713) * 46;
+acc += Math.sin(36713) + Math.cos(36714) * 47;
+acc += Math.sin(36714) + Math.cos(36715) * 48;
+acc += Math.sin(36715) + Math.cos(36716) * 49;
+acc += Math.sin(36716) + Math.cos(36717) * 50;
+acc += Math.sin(36717) + Math.cos(36718) * 51;
+acc += Math.sin(36718) + Math.cos(36719) * 52;
+acc += Math.sin(36719) + Math.cos(36720) * 53;
+acc += Math.sin(36720) + Math.cos(36721) * 54;
+acc += Math.sin(36721) + Math.cos(36722) * 55;
+acc += Math.sin(36722) + Math.cos(36723) * 56;
+acc += Math.sin(36723) + Math.cos(36724) * 57;
+acc += Math.sin(36724) + Math.cos(36725) * 58;
+acc += Math.sin(36725) + Math.cos(36726) * 59;
+acc += Math.sin(36726) + Math.cos(36727) * 60;
+acc += Math.sin(36727) + Math.cos(36728) * 61;
+acc += Math.sin(36728) + Math.cos(36729) * 62;
+acc += Math.sin(36729) + Math.cos(36730) * 63;
+acc += Math.sin(36730) + Math.cos(36731) * 64;
+acc += Math.sin(36731) + Math.cos(36732) * 65;
+acc += Math.sin(36732) + Math.cos(36733) * 66;
+acc += Math.sin(36733) + Math.cos(36734) * 67;
+acc += Math.sin(36734) + Math.cos(36735) * 68;
+acc += Math.sin(36735) + Math.cos(36736) * 69;
+acc += Math.sin(36736) + Math.cos(36737) * 70;
+acc += Math.sin(36737) + Math.cos(36738) * 71;
+acc += Math.sin(36738) + Math.cos(36739) * 72;
+acc += Math.sin(36739) + Math.cos(36740) * 73;
+acc += Math.sin(36740) + Math.cos(36741) * 74;
+acc += Math.sin(36741) + Math.cos(36742) * 75;
+acc += Math.sin(36742) + Math.cos(36743) * 76;
+acc += Math.sin(36743) + Math.cos(36744) * 77;
+acc += Math.sin(36744) + Math.cos(36745) * 78;
+acc += Math.sin(36745) + Math.cos(36746) * 79;
+acc += Math.sin(36746) + Math.cos(36747) * 80;
+acc += Math.sin(36747) + Math.cos(36748) * 81;
+acc += Math.sin(36748) + Math.cos(36749) * 82;
+acc += Math.sin(36749) + Math.cos(36750) * 83;
+acc += Math.sin(36750) + Math.cos(36751) * 84;
+acc += Math.sin(36751) + Math.cos(36752) * 85;
+acc += Math.sin(36752) + Math.cos(36753) * 86;
+acc += Math.sin(36753) + Math.cos(36754) * 87;
+acc += Math.sin(36754) + Math.cos(36755) * 88;
+acc += Math.sin(36755) + Math.cos(36756) * 89;
+acc += Math.sin(36756) + Math.cos(36757) * 90;
+acc += Math.sin(36757) + Math.cos(36758) * 91;
+acc += Math.sin(36758) + Math.cos(36759) * 92;
+acc += Math.sin(36759) + Math.cos(36760) * 93;
+acc += Math.sin(36760) + Math.cos(36761) * 94;
+acc += Math.sin(36761) + Math.cos(36762) * 95;
+acc += Math.sin(36762) + Math.cos(36763) * 96;
+acc += Math.sin(36763) + Math.cos(36764) * 0;
+acc += Math.sin(36764) + Math.cos(36765) * 1;
+acc += Math.sin(36765) + Math.cos(36766) * 2;
+acc += Math.sin(36766) + Math.cos(36767) * 3;
+acc += Math.sin(36767) + Math.cos(36768) * 4;
+acc += Math.sin(36768) + Math.cos(36769) * 5;
+acc += Math.sin(36769) + Math.cos(36770) * 6;
+acc += Math.sin(36770) + Math.cos(36771) * 7;
+acc += Math.sin(36771) + Math.cos(36772) * 8;
+acc += Math.sin(36772) + Math.cos(36773) * 9;
+acc += Math.sin(36773) + Math.cos(36774) * 10;
+acc += Math.sin(36774) + Math.cos(36775) * 11;
+acc += Math.sin(36775) + Math.cos(36776) * 12;
+acc += Math.sin(36776) + Math.cos(36777) * 13;
+acc += Math.sin(36777) + Math.cos(36778) * 14;
+acc += Math.sin(36778) + Math.cos(36779) * 15;
+acc += Math.sin(36779) + Math.cos(36780) * 16;
+acc += Math.sin(36780) + Math.cos(36781) * 17;
+acc += Math.sin(36781) + Math.cos(36782) * 18;
+acc += Math.sin(36782) + Math.cos(36783) * 19;
+acc += Math.sin(36783) + Math.cos(36784) * 20;
+acc += Math.sin(36784) + Math.cos(36785) * 21;
+acc += Math.sin(36785) + Math.cos(36786) * 22;
+acc += Math.sin(36786) + Math.cos(36787) * 23;
+acc += Math.sin(36787) + Math.cos(36788) * 24;
+acc += Math.sin(36788) + Math.cos(36789) * 25;
+acc += Math.sin(36789) + Math.cos(36790) * 26;
+acc += Math.sin(36790) + Math.cos(36791) * 27;
+acc += Math.sin(36791) + Math.cos(36792) * 28;
+acc += Math.sin(36792) + Math.cos(36793) * 29;
+acc += Math.sin(36793) + Math.cos(36794) * 30;
+acc += Math.sin(36794) + Math.cos(36795) * 31;
+acc += Math.sin(36795) + Math.cos(36796) * 32;
+acc += Math.sin(36796) + Math.cos(36797) * 33;
+acc += Math.sin(36797) + Math.cos(36798) * 34;
+acc += Math.sin(36798) + Math.cos(36799) * 35;
+acc += Math.sin(36799) + Math.cos(36800) * 36;
+acc += Math.sin(36800) + Math.cos(36801) * 37;
+acc += Math.sin(36801) + Math.cos(36802) * 38;
+acc += Math.sin(36802) + Math.cos(36803) * 39;
+acc += Math.sin(36803) + Math.cos(36804) * 40;
+acc += Math.sin(36804) + Math.cos(36805) * 41;
+acc += Math.sin(36805) + Math.cos(36806) * 42;
+acc += Math.sin(36806) + Math.cos(36807) * 43;
+acc += Math.sin(36807) + Math.cos(36808) * 44;
+acc += Math.sin(36808) + Math.cos(36809) * 45;
+acc += Math.sin(36809) + Math.cos(36810) * 46;
+acc += Math.sin(36810) + Math.cos(36811) * 47;
+acc += Math.sin(36811) + Math.cos(36812) * 48;
+acc += Math.sin(36812) + Math.cos(36813) * 49;
+acc += Math.sin(36813) + Math.cos(36814) * 50;
+acc += Math.sin(36814) + Math.cos(36815) * 51;
+acc += Math.sin(36815) + Math.cos(36816) * 52;
+acc += Math.sin(36816) + Math.cos(36817) * 53;
+acc += Math.sin(36817) + Math.cos(36818) * 54;
+acc += Math.sin(36818) + Math.cos(36819) * 55;
+acc += Math.sin(36819) + Math.cos(36820) * 56;
+acc += Math.sin(36820) + Math.cos(36821) * 57;
+acc += Math.sin(36821) + Math.cos(36822) * 58;
+acc += Math.sin(36822) + Math.cos(36823) * 59;
+acc += Math.sin(36823) + Math.cos(36824) * 60;
+acc += Math.sin(36824) + Math.cos(36825) * 61;
+acc += Math.sin(36825) + Math.cos(36826) * 62;
+acc += Math.sin(36826) + Math.cos(36827) * 63;
+acc += Math.sin(36827) + Math.cos(36828) * 64;
+acc += Math.sin(36828) + Math.cos(36829) * 65;
+acc += Math.sin(36829) + Math.cos(36830) * 66;
+acc += Math.sin(36830) + Math.cos(36831) * 67;
+acc += Math.sin(36831) + Math.cos(36832) * 68;
+acc += Math.sin(36832) + Math.cos(36833) * 69;
+acc += Math.sin(36833) + Math.cos(36834) * 70;
+acc += Math.sin(36834) + Math.cos(36835) * 71;
+acc += Math.sin(36835) + Math.cos(36836) * 72;
+acc += Math.sin(36836) + Math.cos(36837) * 73;
+acc += Math.sin(36837) + Math.cos(36838) * 74;
+acc += Math.sin(36838) + Math.cos(36839) * 75;
+acc += Math.sin(36839) + Math.cos(36840) * 76;
+acc += Math.sin(36840) + Math.cos(36841) * 77;
+acc += Math.sin(36841) + Math.cos(36842) * 78;
+acc += Math.sin(36842) + Math.cos(36843) * 79;
+acc += Math.sin(36843) + Math.cos(36844) * 80;
+acc += Math.sin(36844) + Math.cos(36845) * 81;
+acc += Math.sin(36845) + Math.cos(36846) * 82;
+acc += Math.sin(36846) + Math.cos(36847) * 83;
+acc += Math.sin(36847) + Math.cos(36848) * 84;
+acc += Math.sin(36848) + Math.cos(36849) * 85;
+acc += Math.sin(36849) + Math.cos(36850) * 86;
+acc += Math.sin(36850) + Math.cos(36851) * 87;
+acc += Math.sin(36851) + Math.cos(36852) * 88;
+acc += Math.sin(36852) + Math.cos(36853) * 89;
+acc += Math.sin(36853) + Math.cos(36854) * 90;
+acc += Math.sin(36854) + Math.cos(36855) * 91;
+acc += Math.sin(36855) + Math.cos(36856) * 92;
+acc += Math.sin(36856) + Math.cos(36857) * 93;
+acc += Math.sin(36857) + Math.cos(36858) * 94;
+acc += Math.sin(36858) + Math.cos(36859) * 95;
+acc += Math.sin(36859) + Math.cos(36860) * 96;
+acc += Math.sin(36860) + Math.cos(36861) * 0;
+acc += Math.sin(36861) + Math.cos(36862) * 1;
+acc += Math.sin(36862) + Math.cos(36863) * 2;
+acc += Math.sin(36863) + Math.cos(36864) * 3;
+acc += Math.sin(36864) + Math.cos(36865) * 4;
+acc += Math.sin(36865) + Math.cos(36866) * 5;
+acc += Math.sin(36866) + Math.cos(36867) * 6;
+acc += Math.sin(36867) + Math.cos(36868) * 7;
+acc += Math.sin(36868) + Math.cos(36869) * 8;
+acc += Math.sin(36869) + Math.cos(36870) * 9;
+acc += Math.sin(36870) + Math.cos(36871) * 10;
+acc += Math.sin(36871) + Math.cos(36872) * 11;
+acc += Math.sin(36872) + Math.cos(36873) * 12;
+acc += Math.sin(36873) + Math.cos(36874) * 13;
+acc += Math.sin(36874) + Math.cos(36875) * 14;
+acc += Math.sin(36875) + Math.cos(36876) * 15;
+acc += Math.sin(36876) + Math.cos(36877) * 16;
+acc += Math.sin(36877) + Math.cos(36878) * 17;
+acc += Math.sin(36878) + Math.cos(36879) * 18;
+acc += Math.sin(36879) + Math.cos(36880) * 19;
+acc += Math.sin(36880) + Math.cos(36881) * 20;
+acc += Math.sin(36881) + Math.cos(36882) * 21;
+acc += Math.sin(36882) + Math.cos(36883) * 22;
+acc += Math.sin(36883) + Math.cos(36884) * 23;
+acc += Math.sin(36884) + Math.cos(36885) * 24;
+acc += Math.sin(36885) + Math.cos(36886) * 25;
+acc += Math.sin(36886) + Math.cos(36887) * 26;
+acc += Math.sin(36887) + Math.cos(36888) * 27;
+acc += Math.sin(36888) + Math.cos(36889) * 28;
+acc += Math.sin(36889) + Math.cos(36890) * 29;
+acc += Math.sin(36890) + Math.cos(36891) * 30;
+acc += Math.sin(36891) + Math.cos(36892) * 31;
+acc += Math.sin(36892) + Math.cos(36893) * 32;
+acc += Math.sin(36893) + Math.cos(36894) * 33;
+acc += Math.sin(36894) + Math.cos(36895) * 34;
+acc += Math.sin(36895) + Math.cos(36896) * 35;
+acc += Math.sin(36896) + Math.cos(36897) * 36;
+acc += Math.sin(36897) + Math.cos(36898) * 37;
+acc += Math.sin(36898) + Math.cos(36899) * 38;
+acc += Math.sin(36899) + Math.cos(36900) * 39;
+acc += Math.sin(36900) + Math.cos(36901) * 40;
+acc += Math.sin(36901) + Math.cos(36902) * 41;
+acc += Math.sin(36902) + Math.cos(36903) * 42;
+acc += Math.sin(36903) + Math.cos(36904) * 43;
+acc += Math.sin(36904) + Math.cos(36905) * 44;
+acc += Math.sin(36905) + Math.cos(36906) * 45;
+acc += Math.sin(36906) + Math.cos(36907) * 46;
+acc += Math.sin(36907) + Math.cos(36908) * 47;
+acc += Math.sin(36908) + Math.cos(36909) * 48;
+acc += Math.sin(36909) + Math.cos(36910) * 49;
+acc += Math.sin(36910) + Math.cos(36911) * 50;
+acc += Math.sin(36911) + Math.cos(36912) * 51;
+acc += Math.sin(36912) + Math.cos(36913) * 52;
+acc += Math.sin(36913) + Math.cos(36914) * 53;
+acc += Math.sin(36914) + Math.cos(36915) * 54;
+acc += Math.sin(36915) + Math.cos(36916) * 55;
+acc += Math.sin(36916) + Math.cos(36917) * 56;
+acc += Math.sin(36917) + Math.cos(36918) * 57;
+acc += Math.sin(36918) + Math.cos(36919) * 58;
+acc += Math.sin(36919) + Math.cos(36920) * 59;
+acc += Math.sin(36920) + Math.cos(36921) * 60;
+acc += Math.sin(36921) + Math.cos(36922) * 61;
+acc += Math.sin(36922) + Math.cos(36923) * 62;
+acc += Math.sin(36923) + Math.cos(36924) * 63;
+acc += Math.sin(36924) + Math.cos(36925) * 64;
+acc += Math.sin(36925) + Math.cos(36926) * 65;
+acc += Math.sin(36926) + Math.cos(36927) * 66;
+acc += Math.sin(36927) + Math.cos(36928) * 67;
+acc += Math.sin(36928) + Math.cos(36929) * 68;
+acc += Math.sin(36929) + Math.cos(36930) * 69;
+acc += Math.sin(36930) + Math.cos(36931) * 70;
+acc += Math.sin(36931) + Math.cos(36932) * 71;
+acc += Math.sin(36932) + Math.cos(36933) * 72;
+acc += Math.sin(36933) + Math.cos(36934) * 73;
+acc += Math.sin(36934) + Math.cos(36935) * 74;
+acc += Math.sin(36935) + Math.cos(36936) * 75;
+acc += Math.sin(36936) + Math.cos(36937) * 76;
+acc += Math.sin(36937) + Math.cos(36938) * 77;
+acc += Math.sin(36938) + Math.cos(36939) * 78;
+acc += Math.sin(36939) + Math.cos(36940) * 79;
+acc += Math.sin(36940) + Math.cos(36941) * 80;
+acc += Math.sin(36941) + Math.cos(36942) * 81;
+acc += Math.sin(36942) + Math.cos(36943) * 82;
+acc += Math.sin(36943) + Math.cos(36944) * 83;
+acc += Math.sin(36944) + Math.cos(36945) * 84;
+acc += Math.sin(36945) + Math.cos(36946) * 85;
+acc += Math.sin(36946) + Math.cos(36947) * 86;
+acc += Math.sin(36947) + Math.cos(36948) * 87;
+acc += Math.sin(36948) + Math.cos(36949) * 88;
+acc += Math.sin(36949) + Math.cos(36950) * 89;
+acc += Math.sin(36950) + Math.cos(36951) * 90;
+acc += Math.sin(36951) + Math.cos(36952) * 91;
+acc += Math.sin(36952) + Math.cos(36953) * 92;
+acc += Math.sin(36953) + Math.cos(36954) * 93;
+acc += Math.sin(36954) + Math.cos(36955) * 94;
+acc += Math.sin(36955) + Math.cos(36956) * 95;
+acc += Math.sin(36956) + Math.cos(36957) * 96;
+acc += Math.sin(36957) + Math.cos(36958) * 0;
+acc += Math.sin(36958) + Math.cos(36959) * 1;
+acc += Math.sin(36959) + Math.cos(36960) * 2;
+acc += Math.sin(36960) + Math.cos(36961) * 3;
+acc += Math.sin(36961) + Math.cos(36962) * 4;
+acc += Math.sin(36962) + Math.cos(36963) * 5;
+acc += Math.sin(36963) + Math.cos(36964) * 6;
+acc += Math.sin(36964) + Math.cos(36965) * 7;
+acc += Math.sin(36965) + Math.cos(36966) * 8;
+acc += Math.sin(36966) + Math.cos(36967) * 9;
+acc += Math.sin(36967) + Math.cos(36968) * 10;
+acc += Math.sin(36968) + Math.cos(36969) * 11;
+acc += Math.sin(36969) + Math.cos(36970) * 12;
+acc += Math.sin(36970) + Math.cos(36971) * 13;
+acc += Math.sin(36971) + Math.cos(36972) * 14;
+acc += Math.sin(36972) + Math.cos(36973) * 15;
+acc += Math.sin(36973) + Math.cos(36974) * 16;
+acc += Math.sin(36974) + Math.cos(36975) * 17;
+acc += Math.sin(36975) + Math.cos(36976) * 18;
+acc += Math.sin(36976) + Math.cos(36977) * 19;
+acc += Math.sin(36977) + Math.cos(36978) * 20;
+acc += Math.sin(36978) + Math.cos(36979) * 21;
+acc += Math.sin(36979) + Math.cos(36980) * 22;
+acc += Math.sin(36980) + Math.cos(36981) * 23;
+acc += Math.sin(36981) + Math.cos(36982) * 24;
+acc += Math.sin(36982) + Math.cos(36983) * 25;
+acc += Math.sin(36983) + Math.cos(36984) * 26;
+acc += Math.sin(36984) + Math.cos(36985) * 27;
+acc += Math.sin(36985) + Math.cos(36986) * 28;
+acc += Math.sin(36986) + Math.cos(36987) * 29;
+acc += Math.sin(36987) + Math.cos(36988) * 30;
+acc += Math.sin(36988) + Math.cos(36989) * 31;
+acc += Math.sin(36989) + Math.cos(36990) * 32;
+acc += Math.sin(36990) + Math.cos(36991) * 33;
+acc += Math.sin(36991) + Math.cos(36992) * 34;
+acc += Math.sin(36992) + Math.cos(36993) * 35;
+acc += Math.sin(36993) + Math.cos(36994) * 36;
+acc += Math.sin(36994) + Math.cos(36995) * 37;
+acc += Math.sin(36995) + Math.cos(36996) * 38;
+acc += Math.sin(36996) + Math.cos(36997) * 39;
+acc += Math.sin(36997) + Math.cos(36998) * 40;
+acc += Math.sin(36998) + Math.cos(36999) * 41;
+acc += Math.sin(36999) + Math.cos(37000) * 42;
+acc += Math.sin(37000) + Math.cos(37001) * 43;
+acc += Math.sin(37001) + Math.cos(37002) * 44;
+acc += Math.sin(37002) + Math.cos(37003) * 45;
+acc += Math.sin(37003) + Math.cos(37004) * 46;
+acc += Math.sin(37004) + Math.cos(37005) * 47;
+acc += Math.sin(37005) + Math.cos(37006) * 48;
+acc += Math.sin(37006) + Math.cos(37007) * 49;
+acc += Math.sin(37007) + Math.cos(37008) * 50;
+acc += Math.sin(37008) + Math.cos(37009) * 51;
+acc += Math.sin(37009) + Math.cos(37010) * 52;
+acc += Math.sin(37010) + Math.cos(37011) * 53;
+acc += Math.sin(37011) + Math.cos(37012) * 54;
+acc += Math.sin(37012) + Math.cos(37013) * 55;
+acc += Math.sin(37013) + Math.cos(37014) * 56;
+acc += Math.sin(37014) + Math.cos(37015) * 57;
+acc += Math.sin(37015) + Math.cos(37016) * 58;
+acc += Math.sin(37016) + Math.cos(37017) * 59;
+acc += Math.sin(37017) + Math.cos(37018) * 60;
+acc += Math.sin(37018) + Math.cos(37019) * 61;
+acc += Math.sin(37019) + Math.cos(37020) * 62;
+acc += Math.sin(37020) + Math.cos(37021) * 63;
+acc += Math.sin(37021) + Math.cos(37022) * 64;
+acc += Math.sin(37022) + Math.cos(37023) * 65;
+acc += Math.sin(37023) + Math.cos(37024) * 66;
+acc += Math.sin(37024) + Math.cos(37025) * 67;
+acc += Math.sin(37025) + Math.cos(37026) * 68;
+acc += Math.sin(37026) + Math.cos(37027) * 69;
+acc += Math.sin(37027) + Math.cos(37028) * 70;
+acc += Math.sin(37028) + Math.cos(37029) * 71;
+acc += Math.sin(37029) + Math.cos(37030) * 72;
+acc += Math.sin(37030) + Math.cos(37031) * 73;
+acc += Math.sin(37031) + Math.cos(37032) * 74;
+acc += Math.sin(37032) + Math.cos(37033) * 75;
+acc += Math.sin(37033) + Math.cos(37034) * 76;
+acc += Math.sin(37034) + Math.cos(37035) * 77;
+acc += Math.sin(37035) + Math.cos(37036) * 78;
+acc += Math.sin(37036) + Math.cos(37037) * 79;
+acc += Math.sin(37037) + Math.cos(37038) * 80;
+acc += Math.sin(37038) + Math.cos(37039) * 81;
+acc += Math.sin(37039) + Math.cos(37040) * 82;
+acc += Math.sin(37040) + Math.cos(37041) * 83;
+acc += Math.sin(37041) + Math.cos(37042) * 84;
+acc += Math.sin(37042) + Math.cos(37043) * 85;
+acc += Math.sin(37043) + Math.cos(37044) * 86;
+acc += Math.sin(37044) + Math.cos(37045) * 87;
+acc += Math.sin(37045) + Math.cos(37046) * 88;
+acc += Math.sin(37046) + Math.cos(37047) * 89;
+acc += Math.sin(37047) + Math.cos(37048) * 90;
+acc += Math.sin(37048) + Math.cos(37049) * 91;
+acc += Math.sin(37049) + Math.cos(37050) * 92;
+acc += Math.sin(37050) + Math.cos(37051) * 93;
+acc += Math.sin(37051) + Math.cos(37052) * 94;
+acc += Math.sin(37052) + Math.cos(37053) * 95;
+acc += Math.sin(37053) + Math.cos(37054) * 96;
+acc += Math.sin(37054) + Math.cos(37055) * 0;
+acc += Math.sin(37055) + Math.cos(37056) * 1;
+acc += Math.sin(37056) + Math.cos(37057) * 2;
+acc += Math.sin(37057) + Math.cos(37058) * 3;
+acc += Math.sin(37058) + Math.cos(37059) * 4;
+acc += Math.sin(37059) + Math.cos(37060) * 5;
+acc += Math.sin(37060) + Math.cos(37061) * 6;
+acc += Math.sin(37061) + Math.cos(37062) * 7;
+acc += Math.sin(37062) + Math.cos(37063) * 8;
+acc += Math.sin(37063) + Math.cos(37064) * 9;
+acc += Math.sin(37064) + Math.cos(37065) * 10;
+acc += Math.sin(37065) + Math.cos(37066) * 11;
+acc += Math.sin(37066) + Math.cos(37067) * 12;
+acc += Math.sin(37067) + Math.cos(37068) * 13;
+acc += Math.sin(37068) + Math.cos(37069) * 14;
+acc += Math.sin(37069) + Math.cos(37070) * 15;
+acc += Math.sin(37070) + Math.cos(37071) * 16;
+acc += Math.sin(37071) + Math.cos(37072) * 17;
+acc += Math.sin(37072) + Math.cos(37073) * 18;
+acc += Math.sin(37073) + Math.cos(37074) * 19;
+acc += Math.sin(37074) + Math.cos(37075) * 20;
+acc += Math.sin(37075) + Math.cos(37076) * 21;
+acc += Math.sin(37076) + Math.cos(37077) * 22;
+acc += Math.sin(37077) + Math.cos(37078) * 23;
+acc += Math.sin(37078) + Math.cos(37079) * 24;
+acc += Math.sin(37079) + Math.cos(37080) * 25;
+acc += Math.sin(37080) + Math.cos(37081) * 26;
+acc += Math.sin(37081) + Math.cos(37082) * 27;
+acc += Math.sin(37082) + Math.cos(37083) * 28;
+acc += Math.sin(37083) + Math.cos(37084) * 29;
+acc += Math.sin(37084) + Math.cos(37085) * 30;
+acc += Math.sin(37085) + Math.cos(37086) * 31;
+acc += Math.sin(37086) + Math.cos(37087) * 32;
+acc += Math.sin(37087) + Math.cos(37088) * 33;
+acc += Math.sin(37088) + Math.cos(37089) * 34;
+acc += Math.sin(37089) + Math.cos(37090) * 35;
+acc += Math.sin(37090) + Math.cos(37091) * 36;
+acc += Math.sin(37091) + Math.cos(37092) * 37;
+acc += Math.sin(37092) + Math.cos(37093) * 38;
+acc += Math.sin(37093) + Math.cos(37094) * 39;
+acc += Math.sin(37094) + Math.cos(37095) * 40;
+acc += Math.sin(37095) + Math.cos(37096) * 41;
+acc += Math.sin(37096) + Math.cos(37097) * 42;
+acc += Math.sin(37097) + Math.cos(37098) * 43;
+acc += Math.sin(37098) + Math.cos(37099) * 44;
+acc += Math.sin(37099) + Math.cos(37100) * 45;
+acc += Math.sin(37100) + Math.cos(37101) * 46;
+acc += Math.sin(37101) + Math.cos(37102) * 47;
+acc += Math.sin(37102) + Math.cos(37103) * 48;
+acc += Math.sin(37103) + Math.cos(37104) * 49;
+acc += Math.sin(37104) + Math.cos(37105) * 50;
+acc += Math.sin(37105) + Math.cos(37106) * 51;
+acc += Math.sin(37106) + Math.cos(37107) * 52;
+acc += Math.sin(37107) + Math.cos(37108) * 53;
+acc += Math.sin(37108) + Math.cos(37109) * 54;
+acc += Math.sin(37109) + Math.cos(37110) * 55;
+acc += Math.sin(37110) + Math.cos(37111) * 56;
+acc += Math.sin(37111) + Math.cos(37112) * 57;
+acc += Math.sin(37112) + Math.cos(37113) * 58;
+acc += Math.sin(37113) + Math.cos(37114) * 59;
+acc += Math.sin(37114) + Math.cos(37115) * 60;
+acc += Math.sin(37115) + Math.cos(37116) * 61;
+acc += Math.sin(37116) + Math.cos(37117) * 62;
+acc += Math.sin(37117) + Math.cos(37118) * 63;
+acc += Math.sin(37118) + Math.cos(37119) * 64;
+acc += Math.sin(37119) + Math.cos(37120) * 65;
+acc += Math.sin(37120) + Math.cos(37121) * 66;
+acc += Math.sin(37121) + Math.cos(37122) * 67;
+acc += Math.sin(37122) + Math.cos(37123) * 68;
+acc += Math.sin(37123) + Math.cos(37124) * 69;
+acc += Math.sin(37124) + Math.cos(37125) * 70;
+acc += Math.sin(37125) + Math.cos(37126) * 71;
+acc += Math.sin(37126) + Math.cos(37127) * 72;
+acc += Math.sin(37127) + Math.cos(37128) * 73;
+acc += Math.sin(37128) + Math.cos(37129) * 74;
+acc += Math.sin(37129) + Math.cos(37130) * 75;
+acc += Math.sin(37130) + Math.cos(37131) * 76;
+acc += Math.sin(37131) + Math.cos(37132) * 77;
+acc += Math.sin(37132) + Math.cos(37133) * 78;
+acc += Math.sin(37133) + Math.cos(37134) * 79;
+acc += Math.sin(37134) + Math.cos(37135) * 80;
+acc += Math.sin(37135) + Math.cos(37136) * 81;
+acc += Math.sin(37136) + Math.cos(37137) * 82;
+acc += Math.sin(37137) + Math.cos(37138) * 83;
+acc += Math.sin(37138) + Math.cos(37139) * 84;
+acc += Math.sin(37139) + Math.cos(37140) * 85;
+acc += Math.sin(37140) + Math.cos(37141) * 86;
+acc += Math.sin(37141) + Math.cos(37142) * 87;
+acc += Math.sin(37142) + Math.cos(37143) * 88;
+acc += Math.sin(37143) + Math.cos(37144) * 89;
+acc += Math.sin(37144) + Math.cos(37145) * 90;
+acc += Math.sin(37145) + Math.cos(37146) * 91;
+acc += Math.sin(37146) + Math.cos(37147) * 92;
+acc += Math.sin(37147) + Math.cos(37148) * 93;
+acc += Math.sin(37148) + Math.cos(37149) * 94;
+acc += Math.sin(37149) + Math.cos(37150) * 95;
+acc += Math.sin(37150) + Math.cos(37151) * 96;
+acc += Math.sin(37151) + Math.cos(37152) * 0;
+acc += Math.sin(37152) + Math.cos(37153) * 1;
+acc += Math.sin(37153) + Math.cos(37154) * 2;
+acc += Math.sin(37154) + Math.cos(37155) * 3;
+acc += Math.sin(37155) + Math.cos(37156) * 4;
+acc += Math.sin(37156) + Math.cos(37157) * 5;
+acc += Math.sin(37157) + Math.cos(37158) * 6;
+acc += Math.sin(37158) + Math.cos(37159) * 7;
+acc += Math.sin(37159) + Math.cos(37160) * 8;
+acc += Math.sin(37160) + Math.cos(37161) * 9;
+acc += Math.sin(37161) + Math.cos(37162) * 10;
+acc += Math.sin(37162) + Math.cos(37163) * 11;
+acc += Math.sin(37163) + Math.cos(37164) * 12;
+acc += Math.sin(37164) + Math.cos(37165) * 13;
+acc += Math.sin(37165) + Math.cos(37166) * 14;
+acc += Math.sin(37166) + Math.cos(37167) * 15;
+acc += Math.sin(37167) + Math.cos(37168) * 16;
+acc += Math.sin(37168) + Math.cos(37169) * 17;
+acc += Math.sin(37169) + Math.cos(37170) * 18;
+acc += Math.sin(37170) + Math.cos(37171) * 19;
+acc += Math.sin(37171) + Math.cos(37172) * 20;
+acc += Math.sin(37172) + Math.cos(37173) * 21;
+acc += Math.sin(37173) + Math.cos(37174) * 22;
+acc += Math.sin(37174) + Math.cos(37175) * 23;
+acc += Math.sin(37175) + Math.cos(37176) * 24;
+acc += Math.sin(37176) + Math.cos(37177) * 25;
+acc += Math.sin(37177) + Math.cos(37178) * 26;
+acc += Math.sin(37178) + Math.cos(37179) * 27;
+acc += Math.sin(37179) + Math.cos(37180) * 28;
+acc += Math.sin(37180) + Math.cos(37181) * 29;
+acc += Math.sin(37181) + Math.cos(37182) * 30;
+acc += Math.sin(37182) + Math.cos(37183) * 31;
+acc += Math.sin(37183) + Math.cos(37184) * 32;
+acc += Math.sin(37184) + Math.cos(37185) * 33;
+acc += Math.sin(37185) + Math.cos(37186) * 34;
+acc += Math.sin(37186) + Math.cos(37187) * 35;
+acc += Math.sin(37187) + Math.cos(37188) * 36;
+acc += Math.sin(37188) + Math.cos(37189) * 37;
+acc += Math.sin(37189) + Math.cos(37190) * 38;
+acc += Math.sin(37190) + Math.cos(37191) * 39;
+acc += Math.sin(37191) + Math.cos(37192) * 40;
+acc += Math.sin(37192) + Math.cos(37193) * 41;
+acc += Math.sin(37193) + Math.cos(37194) * 42;
+acc += Math.sin(37194) + Math.cos(37195) * 43;
+acc += Math.sin(37195) + Math.cos(37196) * 44;
+acc += Math.sin(37196) + Math.cos(37197) * 45;
+acc += Math.sin(37197) + Math.cos(37198) * 46;
+acc += Math.sin(37198) + Math.cos(37199) * 47;
+acc += Math.sin(37199) + Math.cos(37200) * 48;
+acc += Math.sin(37200) + Math.cos(37201) * 49;
+acc += Math.sin(37201) + Math.cos(37202) * 50;
+acc += Math.sin(37202) + Math.cos(37203) * 51;
+acc += Math.sin(37203) + Math.cos(37204) * 52;
+acc += Math.sin(37204) + Math.cos(37205) * 53;
+acc += Math.sin(37205) + Math.cos(37206) * 54;
+acc += Math.sin(37206) + Math.cos(37207) * 55;
+acc += Math.sin(37207) + Math.cos(37208) * 56;
+acc += Math.sin(37208) + Math.cos(37209) * 57;
+acc += Math.sin(37209) + Math.cos(37210) * 58;
+acc += Math.sin(37210) + Math.cos(37211) * 59;
+acc += Math.sin(37211) + Math.cos(37212) * 60;
+acc += Math.sin(37212) + Math.cos(37213) * 61;
+acc += Math.sin(37213) + Math.cos(37214) * 62;
+acc += Math.sin(37214) + Math.cos(37215) * 63;
+acc += Math.sin(37215) + Math.cos(37216) * 64;
+acc += Math.sin(37216) + Math.cos(37217) * 65;
+acc += Math.sin(37217) + Math.cos(37218) * 66;
+acc += Math.sin(37218) + Math.cos(37219) * 67;
+acc += Math.sin(37219) + Math.cos(37220) * 68;
+acc += Math.sin(37220) + Math.cos(37221) * 69;
+acc += Math.sin(37221) + Math.cos(37222) * 70;
+acc += Math.sin(37222) + Math.cos(37223) * 71;
+acc += Math.sin(37223) + Math.cos(37224) * 72;
+acc += Math.sin(37224) + Math.cos(37225) * 73;
+acc += Math.sin(37225) + Math.cos(37226) * 74;
+acc += Math.sin(37226) + Math.cos(37227) * 75;
+acc += Math.sin(37227) + Math.cos(37228) * 76;
+acc += Math.sin(37228) + Math.cos(37229) * 77;
+acc += Math.sin(37229) + Math.cos(37230) * 78;
+acc += Math.sin(37230) + Math.cos(37231) * 79;
+acc += Math.sin(37231) + Math.cos(37232) * 80;
+acc += Math.sin(37232) + Math.cos(37233) * 81;
+acc += Math.sin(37233) + Math.cos(37234) * 82;
+acc += Math.sin(37234) + Math.cos(37235) * 83;
+acc += Math.sin(37235) + Math.cos(37236) * 84;
+acc += Math.sin(37236) + Math.cos(37237) * 85;
+acc += Math.sin(37237) + Math.cos(37238) * 86;
+acc += Math.sin(37238) + Math.cos(37239) * 87;
+acc += Math.sin(37239) + Math.cos(37240) * 88;
+acc += Math.sin(37240) + Math.cos(37241) * 89;
+acc += Math.sin(37241) + Math.cos(37242) * 90;
+acc += Math.sin(37242) + Math.cos(37243) * 91;
+acc += Math.sin(37243) + Math.cos(37244) * 92;
+acc += Math.sin(37244) + Math.cos(37245) * 93;
+acc += Math.sin(37245) + Math.cos(37246) * 94;
+acc += Math.sin(37246) + Math.cos(37247) * 95;
+acc += Math.sin(37247) + Math.cos(37248) * 96;
+acc += Math.sin(37248) + Math.cos(37249) * 0;
+acc += Math.sin(37249) + Math.cos(37250) * 1;
+acc += Math.sin(37250) + Math.cos(37251) * 2;
+acc += Math.sin(37251) + Math.cos(37252) * 3;
+acc += Math.sin(37252) + Math.cos(37253) * 4;
+acc += Math.sin(37253) + Math.cos(37254) * 5;
+acc += Math.sin(37254) + Math.cos(37255) * 6;
+acc += Math.sin(37255) + Math.cos(37256) * 7;
+acc += Math.sin(37256) + Math.cos(37257) * 8;
+acc += Math.sin(37257) + Math.cos(37258) * 9;
+acc += Math.sin(37258) + Math.cos(37259) * 10;
+acc += Math.sin(37259) + Math.cos(37260) * 11;
+acc += Math.sin(37260) + Math.cos(37261) * 12;
+acc += Math.sin(37261) + Math.cos(37262) * 13;
+acc += Math.sin(37262) + Math.cos(37263) * 14;
+acc += Math.sin(37263) + Math.cos(37264) * 15;
+acc += Math.sin(37264) + Math.cos(37265) * 16;
+acc += Math.sin(37265) + Math.cos(37266) * 17;
+acc += Math.sin(37266) + Math.cos(37267) * 18;
+acc += Math.sin(37267) + Math.cos(37268) * 19;
+acc += Math.sin(37268) + Math.cos(37269) * 20;
+acc += Math.sin(37269) + Math.cos(37270) * 21;
+acc += Math.sin(37270) + Math.cos(37271) * 22;
+acc += Math.sin(37271) + Math.cos(37272) * 23;
+acc += Math.sin(37272) + Math.cos(37273) * 24;
+acc += Math.sin(37273) + Math.cos(37274) * 25;
+acc += Math.sin(37274) + Math.cos(37275) * 26;
+acc += Math.sin(37275) + Math.cos(37276) * 27;
+acc += Math.sin(37276) + Math.cos(37277) * 28;
+acc += Math.sin(37277) + Math.cos(37278) * 29;
+acc += Math.sin(37278) + Math.cos(37279) * 30;
+acc += Math.sin(37279) + Math.cos(37280) * 31;
+acc += Math.sin(37280) + Math.cos(37281) * 32;
+acc += Math.sin(37281) + Math.cos(37282) * 33;
+acc += Math.sin(37282) + Math.cos(37283) * 34;
+acc += Math.sin(37283) + Math.cos(37284) * 35;
+acc += Math.sin(37284) + Math.cos(37285) * 36;
+acc += Math.sin(37285) + Math.cos(37286) * 37;
+acc += Math.sin(37286) + Math.cos(37287) * 38;
+acc += Math.sin(37287) + Math.cos(37288) * 39;
+acc += Math.sin(37288) + Math.cos(37289) * 40;
+acc += Math.sin(37289) + Math.cos(37290) * 41;
+acc += Math.sin(37290) + Math.cos(37291) * 42;
+acc += Math.sin(37291) + Math.cos(37292) * 43;
+acc += Math.sin(37292) + Math.cos(37293) * 44;
+acc += Math.sin(37293) + Math.cos(37294) * 45;
+acc += Math.sin(37294) + Math.cos(37295) * 46;
+acc += Math.sin(37295) + Math.cos(37296) * 47;
+acc += Math.sin(37296) + Math.cos(37297) * 48;
+acc += Math.sin(37297) + Math.cos(37298) * 49;
+acc += Math.sin(37298) + Math.cos(37299) * 50;
+acc += Math.sin(37299) + Math.cos(37300) * 51;
+acc += Math.sin(37300) + Math.cos(37301) * 52;
+acc += Math.sin(37301) + Math.cos(37302) * 53;
+acc += Math.sin(37302) + Math.cos(37303) * 54;
+acc += Math.sin(37303) + Math.cos(37304) * 55;
+acc += Math.sin(37304) + Math.cos(37305) * 56;
+acc += Math.sin(37305) + Math.cos(37306) * 57;
+acc += Math.sin(37306) + Math.cos(37307) * 58;
+acc += Math.sin(37307) + Math.cos(37308) * 59;
+acc += Math.sin(37308) + Math.cos(37309) * 60;
+acc += Math.sin(37309) + Math.cos(37310) * 61;
+acc += Math.sin(37310) + Math.cos(37311) * 62;
+acc += Math.sin(37311) + Math.cos(37312) * 63;
+acc += Math.sin(37312) + Math.cos(37313) * 64;
+acc += Math.sin(37313) + Math.cos(37314) * 65;
+acc += Math.sin(37314) + Math.cos(37315) * 66;
+acc += Math.sin(37315) + Math.cos(37316) * 67;
+acc += Math.sin(37316) + Math.cos(37317) * 68;
+acc += Math.sin(37317) + Math.cos(37318) * 69;
+acc += Math.sin(37318) + Math.cos(37319) * 70;
+acc += Math.sin(37319) + Math.cos(37320) * 71;
+acc += Math.sin(37320) + Math.cos(37321) * 72;
+acc += Math.sin(37321) + Math.cos(37322) * 73;
+acc += Math.sin(37322) + Math.cos(37323) * 74;
+acc += Math.sin(37323) + Math.cos(37324) * 75;
+acc += Math.sin(37324) + Math.cos(37325) * 76;
+acc += Math.sin(37325) + Math.cos(37326) * 77;
+acc += Math.sin(37326) + Math.cos(37327) * 78;
+acc += Math.sin(37327) + Math.cos(37328) * 79;
+acc += Math.sin(37328) + Math.cos(37329) * 80;
+acc += Math.sin(37329) + Math.cos(37330) * 81;
+acc += Math.sin(37330) + Math.cos(37331) * 82;
+acc += Math.sin(37331) + Math.cos(37332) * 83;
+acc += Math.sin(37332) + Math.cos(37333) * 84;
+acc += Math.sin(37333) + Math.cos(37334) * 85;
+acc += Math.sin(37334) + Math.cos(37335) * 86;
+acc += Math.sin(37335) + Math.cos(37336) * 87;
+acc += Math.sin(37336) + Math.cos(37337) * 88;
+acc += Math.sin(37337) + Math.cos(37338) * 89;
+acc += Math.sin(37338) + Math.cos(37339) * 90;
+acc += Math.sin(37339) + Math.cos(37340) * 91;
+acc += Math.sin(37340) + Math.cos(37341) * 92;
+acc += Math.sin(37341) + Math.cos(37342) * 93;
+acc += Math.sin(37342) + Math.cos(37343) * 94;
+acc += Math.sin(37343) + Math.cos(37344) * 95;
+acc += Math.sin(37344) + Math.cos(37345) * 96;
+acc += Math.sin(37345) + Math.cos(37346) * 0;
+acc += Math.sin(37346) + Math.cos(37347) * 1;
+acc += Math.sin(37347) + Math.cos(37348) * 2;
+acc += Math.sin(37348) + Math.cos(37349) * 3;
+acc += Math.sin(37349) + Math.cos(37350) * 4;
+acc += Math.sin(37350) + Math.cos(37351) * 5;
+acc += Math.sin(37351) + Math.cos(37352) * 6;
+acc += Math.sin(37352) + Math.cos(37353) * 7;
+acc += Math.sin(37353) + Math.cos(37354) * 8;
+acc += Math.sin(37354) + Math.cos(37355) * 9;
+acc += Math.sin(37355) + Math.cos(37356) * 10;
+acc += Math.sin(37356) + Math.cos(37357) * 11;
+acc += Math.sin(37357) + Math.cos(37358) * 12;
+acc += Math.sin(37358) + Math.cos(37359) * 13;
+acc += Math.sin(37359) + Math.cos(37360) * 14;
+acc += Math.sin(37360) + Math.cos(37361) * 15;
+acc += Math.sin(37361) + Math.cos(37362) * 16;
+acc += Math.sin(37362) + Math.cos(37363) * 17;
+acc += Math.sin(37363) + Math.cos(37364) * 18;
+acc += Math.sin(37364) + Math.cos(37365) * 19;
+acc += Math.sin(37365) + Math.cos(37366) * 20;
+acc += Math.sin(37366) + Math.cos(37367) * 21;
+acc += Math.sin(37367) + Math.cos(37368) * 22;
+acc += Math.sin(37368) + Math.cos(37369) * 23;
+acc += Math.sin(37369) + Math.cos(37370) * 24;
+acc += Math.sin(37370) + Math.cos(37371) * 25;
+acc += Math.sin(37371) + Math.cos(37372) * 26;
+acc += Math.sin(37372) + Math.cos(37373) * 27;
+acc += Math.sin(37373) + Math.cos(37374) * 28;
+acc += Math.sin(37374) + Math.cos(37375) * 29;
+acc += Math.sin(37375) + Math.cos(37376) * 30;
+acc += Math.sin(37376) + Math.cos(37377) * 31;
+acc += Math.sin(37377) + Math.cos(37378) * 32;
+acc += Math.sin(37378) + Math.cos(37379) * 33;
+acc += Math.sin(37379) + Math.cos(37380) * 34;
+acc += Math.sin(37380) + Math.cos(37381) * 35;
+acc += Math.sin(37381) + Math.cos(37382) * 36;
+acc += Math.sin(37382) + Math.cos(37383) * 37;
+acc += Math.sin(37383) + Math.cos(37384) * 38;
+acc += Math.sin(37384) + Math.cos(37385) * 39;
+acc += Math.sin(37385) + Math.cos(37386) * 40;
+acc += Math.sin(37386) + Math.cos(37387) * 41;
+acc += Math.sin(37387) + Math.cos(37388) * 42;
+acc += Math.sin(37388) + Math.cos(37389) * 43;
+acc += Math.sin(37389) + Math.cos(37390) * 44;
+acc += Math.sin(37390) + Math.cos(37391) * 45;
+acc += Math.sin(37391) + Math.cos(37392) * 46;
+acc += Math.sin(37392) + Math.cos(37393) * 47;
+acc += Math.sin(37393) + Math.cos(37394) * 48;
+acc += Math.sin(37394) + Math.cos(37395) * 49;
+acc += Math.sin(37395) + Math.cos(37396) * 50;
+acc += Math.sin(37396) + Math.cos(37397) * 51;
+acc += Math.sin(37397) + Math.cos(37398) * 52;
+acc += Math.sin(37398) + Math.cos(37399) * 53;
+acc += Math.sin(37399) + Math.cos(37400) * 54;
+acc += Math.sin(37400) + Math.cos(37401) * 55;
+acc += Math.sin(37401) + Math.cos(37402) * 56;
+acc += Math.sin(37402) + Math.cos(37403) * 57;
+acc += Math.sin(37403) + Math.cos(37404) * 58;
+acc += Math.sin(37404) + Math.cos(37405) * 59;
+acc += Math.sin(37405) + Math.cos(37406) * 60;
+acc += Math.sin(37406) + Math.cos(37407) * 61;
+acc += Math.sin(37407) + Math.cos(37408) * 62;
+acc += Math.sin(37408) + Math.cos(37409) * 63;
+acc += Math.sin(37409) + Math.cos(37410) * 64;
+acc += Math.sin(37410) + Math.cos(37411) * 65;
+acc += Math.sin(37411) + Math.cos(37412) * 66;
+acc += Math.sin(37412) + Math.cos(37413) * 67;
+acc += Math.sin(37413) + Math.cos(37414) * 68;
+acc += Math.sin(37414) + Math.cos(37415) * 69;
+acc += Math.sin(37415) + Math.cos(37416) * 70;
+acc += Math.sin(37416) + Math.cos(37417) * 71;
+acc += Math.sin(37417) + Math.cos(37418) * 72;
+acc += Math.sin(37418) + Math.cos(37419) * 73;
+acc += Math.sin(37419) + Math.cos(37420) * 74;
+acc += Math.sin(37420) + Math.cos(37421) * 75;
+acc += Math.sin(37421) + Math.cos(37422) * 76;
+acc += Math.sin(37422) + Math.cos(37423) * 77;
+acc += Math.sin(37423) + Math.cos(37424) * 78;
+acc += Math.sin(37424) + Math.cos(37425) * 79;
+acc += Math.sin(37425) + Math.cos(37426) * 80;
+acc += Math.sin(37426) + Math.cos(37427) * 81;
+acc += Math.sin(37427) + Math.cos(37428) * 82;
+acc += Math.sin(37428) + Math.cos(37429) * 83;
+acc += Math.sin(37429) + Math.cos(37430) * 84;
+acc += Math.sin(37430) + Math.cos(37431) * 85;
+acc += Math.sin(37431) + Math.cos(37432) * 86;
+acc += Math.sin(37432) + Math.cos(37433) * 87;
+acc += Math.sin(37433) + Math.cos(37434) * 88;
+acc += Math.sin(37434) + Math.cos(37435) * 89;
+acc += Math.sin(37435) + Math.cos(37436) * 90;
+acc += Math.sin(37436) + Math.cos(37437) * 91;
+acc += Math.sin(37437) + Math.cos(37438) * 92;
+acc += Math.sin(37438) + Math.cos(37439) * 93;
+acc += Math.sin(37439) + Math.cos(37440) * 94;
+acc += Math.sin(37440) + Math.cos(37441) * 95;
+acc += Math.sin(37441) + Math.cos(37442) * 96;
+acc += Math.sin(37442) + Math.cos(37443) * 0;
+acc += Math.sin(37443) + Math.cos(37444) * 1;
+acc += Math.sin(37444) + Math.cos(37445) * 2;
+acc += Math.sin(37445) + Math.cos(37446) * 3;
+acc += Math.sin(37446) + Math.cos(37447) * 4;
+acc += Math.sin(37447) + Math.cos(37448) * 5;
+acc += Math.sin(37448) + Math.cos(37449) * 6;
+acc += Math.sin(37449) + Math.cos(37450) * 7;
+acc += Math.sin(37450) + Math.cos(37451) * 8;
+acc += Math.sin(37451) + Math.cos(37452) * 9;
+acc += Math.sin(37452) + Math.cos(37453) * 10;
+acc += Math.sin(37453) + Math.cos(37454) * 11;
+acc += Math.sin(37454) + Math.cos(37455) * 12;
+acc += Math.sin(37455) + Math.cos(37456) * 13;
+acc += Math.sin(37456) + Math.cos(37457) * 14;
+acc += Math.sin(37457) + Math.cos(37458) * 15;
+acc += Math.sin(37458) + Math.cos(37459) * 16;
+acc += Math.sin(37459) + Math.cos(37460) * 17;
+acc += Math.sin(37460) + Math.cos(37461) * 18;
+acc += Math.sin(37461) + Math.cos(37462) * 19;
+acc += Math.sin(37462) + Math.cos(37463) * 20;
+acc += Math.sin(37463) + Math.cos(37464) * 21;
+acc += Math.sin(37464) + Math.cos(37465) * 22;
+acc += Math.sin(37465) + Math.cos(37466) * 23;
+acc += Math.sin(37466) + Math.cos(37467) * 24;
+acc += Math.sin(37467) + Math.cos(37468) * 25;
+acc += Math.sin(37468) + Math.cos(37469) * 26;
+acc += Math.sin(37469) + Math.cos(37470) * 27;
+acc += Math.sin(37470) + Math.cos(37471) * 28;
+acc += Math.sin(37471) + Math.cos(37472) * 29;
+acc += Math.sin(37472) + Math.cos(37473) * 30;
+acc += Math.sin(37473) + Math.cos(37474) * 31;
+acc += Math.sin(37474) + Math.cos(37475) * 32;
+acc += Math.sin(37475) + Math.cos(37476) * 33;
+acc += Math.sin(37476) + Math.cos(37477) * 34;
+acc += Math.sin(37477) + Math.cos(37478) * 35;
+acc += Math.sin(37478) + Math.cos(37479) * 36;
+acc += Math.sin(37479) + Math.cos(37480) * 37;
+acc += Math.sin(37480) + Math.cos(37481) * 38;
+acc += Math.sin(37481) + Math.cos(37482) * 39;
+acc += Math.sin(37482) + Math.cos(37483) * 40;
+acc += Math.sin(37483) + Math.cos(37484) * 41;
+acc += Math.sin(37484) + Math.cos(37485) * 42;
+acc += Math.sin(37485) + Math.cos(37486) * 43;
+acc += Math.sin(37486) + Math.cos(37487) * 44;
+acc += Math.sin(37487) + Math.cos(37488) * 45;
+acc += Math.sin(37488) + Math.cos(37489) * 46;
+acc += Math.sin(37489) + Math.cos(37490) * 47;
+acc += Math.sin(37490) + Math.cos(37491) * 48;
+acc += Math.sin(37491) + Math.cos(37492) * 49;
+acc += Math.sin(37492) + Math.cos(37493) * 50;
+acc += Math.sin(37493) + Math.cos(37494) * 51;
+acc += Math.sin(37494) + Math.cos(37495) * 52;
+acc += Math.sin(37495) + Math.cos(37496) * 53;
+acc += Math.sin(37496) + Math.cos(37497) * 54;
+acc += Math.sin(37497) + Math.cos(37498) * 55;
+acc += Math.sin(37498) + Math.cos(37499) * 56;
+acc += Math.sin(37499) + Math.cos(37500) * 57;
+acc += Math.sin(37500) + Math.cos(37501) * 58;
+acc += Math.sin(37501) + Math.cos(37502) * 59;
+acc += Math.sin(37502) + Math.cos(37503) * 60;
+acc += Math.sin(37503) + Math.cos(37504) * 61;
+acc += Math.sin(37504) + Math.cos(37505) * 62;
+acc += Math.sin(37505) + Math.cos(37506) * 63;
+acc += Math.sin(37506) + Math.cos(37507) * 64;
+acc += Math.sin(37507) + Math.cos(37508) * 65;
+acc += Math.sin(37508) + Math.cos(37509) * 66;
+acc += Math.sin(37509) + Math.cos(37510) * 67;
+acc += Math.sin(37510) + Math.cos(37511) * 68;
+acc += Math.sin(37511) + Math.cos(37512) * 69;
+acc += Math.sin(37512) + Math.cos(37513) * 70;
+acc += Math.sin(37513) + Math.cos(37514) * 71;
+acc += Math.sin(37514) + Math.cos(37515) * 72;
+acc += Math.sin(37515) + Math.cos(37516) * 73;
+acc += Math.sin(37516) + Math.cos(37517) * 74;
+acc += Math.sin(37517) + Math.cos(37518) * 75;
+acc += Math.sin(37518) + Math.cos(37519) * 76;
+acc += Math.sin(37519) + Math.cos(37520) * 77;
+acc += Math.sin(37520) + Math.cos(37521) * 78;
+acc += Math.sin(37521) + Math.cos(37522) * 79;
+acc += Math.sin(37522) + Math.cos(37523) * 80;
+acc += Math.sin(37523) + Math.cos(37524) * 81;
+acc += Math.sin(37524) + Math.cos(37525) * 82;
+acc += Math.sin(37525) + Math.cos(37526) * 83;
+acc += Math.sin(37526) + Math.cos(37527) * 84;
+acc += Math.sin(37527) + Math.cos(37528) * 85;
+acc += Math.sin(37528) + Math.cos(37529) * 86;
+acc += Math.sin(37529) + Math.cos(37530) * 87;
+acc += Math.sin(37530) + Math.cos(37531) * 88;
+acc += Math.sin(37531) + Math.cos(37532) * 89;
+acc += Math.sin(37532) + Math.cos(37533) * 90;
+acc += Math.sin(37533) + Math.cos(37534) * 91;
+acc += Math.sin(37534) + Math.cos(37535) * 92;
+acc += Math.sin(37535) + Math.cos(37536) * 93;
+acc += Math.sin(37536) + Math.cos(37537) * 94;
+acc += Math.sin(37537) + Math.cos(37538) * 95;
+acc += Math.sin(37538) + Math.cos(37539) * 96;
+acc += Math.sin(37539) + Math.cos(37540) * 0;
+acc += Math.sin(37540) + Math.cos(37541) * 1;
+acc += Math.sin(37541) + Math.cos(37542) * 2;
+acc += Math.sin(37542) + Math.cos(37543) * 3;
+acc += Math.sin(37543) + Math.cos(37544) * 4;
+acc += Math.sin(37544) + Math.cos(37545) * 5;
+acc += Math.sin(37545) + Math.cos(37546) * 6;
+acc += Math.sin(37546) + Math.cos(37547) * 7;
+acc += Math.sin(37547) + Math.cos(37548) * 8;
+acc += Math.sin(37548) + Math.cos(37549) * 9;
+acc += Math.sin(37549) + Math.cos(37550) * 10;
+acc += Math.sin(37550) + Math.cos(37551) * 11;
+acc += Math.sin(37551) + Math.cos(37552) * 12;
+acc += Math.sin(37552) + Math.cos(37553) * 13;
+acc += Math.sin(37553) + Math.cos(37554) * 14;
+acc += Math.sin(37554) + Math.cos(37555) * 15;
+acc += Math.sin(37555) + Math.cos(37556) * 16;
+acc += Math.sin(37556) + Math.cos(37557) * 17;
+acc += Math.sin(37557) + Math.cos(37558) * 18;
+acc += Math.sin(37558) + Math.cos(37559) * 19;
+acc += Math.sin(37559) + Math.cos(37560) * 20;
+acc += Math.sin(37560) + Math.cos(37561) * 21;
+acc += Math.sin(37561) + Math.cos(37562) * 22;
+acc += Math.sin(37562) + Math.cos(37563) * 23;
+acc += Math.sin(37563) + Math.cos(37564) * 24;
+acc += Math.sin(37564) + Math.cos(37565) * 25;
+acc += Math.sin(37565) + Math.cos(37566) * 26;
+acc += Math.sin(37566) + Math.cos(37567) * 27;
+acc += Math.sin(37567) + Math.cos(37568) * 28;
+acc += Math.sin(37568) + Math.cos(37569) * 29;
+acc += Math.sin(37569) + Math.cos(37570) * 30;
+acc += Math.sin(37570) + Math.cos(37571) * 31;
+acc += Math.sin(37571) + Math.cos(37572) * 32;
+acc += Math.sin(37572) + Math.cos(37573) * 33;
+acc += Math.sin(37573) + Math.cos(37574) * 34;
+acc += Math.sin(37574) + Math.cos(37575) * 35;
+acc += Math.sin(37575) + Math.cos(37576) * 36;
+acc += Math.sin(37576) + Math.cos(37577) * 37;
+acc += Math.sin(37577) + Math.cos(37578) * 38;
+acc += Math.sin(37578) + Math.cos(37579) * 39;
+acc += Math.sin(37579) + Math.cos(37580) * 40;
+acc += Math.sin(37580) + Math.cos(37581) * 41;
+acc += Math.sin(37581) + Math.cos(37582) * 42;
+acc += Math.sin(37582) + Math.cos(37583) * 43;
+acc += Math.sin(37583) + Math.cos(37584) * 44;
+acc += Math.sin(37584) + Math.cos(37585) * 45;
+acc += Math.sin(37585) + Math.cos(37586) * 46;
+acc += Math.sin(37586) + Math.cos(37587) * 47;
+acc += Math.sin(37587) + Math.cos(37588) * 48;
+acc += Math.sin(37588) + Math.cos(37589) * 49;
+acc += Math.sin(37589) + Math.cos(37590) * 50;
+acc += Math.sin(37590) + Math.cos(37591) * 51;
+acc += Math.sin(37591) + Math.cos(37592) * 52;
+acc += Math.sin(37592) + Math.cos(37593) * 53;
+acc += Math.sin(37593) + Math.cos(37594) * 54;
+acc += Math.sin(37594) + Math.cos(37595) * 55;
+acc += Math.sin(37595) + Math.cos(37596) * 56;
+acc += Math.sin(37596) + Math.cos(37597) * 57;
+acc += Math.sin(37597) + Math.cos(37598) * 58;
+acc += Math.sin(37598) + Math.cos(37599) * 59;
+acc += Math.sin(37599) + Math.cos(37600) * 60;
+acc += Math.sin(37600) + Math.cos(37601) * 61;
+acc += Math.sin(37601) + Math.cos(37602) * 62;
+acc += Math.sin(37602) + Math.cos(37603) * 63;
+acc += Math.sin(37603) + Math.cos(37604) * 64;
+acc += Math.sin(37604) + Math.cos(37605) * 65;
+acc += Math.sin(37605) + Math.cos(37606) * 66;
+acc += Math.sin(37606) + Math.cos(37607) * 67;
+acc += Math.sin(37607) + Math.cos(37608) * 68;
+acc += Math.sin(37608) + Math.cos(37609) * 69;
+acc += Math.sin(37609) + Math.cos(37610) * 70;
+acc += Math.sin(37610) + Math.cos(37611) * 71;
+acc += Math.sin(37611) + Math.cos(37612) * 72;
+acc += Math.sin(37612) + Math.cos(37613) * 73;
+acc += Math.sin(37613) + Math.cos(37614) * 74;
+acc += Math.sin(37614) + Math.cos(37615) * 75;
+acc += Math.sin(37615) + Math.cos(37616) * 76;
+acc += Math.sin(37616) + Math.cos(37617) * 77;
+acc += Math.sin(37617) + Math.cos(37618) * 78;
+acc += Math.sin(37618) + Math.cos(37619) * 79;
+acc += Math.sin(37619) + Math.cos(37620) * 80;
+acc += Math.sin(37620) + Math.cos(37621) * 81;
+acc += Math.sin(37621) + Math.cos(37622) * 82;
+acc += Math.sin(37622) + Math.cos(37623) * 83;
+acc += Math.sin(37623) + Math.cos(37624) * 84;
+acc += Math.sin(37624) + Math.cos(37625) * 85;
+acc += Math.sin(37625) + Math.cos(37626) * 86;
+acc += Math.sin(37626) + Math.cos(37627) * 87;
+acc += Math.sin(37627) + Math.cos(37628) * 88;
+acc += Math.sin(37628) + Math.cos(37629) * 89;
+acc += Math.sin(37629) + Math.cos(37630) * 90;
+acc += Math.sin(37630) + Math.cos(37631) * 91;
+acc += Math.sin(37631) + Math.cos(37632) * 92;
+acc += Math.sin(37632) + Math.cos(37633) * 93;
+acc += Math.sin(37633) + Math.cos(37634) * 94;
+acc += Math.sin(37634) + Math.cos(37635) * 95;
+acc += Math.sin(37635) + Math.cos(37636) * 96;
+acc += Math.sin(37636) + Math.cos(37637) * 0;
+acc += Math.sin(37637) + Math.cos(37638) * 1;
+acc += Math.sin(37638) + Math.cos(37639) * 2;
+acc += Math.sin(37639) + Math.cos(37640) * 3;
+acc += Math.sin(37640) + Math.cos(37641) * 4;
+acc += Math.sin(37641) + Math.cos(37642) * 5;
+acc += Math.sin(37642) + Math.cos(37643) * 6;
+acc += Math.sin(37643) + Math.cos(37644) * 7;
+acc += Math.sin(37644) + Math.cos(37645) * 8;
+acc += Math.sin(37645) + Math.cos(37646) * 9;
+acc += Math.sin(37646) + Math.cos(37647) * 10;
+acc += Math.sin(37647) + Math.cos(37648) * 11;
+acc += Math.sin(37648) + Math.cos(37649) * 12;
+acc += Math.sin(37649) + Math.cos(37650) * 13;
+acc += Math.sin(37650) + Math.cos(37651) * 14;
+acc += Math.sin(37651) + Math.cos(37652) * 15;
+acc += Math.sin(37652) + Math.cos(37653) * 16;
+acc += Math.sin(37653) + Math.cos(37654) * 17;
+acc += Math.sin(37654) + Math.cos(37655) * 18;
+acc += Math.sin(37655) + Math.cos(37656) * 19;
+acc += Math.sin(37656) + Math.cos(37657) * 20;
+acc += Math.sin(37657) + Math.cos(37658) * 21;
+acc += Math.sin(37658) + Math.cos(37659) * 22;
+acc += Math.sin(37659) + Math.cos(37660) * 23;
+acc += Math.sin(37660) + Math.cos(37661) * 24;
+acc += Math.sin(37661) + Math.cos(37662) * 25;
+acc += Math.sin(37662) + Math.cos(37663) * 26;
+acc += Math.sin(37663) + Math.cos(37664) * 27;
+acc += Math.sin(37664) + Math.cos(37665) * 28;
+acc += Math.sin(37665) + Math.cos(37666) * 29;
+acc += Math.sin(37666) + Math.cos(37667) * 30;
+acc += Math.sin(37667) + Math.cos(37668) * 31;
+acc += Math.sin(37668) + Math.cos(37669) * 32;
+acc += Math.sin(37669) + Math.cos(37670) * 33;
+acc += Math.sin(37670) + Math.cos(37671) * 34;
+acc += Math.sin(37671) + Math.cos(37672) * 35;
+acc += Math.sin(37672) + Math.cos(37673) * 36;
+acc += Math.sin(37673) + Math.cos(37674) * 37;
+acc += Math.sin(37674) + Math.cos(37675) * 38;
+acc += Math.sin(37675) + Math.cos(37676) * 39;
+acc += Math.sin(37676) + Math.cos(37677) * 40;
+acc += Math.sin(37677) + Math.cos(37678) * 41;
+acc += Math.sin(37678) + Math.cos(37679) * 42;
+acc += Math.sin(37679) + Math.cos(37680) * 43;
+acc += Math.sin(37680) + Math.cos(37681) * 44;
+acc += Math.sin(37681) + Math.cos(37682) * 45;
+acc += Math.sin(37682) + Math.cos(37683) * 46;
+acc += Math.sin(37683) + Math.cos(37684) * 47;
+acc += Math.sin(37684) + Math.cos(37685) * 48;
+acc += Math.sin(37685) + Math.cos(37686) * 49;
+acc += Math.sin(37686) + Math.cos(37687) * 50;
+acc += Math.sin(37687) + Math.cos(37688) * 51;
+acc += Math.sin(37688) + Math.cos(37689) * 52;
+acc += Math.sin(37689) + Math.cos(37690) * 53;
+acc += Math.sin(37690) + Math.cos(37691) * 54;
+acc += Math.sin(37691) + Math.cos(37692) * 55;
+acc += Math.sin(37692) + Math.cos(37693) * 56;
+acc += Math.sin(37693) + Math.cos(37694) * 57;
+acc += Math.sin(37694) + Math.cos(37695) * 58;
+acc += Math.sin(37695) + Math.cos(37696) * 59;
+acc += Math.sin(37696) + Math.cos(37697) * 60;
+acc += Math.sin(37697) + Math.cos(37698) * 61;
+acc += Math.sin(37698) + Math.cos(37699) * 62;
+acc += Math.sin(37699) + Math.cos(37700) * 63;
+acc += Math.sin(37700) + Math.cos(37701) * 64;
+acc += Math.sin(37701) + Math.cos(37702) * 65;
+acc += Math.sin(37702) + Math.cos(37703) * 66;
+acc += Math.sin(37703) + Math.cos(37704) * 67;
+acc += Math.sin(37704) + Math.cos(37705) * 68;
+acc += Math.sin(37705) + Math.cos(37706) * 69;
+acc += Math.sin(37706) + Math.cos(37707) * 70;
+acc += Math.sin(37707) + Math.cos(37708) * 71;
+acc += Math.sin(37708) + Math.cos(37709) * 72;
+acc += Math.sin(37709) + Math.cos(37710) * 73;
+acc += Math.sin(37710) + Math.cos(37711) * 74;
+acc += Math.sin(37711) + Math.cos(37712) * 75;
+acc += Math.sin(37712) + Math.cos(37713) * 76;
+acc += Math.sin(37713) + Math.cos(37714) * 77;
+acc += Math.sin(37714) + Math.cos(37715) * 78;
+acc += Math.sin(37715) + Math.cos(37716) * 79;
+acc += Math.sin(37716) + Math.cos(37717) * 80;
+acc += Math.sin(37717) + Math.cos(37718) * 81;
+acc += Math.sin(37718) + Math.cos(37719) * 82;
+acc += Math.sin(37719) + Math.cos(37720) * 83;
+acc += Math.sin(37720) + Math.cos(37721) * 84;
+acc += Math.sin(37721) + Math.cos(37722) * 85;
+acc += Math.sin(37722) + Math.cos(37723) * 86;
+acc += Math.sin(37723) + Math.cos(37724) * 87;
+acc += Math.sin(37724) + Math.cos(37725) * 88;
+acc += Math.sin(37725) + Math.cos(37726) * 89;
+acc += Math.sin(37726) + Math.cos(37727) * 90;
+acc += Math.sin(37727) + Math.cos(37728) * 91;
+acc += Math.sin(37728) + Math.cos(37729) * 92;
+acc += Math.sin(37729) + Math.cos(37730) * 93;
+acc += Math.sin(37730) + Math.cos(37731) * 94;
+acc += Math.sin(37731) + Math.cos(37732) * 95;
+acc += Math.sin(37732) + Math.cos(37733) * 96;
+acc += Math.sin(37733) + Math.cos(37734) * 0;
+acc += Math.sin(37734) + Math.cos(37735) * 1;
+acc += Math.sin(37735) + Math.cos(37736) * 2;
+acc += Math.sin(37736) + Math.cos(37737) * 3;
+acc += Math.sin(37737) + Math.cos(37738) * 4;
+acc += Math.sin(37738) + Math.cos(37739) * 5;
+acc += Math.sin(37739) + Math.cos(37740) * 6;
+acc += Math.sin(37740) + Math.cos(37741) * 7;
+acc += Math.sin(37741) + Math.cos(37742) * 8;
+acc += Math.sin(37742) + Math.cos(37743) * 9;
+acc += Math.sin(37743) + Math.cos(37744) * 10;
+acc += Math.sin(37744) + Math.cos(37745) * 11;
+acc += Math.sin(37745) + Math.cos(37746) * 12;
+acc += Math.sin(37746) + Math.cos(37747) * 13;
+acc += Math.sin(37747) + Math.cos(37748) * 14;
+acc += Math.sin(37748) + Math.cos(37749) * 15;
+acc += Math.sin(37749) + Math.cos(37750) * 16;
+acc += Math.sin(37750) + Math.cos(37751) * 17;
+acc += Math.sin(37751) + Math.cos(37752) * 18;
+acc += Math.sin(37752) + Math.cos(37753) * 19;
+acc += Math.sin(37753) + Math.cos(37754) * 20;
+acc += Math.sin(37754) + Math.cos(37755) * 21;
+acc += Math.sin(37755) + Math.cos(37756) * 22;
+acc += Math.sin(37756) + Math.cos(37757) * 23;
+acc += Math.sin(37757) + Math.cos(37758) * 24;
+acc += Math.sin(37758) + Math.cos(37759) * 25;
+acc += Math.sin(37759) + Math.cos(37760) * 26;
+acc += Math.sin(37760) + Math.cos(37761) * 27;
+acc += Math.sin(37761) + Math.cos(37762) * 28;
+acc += Math.sin(37762) + Math.cos(37763) * 29;
+acc += Math.sin(37763) + Math.cos(37764) * 30;
+acc += Math.sin(37764) + Math.cos(37765) * 31;
+acc += Math.sin(37765) + Math.cos(37766) * 32;
+acc += Math.sin(37766) + Math.cos(37767) * 33;
+acc += Math.sin(37767) + Math.cos(37768) * 34;
+acc += Math.sin(37768) + Math.cos(37769) * 35;
+acc += Math.sin(37769) + Math.cos(37770) * 36;
+acc += Math.sin(37770) + Math.cos(37771) * 37;
+acc += Math.sin(37771) + Math.cos(37772) * 38;
+acc += Math.sin(37772) + Math.cos(37773) * 39;
+acc += Math.sin(37773) + Math.cos(37774) * 40;
+acc += Math.sin(37774) + Math.cos(37775) * 41;
+acc += Math.sin(37775) + Math.cos(37776) * 42;
+acc += Math.sin(37776) + Math.cos(37777) * 43;
+acc += Math.sin(37777) + Math.cos(37778) * 44;
+acc += Math.sin(37778) + Math.cos(37779) * 45;
+acc += Math.sin(37779) + Math.cos(37780) * 46;
+acc += Math.sin(37780) + Math.cos(37781) * 47;
+acc += Math.sin(37781) + Math.cos(37782) * 48;
+acc += Math.sin(37782) + Math.cos(37783) * 49;
+acc += Math.sin(37783) + Math.cos(37784) * 50;
+acc += Math.sin(37784) + Math.cos(37785) * 51;
+acc += Math.sin(37785) + Math.cos(37786) * 52;
+acc += Math.sin(37786) + Math.cos(37787) * 53;
+acc += Math.sin(37787) + Math.cos(37788) * 54;
+acc += Math.sin(37788) + Math.cos(37789) * 55;
+acc += Math.sin(37789) + Math.cos(37790) * 56;
+acc += Math.sin(37790) + Math.cos(37791) * 57;
+acc += Math.sin(37791) + Math.cos(37792) * 58;
+acc += Math.sin(37792) + Math.cos(37793) * 59;
+acc += Math.sin(37793) + Math.cos(37794) * 60;
+acc += Math.sin(37794) + Math.cos(37795) * 61;
+acc += Math.sin(37795) + Math.cos(37796) * 62;
+acc += Math.sin(37796) + Math.cos(37797) * 63;
+acc += Math.sin(37797) + Math.cos(37798) * 64;
+acc += Math.sin(37798) + Math.cos(37799) * 65;
+acc += Math.sin(37799) + Math.cos(37800) * 66;
+acc += Math.sin(37800) + Math.cos(37801) * 67;
+acc += Math.sin(37801) + Math.cos(37802) * 68;
+acc += Math.sin(37802) + Math.cos(37803) * 69;
+acc += Math.sin(37803) + Math.cos(37804) * 70;
+acc += Math.sin(37804) + Math.cos(37805) * 71;
+acc += Math.sin(37805) + Math.cos(37806) * 72;
+acc += Math.sin(37806) + Math.cos(37807) * 73;
+acc += Math.sin(37807) + Math.cos(37808) * 74;
+acc += Math.sin(37808) + Math.cos(37809) * 75;
+acc += Math.sin(37809) + Math.cos(37810) * 76;
+acc += Math.sin(37810) + Math.cos(37811) * 77;
+acc += Math.sin(37811) + Math.cos(37812) * 78;
+acc += Math.sin(37812) + Math.cos(37813) * 79;
+acc += Math.sin(37813) + Math.cos(37814) * 80;
+acc += Math.sin(37814) + Math.cos(37815) * 81;
+acc += Math.sin(37815) + Math.cos(37816) * 82;
+acc += Math.sin(37816) + Math.cos(37817) * 83;
+acc += Math.sin(37817) + Math.cos(37818) * 84;
+acc += Math.sin(37818) + Math.cos(37819) * 85;
+acc += Math.sin(37819) + Math.cos(37820) * 86;
+acc += Math.sin(37820) + Math.cos(37821) * 87;
+acc += Math.sin(37821) + Math.cos(37822) * 88;
+acc += Math.sin(37822) + Math.cos(37823) * 89;
+acc += Math.sin(37823) + Math.cos(37824) * 90;
+acc += Math.sin(37824) + Math.cos(37825) * 91;
+acc += Math.sin(37825) + Math.cos(37826) * 92;
+acc += Math.sin(37826) + Math.cos(37827) * 93;
+acc += Math.sin(37827) + Math.cos(37828) * 94;
+acc += Math.sin(37828) + Math.cos(37829) * 95;
+acc += Math.sin(37829) + Math.cos(37830) * 96;
+acc += Math.sin(37830) + Math.cos(37831) * 0;
+acc += Math.sin(37831) + Math.cos(37832) * 1;
+acc += Math.sin(37832) + Math.cos(37833) * 2;
+acc += Math.sin(37833) + Math.cos(37834) * 3;
+acc += Math.sin(37834) + Math.cos(37835) * 4;
+acc += Math.sin(37835) + Math.cos(37836) * 5;
+acc += Math.sin(37836) + Math.cos(37837) * 6;
+acc += Math.sin(37837) + Math.cos(37838) * 7;
+acc += Math.sin(37838) + Math.cos(37839) * 8;
+acc += Math.sin(37839) + Math.cos(37840) * 9;
+acc += Math.sin(37840) + Math.cos(37841) * 10;
+acc += Math.sin(37841) + Math.cos(37842) * 11;
+acc += Math.sin(37842) + Math.cos(37843) * 12;
+acc += Math.sin(37843) + Math.cos(37844) * 13;
+acc += Math.sin(37844) + Math.cos(37845) * 14;
+acc += Math.sin(37845) + Math.cos(37846) * 15;
+acc += Math.sin(37846) + Math.cos(37847) * 16;
+acc += Math.sin(37847) + Math.cos(37848) * 17;
+acc += Math.sin(37848) + Math.cos(37849) * 18;
+acc += Math.sin(37849) + Math.cos(37850) * 19;
+acc += Math.sin(37850) + Math.cos(37851) * 20;
+acc += Math.sin(37851) + Math.cos(37852) * 21;
+acc += Math.sin(37852) + Math.cos(37853) * 22;
+acc += Math.sin(37853) + Math.cos(37854) * 23;
+acc += Math.sin(37854) + Math.cos(37855) * 24;
+acc += Math.sin(37855) + Math.cos(37856) * 25;
+acc += Math.sin(37856) + Math.cos(37857) * 26;
+acc += Math.sin(37857) + Math.cos(37858) * 27;
+acc += Math.sin(37858) + Math.cos(37859) * 28;
+acc += Math.sin(37859) + Math.cos(37860) * 29;
+acc += Math.sin(37860) + Math.cos(37861) * 30;
+acc += Math.sin(37861) + Math.cos(37862) * 31;
+acc += Math.sin(37862) + Math.cos(37863) * 32;
+acc += Math.sin(37863) + Math.cos(37864) * 33;
+acc += Math.sin(37864) + Math.cos(37865) * 34;
+acc += Math.sin(37865) + Math.cos(37866) * 35;
+acc += Math.sin(37866) + Math.cos(37867) * 36;
+acc += Math.sin(37867) + Math.cos(37868) * 37;
+acc += Math.sin(37868) + Math.cos(37869) * 38;
+acc += Math.sin(37869) + Math.cos(37870) * 39;
+acc += Math.sin(37870) + Math.cos(37871) * 40;
+acc += Math.sin(37871) + Math.cos(37872) * 41;
+acc += Math.sin(37872) + Math.cos(37873) * 42;
+acc += Math.sin(37873) + Math.cos(37874) * 43;
+acc += Math.sin(37874) + Math.cos(37875) * 44;
+acc += Math.sin(37875) + Math.cos(37876) * 45;
+acc += Math.sin(37876) + Math.cos(37877) * 46;
+acc += Math.sin(37877) + Math.cos(37878) * 47;
+acc += Math.sin(37878) + Math.cos(37879) * 48;
+acc += Math.sin(37879) + Math.cos(37880) * 49;
+acc += Math.sin(37880) + Math.cos(37881) * 50;
+acc += Math.sin(37881) + Math.cos(37882) * 51;
+acc += Math.sin(37882) + Math.cos(37883) * 52;
+acc += Math.sin(37883) + Math.cos(37884) * 53;
+acc += Math.sin(37884) + Math.cos(37885) * 54;
+acc += Math.sin(37885) + Math.cos(37886) * 55;
+acc += Math.sin(37886) + Math.cos(37887) * 56;
+acc += Math.sin(37887) + Math.cos(37888) * 57;
+acc += Math.sin(37888) + Math.cos(37889) * 58;
+acc += Math.sin(37889) + Math.cos(37890) * 59;
+acc += Math.sin(37890) + Math.cos(37891) * 60;
+acc += Math.sin(37891) + Math.cos(37892) * 61;
+acc += Math.sin(37892) + Math.cos(37893) * 62;
+acc += Math.sin(37893) + Math.cos(37894) * 63;
+acc += Math.sin(37894) + Math.cos(37895) * 64;
+acc += Math.sin(37895) + Math.cos(37896) * 65;
+acc += Math.sin(37896) + Math.cos(37897) * 66;
+acc += Math.sin(37897) + Math.cos(37898) * 67;
+acc += Math.sin(37898) + Math.cos(37899) * 68;
+acc += Math.sin(37899) + Math.cos(37900) * 69;
+acc += Math.sin(37900) + Math.cos(37901) * 70;
+acc += Math.sin(37901) + Math.cos(37902) * 71;
+acc += Math.sin(37902) + Math.cos(37903) * 72;
+acc += Math.sin(37903) + Math.cos(37904) * 73;
+acc += Math.sin(37904) + Math.cos(37905) * 74;
+acc += Math.sin(37905) + Math.cos(37906) * 75;
+acc += Math.sin(37906) + Math.cos(37907) * 76;
+acc += Math.sin(37907) + Math.cos(37908) * 77;
+acc += Math.sin(37908) + Math.cos(37909) * 78;
+acc += Math.sin(37909) + Math.cos(37910) * 79;
+acc += Math.sin(37910) + Math.cos(37911) * 80;
+acc += Math.sin(37911) + Math.cos(37912) * 81;
+acc += Math.sin(37912) + Math.cos(37913) * 82;
+acc += Math.sin(37913) + Math.cos(37914) * 83;
+acc += Math.sin(37914) + Math.cos(37915) * 84;
+acc += Math.sin(37915) + Math.cos(37916) * 85;
+acc += Math.sin(37916) + Math.cos(37917) * 86;
+acc += Math.sin(37917) + Math.cos(37918) * 87;
+acc += Math.sin(37918) + Math.cos(37919) * 88;
+acc += Math.sin(37919) + Math.cos(37920) * 89;
+acc += Math.sin(37920) + Math.cos(37921) * 90;
+acc += Math.sin(37921) + Math.cos(37922) * 91;
+acc += Math.sin(37922) + Math.cos(37923) * 92;
+acc += Math.sin(37923) + Math.cos(37924) * 93;
+acc += Math.sin(37924) + Math.cos(37925) * 94;
+acc += Math.sin(37925) + Math.cos(37926) * 95;
+acc += Math.sin(37926) + Math.cos(37927) * 96;
+acc += Math.sin(37927) + Math.cos(37928) * 0;
+acc += Math.sin(37928) + Math.cos(37929) * 1;
+acc += Math.sin(37929) + Math.cos(37930) * 2;
+acc += Math.sin(37930) + Math.cos(37931) * 3;
+acc += Math.sin(37931) + Math.cos(37932) * 4;
+acc += Math.sin(37932) + Math.cos(37933) * 5;
+acc += Math.sin(37933) + Math.cos(37934) * 6;
+acc += Math.sin(37934) + Math.cos(37935) * 7;
+acc += Math.sin(37935) + Math.cos(37936) * 8;
+acc += Math.sin(37936) + Math.cos(37937) * 9;
+acc += Math.sin(37937) + Math.cos(37938) * 10;
+acc += Math.sin(37938) + Math.cos(37939) * 11;
+acc += Math.sin(37939) + Math.cos(37940) * 12;
+acc += Math.sin(37940) + Math.cos(37941) * 13;
+acc += Math.sin(37941) + Math.cos(37942) * 14;
+acc += Math.sin(37942) + Math.cos(37943) * 15;
+acc += Math.sin(37943) + Math.cos(37944) * 16;
+acc += Math.sin(37944) + Math.cos(37945) * 17;
+acc += Math.sin(37945) + Math.cos(37946) * 18;
+acc += Math.sin(37946) + Math.cos(37947) * 19;
+acc += Math.sin(37947) + Math.cos(37948) * 20;
+acc += Math.sin(37948) + Math.cos(37949) * 21;
+acc += Math.sin(37949) + Math.cos(37950) * 22;
+acc += Math.sin(37950) + Math.cos(37951) * 23;
+acc += Math.sin(37951) + Math.cos(37952) * 24;
+acc += Math.sin(37952) + Math.cos(37953) * 25;
+acc += Math.sin(37953) + Math.cos(37954) * 26;
+acc += Math.sin(37954) + Math.cos(37955) * 27;
+acc += Math.sin(37955) + Math.cos(37956) * 28;
+acc += Math.sin(37956) + Math.cos(37957) * 29;
+acc += Math.sin(37957) + Math.cos(37958) * 30;
+acc += Math.sin(37958) + Math.cos(37959) * 31;
+acc += Math.sin(37959) + Math.cos(37960) * 32;
+acc += Math.sin(37960) + Math.cos(37961) * 33;
+acc += Math.sin(37961) + Math.cos(37962) * 34;
+acc += Math.sin(37962) + Math.cos(37963) * 35;
+acc += Math.sin(37963) + Math.cos(37964) * 36;
+acc += Math.sin(37964) + Math.cos(37965) * 37;
+acc += Math.sin(37965) + Math.cos(37966) * 38;
+acc += Math.sin(37966) + Math.cos(37967) * 39;
+acc += Math.sin(37967) + Math.cos(37968) * 40;
+acc += Math.sin(37968) + Math.cos(37969) * 41;
+acc += Math.sin(37969) + Math.cos(37970) * 42;
+acc += Math.sin(37970) + Math.cos(37971) * 43;
+acc += Math.sin(37971) + Math.cos(37972) * 44;
+acc += Math.sin(37972) + Math.cos(37973) * 45;
+acc += Math.sin(37973) + Math.cos(37974) * 46;
+acc += Math.sin(37974) + Math.cos(37975) * 47;
+acc += Math.sin(37975) + Math.cos(37976) * 48;
+acc += Math.sin(37976) + Math.cos(37977) * 49;
+acc += Math.sin(37977) + Math.cos(37978) * 50;
+acc += Math.sin(37978) + Math.cos(37979) * 51;
+acc += Math.sin(37979) + Math.cos(37980) * 52;
+acc += Math.sin(37980) + Math.cos(37981) * 53;
+acc += Math.sin(37981) + Math.cos(37982) * 54;
+acc += Math.sin(37982) + Math.cos(37983) * 55;
+acc += Math.sin(37983) + Math.cos(37984) * 56;
+acc += Math.sin(37984) + Math.cos(37985) * 57;
+acc += Math.sin(37985) + Math.cos(37986) * 58;
+acc += Math.sin(37986) + Math.cos(37987) * 59;
+acc += Math.sin(37987) + Math.cos(37988) * 60;
+acc += Math.sin(37988) + Math.cos(37989) * 61;
+acc += Math.sin(37989) + Math.cos(37990) * 62;
+acc += Math.sin(37990) + Math.cos(37991) * 63;
+acc += Math.sin(37991) + Math.cos(37992) * 64;
+acc += Math.sin(37992) + Math.cos(37993) * 65;
+acc += Math.sin(37993) + Math.cos(37994) * 66;
+acc += Math.sin(37994) + Math.cos(37995) * 67;
+acc += Math.sin(37995) + Math.cos(37996) * 68;
+acc += Math.sin(37996) + Math.cos(37997) * 69;
+acc += Math.sin(37997) + Math.cos(37998) * 70;
+acc += Math.sin(37998) + Math.cos(37999) * 71;
+acc += Math.sin(37999) + Math.cos(38000) * 72;
+acc += Math.sin(38000) + Math.cos(38001) * 73;
+acc += Math.sin(38001) + Math.cos(38002) * 74;
+acc += Math.sin(38002) + Math.cos(38003) * 75;
+acc += Math.sin(38003) + Math.cos(38004) * 76;
+acc += Math.sin(38004) + Math.cos(38005) * 77;
+acc += Math.sin(38005) + Math.cos(38006) * 78;
+acc += Math.sin(38006) + Math.cos(38007) * 79;
+acc += Math.sin(38007) + Math.cos(38008) * 80;
+acc += Math.sin(38008) + Math.cos(38009) * 81;
+acc += Math.sin(38009) + Math.cos(38010) * 82;
+acc += Math.sin(38010) + Math.cos(38011) * 83;
+acc += Math.sin(38011) + Math.cos(38012) * 84;
+acc += Math.sin(38012) + Math.cos(38013) * 85;
+acc += Math.sin(38013) + Math.cos(38014) * 86;
+acc += Math.sin(38014) + Math.cos(38015) * 87;
+acc += Math.sin(38015) + Math.cos(38016) * 88;
+acc += Math.sin(38016) + Math.cos(38017) * 89;
+acc += Math.sin(38017) + Math.cos(38018) * 90;
+acc += Math.sin(38018) + Math.cos(38019) * 91;
+acc += Math.sin(38019) + Math.cos(38020) * 92;
+acc += Math.sin(38020) + Math.cos(38021) * 93;
+acc += Math.sin(38021) + Math.cos(38022) * 94;
+acc += Math.sin(38022) + Math.cos(38023) * 95;
+acc += Math.sin(38023) + Math.cos(38024) * 96;
+acc += Math.sin(38024) + Math.cos(38025) * 0;
+acc += Math.sin(38025) + Math.cos(38026) * 1;
+acc += Math.sin(38026) + Math.cos(38027) * 2;
+acc += Math.sin(38027) + Math.cos(38028) * 3;
+acc += Math.sin(38028) + Math.cos(38029) * 4;
+acc += Math.sin(38029) + Math.cos(38030) * 5;
+acc += Math.sin(38030) + Math.cos(38031) * 6;
+acc += Math.sin(38031) + Math.cos(38032) * 7;
+acc += Math.sin(38032) + Math.cos(38033) * 8;
+acc += Math.sin(38033) + Math.cos(38034) * 9;
+acc += Math.sin(38034) + Math.cos(38035) * 10;
+acc += Math.sin(38035) + Math.cos(38036) * 11;
+acc += Math.sin(38036) + Math.cos(38037) * 12;
+acc += Math.sin(38037) + Math.cos(38038) * 13;
+acc += Math.sin(38038) + Math.cos(38039) * 14;
+acc += Math.sin(38039) + Math.cos(38040) * 15;
+acc += Math.sin(38040) + Math.cos(38041) * 16;
+acc += Math.sin(38041) + Math.cos(38042) * 17;
+acc += Math.sin(38042) + Math.cos(38043) * 18;
+acc += Math.sin(38043) + Math.cos(38044) * 19;
+acc += Math.sin(38044) + Math.cos(38045) * 20;
+acc += Math.sin(38045) + Math.cos(38046) * 21;
+acc += Math.sin(38046) + Math.cos(38047) * 22;
+acc += Math.sin(38047) + Math.cos(38048) * 23;
+acc += Math.sin(38048) + Math.cos(38049) * 24;
+acc += Math.sin(38049) + Math.cos(38050) * 25;
+acc += Math.sin(38050) + Math.cos(38051) * 26;
+acc += Math.sin(38051) + Math.cos(38052) * 27;
+acc += Math.sin(38052) + Math.cos(38053) * 28;
+acc += Math.sin(38053) + Math.cos(38054) * 29;
+acc += Math.sin(38054) + Math.cos(38055) * 30;
+acc += Math.sin(38055) + Math.cos(38056) * 31;
+acc += Math.sin(38056) + Math.cos(38057) * 32;
+acc += Math.sin(38057) + Math.cos(38058) * 33;
+acc += Math.sin(38058) + Math.cos(38059) * 34;
+acc += Math.sin(38059) + Math.cos(38060) * 35;
+acc += Math.sin(38060) + Math.cos(38061) * 36;
+acc += Math.sin(38061) + Math.cos(38062) * 37;
+acc += Math.sin(38062) + Math.cos(38063) * 38;
+acc += Math.sin(38063) + Math.cos(38064) * 39;
+acc += Math.sin(38064) + Math.cos(38065) * 40;
+acc += Math.sin(38065) + Math.cos(38066) * 41;
+acc += Math.sin(38066) + Math.cos(38067) * 42;
+acc += Math.sin(38067) + Math.cos(38068) * 43;
+acc += Math.sin(38068) + Math.cos(38069) * 44;
+acc += Math.sin(38069) + Math.cos(38070) * 45;
+acc += Math.sin(38070) + Math.cos(38071) * 46;
+acc += Math.sin(38071) + Math.cos(38072) * 47;
+acc += Math.sin(38072) + Math.cos(38073) * 48;
+acc += Math.sin(38073) + Math.cos(38074) * 49;
+acc += Math.sin(38074) + Math.cos(38075) * 50;
+acc += Math.sin(38075) + Math.cos(38076) * 51;
+acc += Math.sin(38076) + Math.cos(38077) * 52;
+acc += Math.sin(38077) + Math.cos(38078) * 53;
+acc += Math.sin(38078) + Math.cos(38079) * 54;
+acc += Math.sin(38079) + Math.cos(38080) * 55;
+acc += Math.sin(38080) + Math.cos(38081) * 56;
+acc += Math.sin(38081) + Math.cos(38082) * 57;
+acc += Math.sin(38082) + Math.cos(38083) * 58;
+acc += Math.sin(38083) + Math.cos(38084) * 59;
+acc += Math.sin(38084) + Math.cos(38085) * 60;
+acc += Math.sin(38085) + Math.cos(38086) * 61;
+acc += Math.sin(38086) + Math.cos(38087) * 62;
+acc += Math.sin(38087) + Math.cos(38088) * 63;
+acc += Math.sin(38088) + Math.cos(38089) * 64;
+acc += Math.sin(38089) + Math.cos(38090) * 65;
+acc += Math.sin(38090) + Math.cos(38091) * 66;
+acc += Math.sin(38091) + Math.cos(38092) * 67;
+acc += Math.sin(38092) + Math.cos(38093) * 68;
+acc += Math.sin(38093) + Math.cos(38094) * 69;
+acc += Math.sin(38094) + Math.cos(38095) * 70;
+acc += Math.sin(38095) + Math.cos(38096) * 71;
+acc += Math.sin(38096) + Math.cos(38097) * 72;
+acc += Math.sin(38097) + Math.cos(38098) * 73;
+acc += Math.sin(38098) + Math.cos(38099) * 74;
+acc += Math.sin(38099) + Math.cos(38100) * 75;
+acc += Math.sin(38100) + Math.cos(38101) * 76;
+acc += Math.sin(38101) + Math.cos(38102) * 77;
+acc += Math.sin(38102) + Math.cos(38103) * 78;
+acc += Math.sin(38103) + Math.cos(38104) * 79;
+acc += Math.sin(38104) + Math.cos(38105) * 80;
+acc += Math.sin(38105) + Math.cos(38106) * 81;
+acc += Math.sin(38106) + Math.cos(38107) * 82;
+acc += Math.sin(38107) + Math.cos(38108) * 83;
+acc += Math.sin(38108) + Math.cos(38109) * 84;
+acc += Math.sin(38109) + Math.cos(38110) * 85;
+acc += Math.sin(38110) + Math.cos(38111) * 86;
+acc += Math.sin(38111) + Math.cos(38112) * 87;
+acc += Math.sin(38112) + Math.cos(38113) * 88;
+acc += Math.sin(38113) + Math.cos(38114) * 89;
+acc += Math.sin(38114) + Math.cos(38115) * 90;
+acc += Math.sin(38115) + Math.cos(38116) * 91;
+acc += Math.sin(38116) + Math.cos(38117) * 92;
+acc += Math.sin(38117) + Math.cos(38118) * 93;
+acc += Math.sin(38118) + Math.cos(38119) * 94;
+acc += Math.sin(38119) + Math.cos(38120) * 95;
+acc += Math.sin(38120) + Math.cos(38121) * 96;
+acc += Math.sin(38121) + Math.cos(38122) * 0;
+acc += Math.sin(38122) + Math.cos(38123) * 1;
+acc += Math.sin(38123) + Math.cos(38124) * 2;
+acc += Math.sin(38124) + Math.cos(38125) * 3;
+acc += Math.sin(38125) + Math.cos(38126) * 4;
+acc += Math.sin(38126) + Math.cos(38127) * 5;
+acc += Math.sin(38127) + Math.cos(38128) * 6;
+acc += Math.sin(38128) + Math.cos(38129) * 7;
+acc += Math.sin(38129) + Math.cos(38130) * 8;
+acc += Math.sin(38130) + Math.cos(38131) * 9;
+acc += Math.sin(38131) + Math.cos(38132) * 10;
+acc += Math.sin(38132) + Math.cos(38133) * 11;
+acc += Math.sin(38133) + Math.cos(38134) * 12;
+acc += Math.sin(38134) + Math.cos(38135) * 13;
+acc += Math.sin(38135) + Math.cos(38136) * 14;
+acc += Math.sin(38136) + Math.cos(38137) * 15;
+acc += Math.sin(38137) + Math.cos(38138) * 16;
+acc += Math.sin(38138) + Math.cos(38139) * 17;
+acc += Math.sin(38139) + Math.cos(38140) * 18;
+acc += Math.sin(38140) + Math.cos(38141) * 19;
+acc += Math.sin(38141) + Math.cos(38142) * 20;
+acc += Math.sin(38142) + Math.cos(38143) * 21;
+acc += Math.sin(38143) + Math.cos(38144) * 22;
+acc += Math.sin(38144) + Math.cos(38145) * 23;
+acc += Math.sin(38145) + Math.cos(38146) * 24;
+acc += Math.sin(38146) + Math.cos(38147) * 25;
+acc += Math.sin(38147) + Math.cos(38148) * 26;
+acc += Math.sin(38148) + Math.cos(38149) * 27;
+acc += Math.sin(38149) + Math.cos(38150) * 28;
+acc += Math.sin(38150) + Math.cos(38151) * 29;
+acc += Math.sin(38151) + Math.cos(38152) * 30;
+acc += Math.sin(38152) + Math.cos(38153) * 31;
+acc += Math.sin(38153) + Math.cos(38154) * 32;
+acc += Math.sin(38154) + Math.cos(38155) * 33;
+acc += Math.sin(38155) + Math.cos(38156) * 34;
+acc += Math.sin(38156) + Math.cos(38157) * 35;
+acc += Math.sin(38157) + Math.cos(38158) * 36;
+acc += Math.sin(38158) + Math.cos(38159) * 37;
+acc += Math.sin(38159) + Math.cos(38160) * 38;
+acc += Math.sin(38160) + Math.cos(38161) * 39;
+acc += Math.sin(38161) + Math.cos(38162) * 40;
+acc += Math.sin(38162) + Math.cos(38163) * 41;
+acc += Math.sin(38163) + Math.cos(38164) * 42;
+acc += Math.sin(38164) + Math.cos(38165) * 43;
+acc += Math.sin(38165) + Math.cos(38166) * 44;
+acc += Math.sin(38166) + Math.cos(38167) * 45;
+acc += Math.sin(38167) + Math.cos(38168) * 46;
+acc += Math.sin(38168) + Math.cos(38169) * 47;
+acc += Math.sin(38169) + Math.cos(38170) * 48;
+acc += Math.sin(38170) + Math.cos(38171) * 49;
+acc += Math.sin(38171) + Math.cos(38172) * 50;
+acc += Math.sin(38172) + Math.cos(38173) * 51;
+acc += Math.sin(38173) + Math.cos(38174) * 52;
+acc += Math.sin(38174) + Math.cos(38175) * 53;
+acc += Math.sin(38175) + Math.cos(38176) * 54;
+acc += Math.sin(38176) + Math.cos(38177) * 55;
+acc += Math.sin(38177) + Math.cos(38178) * 56;
+acc += Math.sin(38178) + Math.cos(38179) * 57;
+acc += Math.sin(38179) + Math.cos(38180) * 58;
+acc += Math.sin(38180) + Math.cos(38181) * 59;
+acc += Math.sin(38181) + Math.cos(38182) * 60;
+acc += Math.sin(38182) + Math.cos(38183) * 61;
+acc += Math.sin(38183) + Math.cos(38184) * 62;
+acc += Math.sin(38184) + Math.cos(38185) * 63;
+acc += Math.sin(38185) + Math.cos(38186) * 64;
+acc += Math.sin(38186) + Math.cos(38187) * 65;
+acc += Math.sin(38187) + Math.cos(38188) * 66;
+acc += Math.sin(38188) + Math.cos(38189) * 67;
+acc += Math.sin(38189) + Math.cos(38190) * 68;
+acc += Math.sin(38190) + Math.cos(38191) * 69;
+acc += Math.sin(38191) + Math.cos(38192) * 70;
+acc += Math.sin(38192) + Math.cos(38193) * 71;
+acc += Math.sin(38193) + Math.cos(38194) * 72;
+acc += Math.sin(38194) + Math.cos(38195) * 73;
+acc += Math.sin(38195) + Math.cos(38196) * 74;
+acc += Math.sin(38196) + Math.cos(38197) * 75;
+acc += Math.sin(38197) + Math.cos(38198) * 76;
+acc += Math.sin(38198) + Math.cos(38199) * 77;
+acc += Math.sin(38199) + Math.cos(38200) * 78;
+acc += Math.sin(38200) + Math.cos(38201) * 79;
+acc += Math.sin(38201) + Math.cos(38202) * 80;
+acc += Math.sin(38202) + Math.cos(38203) * 81;
+acc += Math.sin(38203) + Math.cos(38204) * 82;
+acc += Math.sin(38204) + Math.cos(38205) * 83;
+acc += Math.sin(38205) + Math.cos(38206) * 84;
+acc += Math.sin(38206) + Math.cos(38207) * 85;
+acc += Math.sin(38207) + Math.cos(38208) * 86;
+acc += Math.sin(38208) + Math.cos(38209) * 87;
+acc += Math.sin(38209) + Math.cos(38210) * 88;
+acc += Math.sin(38210) + Math.cos(38211) * 89;
+acc += Math.sin(38211) + Math.cos(38212) * 90;
+acc += Math.sin(38212) + Math.cos(38213) * 91;
+acc += Math.sin(38213) + Math.cos(38214) * 92;
+acc += Math.sin(38214) + Math.cos(38215) * 93;
+acc += Math.sin(38215) + Math.cos(38216) * 94;
+acc += Math.sin(38216) + Math.cos(38217) * 95;
+acc += Math.sin(38217) + Math.cos(38218) * 96;
+acc += Math.sin(38218) + Math.cos(38219) * 0;
+acc += Math.sin(38219) + Math.cos(38220) * 1;
+acc += Math.sin(38220) + Math.cos(38221) * 2;
+acc += Math.sin(38221) + Math.cos(38222) * 3;
+acc += Math.sin(38222) + Math.cos(38223) * 4;
+acc += Math.sin(38223) + Math.cos(38224) * 5;
+acc += Math.sin(38224) + Math.cos(38225) * 6;
+acc += Math.sin(38225) + Math.cos(38226) * 7;
+acc += Math.sin(38226) + Math.cos(38227) * 8;
+acc += Math.sin(38227) + Math.cos(38228) * 9;
+acc += Math.sin(38228) + Math.cos(38229) * 10;
+acc += Math.sin(38229) + Math.cos(38230) * 11;
+acc += Math.sin(38230) + Math.cos(38231) * 12;
+acc += Math.sin(38231) + Math.cos(38232) * 13;
+acc += Math.sin(38232) + Math.cos(38233) * 14;
+acc += Math.sin(38233) + Math.cos(38234) * 15;
+acc += Math.sin(38234) + Math.cos(38235) * 16;
+acc += Math.sin(38235) + Math.cos(38236) * 17;
+acc += Math.sin(38236) + Math.cos(38237) * 18;
+acc += Math.sin(38237) + Math.cos(38238) * 19;
+acc += Math.sin(38238) + Math.cos(38239) * 20;
+acc += Math.sin(38239) + Math.cos(38240) * 21;
+acc += Math.sin(38240) + Math.cos(38241) * 22;
+acc += Math.sin(38241) + Math.cos(38242) * 23;
+acc += Math.sin(38242) + Math.cos(38243) * 24;
+acc += Math.sin(38243) + Math.cos(38244) * 25;
+acc += Math.sin(38244) + Math.cos(38245) * 26;
+acc += Math.sin(38245) + Math.cos(38246) * 27;
+acc += Math.sin(38246) + Math.cos(38247) * 28;
+acc += Math.sin(38247) + Math.cos(38248) * 29;
+acc += Math.sin(38248) + Math.cos(38249) * 30;
+acc += Math.sin(38249) + Math.cos(38250) * 31;
+acc += Math.sin(38250) + Math.cos(38251) * 32;
+acc += Math.sin(38251) + Math.cos(38252) * 33;
+acc += Math.sin(38252) + Math.cos(38253) * 34;
+acc += Math.sin(38253) + Math.cos(38254) * 35;
+acc += Math.sin(38254) + Math.cos(38255) * 36;
+acc += Math.sin(38255) + Math.cos(38256) * 37;
+acc += Math.sin(38256) + Math.cos(38257) * 38;
+acc += Math.sin(38257) + Math.cos(38258) * 39;
+acc += Math.sin(38258) + Math.cos(38259) * 40;
+acc += Math.sin(38259) + Math.cos(38260) * 41;
+acc += Math.sin(38260) + Math.cos(38261) * 42;
+acc += Math.sin(38261) + Math.cos(38262) * 43;
+acc += Math.sin(38262) + Math.cos(38263) * 44;
+acc += Math.sin(38263) + Math.cos(38264) * 45;
+acc += Math.sin(38264) + Math.cos(38265) * 46;
+acc += Math.sin(38265) + Math.cos(38266) * 47;
+acc += Math.sin(38266) + Math.cos(38267) * 48;
+acc += Math.sin(38267) + Math.cos(38268) * 49;
+acc += Math.sin(38268) + Math.cos(38269) * 50;
+acc += Math.sin(38269) + Math.cos(38270) * 51;
+acc += Math.sin(38270) + Math.cos(38271) * 52;
+acc += Math.sin(38271) + Math.cos(38272) * 53;
+acc += Math.sin(38272) + Math.cos(38273) * 54;
+acc += Math.sin(38273) + Math.cos(38274) * 55;
+acc += Math.sin(38274) + Math.cos(38275) * 56;
+acc += Math.sin(38275) + Math.cos(38276) * 57;
+acc += Math.sin(38276) + Math.cos(38277) * 58;
+acc += Math.sin(38277) + Math.cos(38278) * 59;
+acc += Math.sin(38278) + Math.cos(38279) * 60;
+acc += Math.sin(38279) + Math.cos(38280) * 61;
+acc += Math.sin(38280) + Math.cos(38281) * 62;
+acc += Math.sin(38281) + Math.cos(38282) * 63;
+acc += Math.sin(38282) + Math.cos(38283) * 64;
+acc += Math.sin(38283) + Math.cos(38284) * 65;
+acc += Math.sin(38284) + Math.cos(38285) * 66;
+acc += Math.sin(38285) + Math.cos(38286) * 67;
+acc += Math.sin(38286) + Math.cos(38287) * 68;
+acc += Math.sin(38287) + Math.cos(38288) * 69;
+acc += Math.sin(38288) + Math.cos(38289) * 70;
+acc += Math.sin(38289) + Math.cos(38290) * 71;
+acc += Math.sin(38290) + Math.cos(38291) * 72;
+acc += Math.sin(38291) + Math.cos(38292) * 73;
+acc += Math.sin(38292) + Math.cos(38293) * 74;
+acc += Math.sin(38293) + Math.cos(38294) * 75;
+acc += Math.sin(38294) + Math.cos(38295) * 76;
+acc += Math.sin(38295) + Math.cos(38296) * 77;
+acc += Math.sin(38296) + Math.cos(38297) * 78;
+acc += Math.sin(38297) + Math.cos(38298) * 79;
+acc += Math.sin(38298) + Math.cos(38299) * 80;
+acc += Math.sin(38299) + Math.cos(38300) * 81;
+acc += Math.sin(38300) + Math.cos(38301) * 82;
+acc += Math.sin(38301) + Math.cos(38302) * 83;
+acc += Math.sin(38302) + Math.cos(38303) * 84;
+acc += Math.sin(38303) + Math.cos(38304) * 85;
+acc += Math.sin(38304) + Math.cos(38305) * 86;
+acc += Math.sin(38305) + Math.cos(38306) * 87;
+acc += Math.sin(38306) + Math.cos(38307) * 88;
+acc += Math.sin(38307) + Math.cos(38308) * 89;
+acc += Math.sin(38308) + Math.cos(38309) * 90;
+acc += Math.sin(38309) + Math.cos(38310) * 91;
+acc += Math.sin(38310) + Math.cos(38311) * 92;
+acc += Math.sin(38311) + Math.cos(38312) * 93;
+acc += Math.sin(38312) + Math.cos(38313) * 94;
+acc += Math.sin(38313) + Math.cos(38314) * 95;
+acc += Math.sin(38314) + Math.cos(38315) * 96;
+acc += Math.sin(38315) + Math.cos(38316) * 0;
+acc += Math.sin(38316) + Math.cos(38317) * 1;
+acc += Math.sin(38317) + Math.cos(38318) * 2;
+acc += Math.sin(38318) + Math.cos(38319) * 3;
+acc += Math.sin(38319) + Math.cos(38320) * 4;
+acc += Math.sin(38320) + Math.cos(38321) * 5;
+acc += Math.sin(38321) + Math.cos(38322) * 6;
+acc += Math.sin(38322) + Math.cos(38323) * 7;
+acc += Math.sin(38323) + Math.cos(38324) * 8;
+acc += Math.sin(38324) + Math.cos(38325) * 9;
+acc += Math.sin(38325) + Math.cos(38326) * 10;
+acc += Math.sin(38326) + Math.cos(38327) * 11;
+acc += Math.sin(38327) + Math.cos(38328) * 12;
+acc += Math.sin(38328) + Math.cos(38329) * 13;
+acc += Math.sin(38329) + Math.cos(38330) * 14;
+acc += Math.sin(38330) + Math.cos(38331) * 15;
+acc += Math.sin(38331) + Math.cos(38332) * 16;
+acc += Math.sin(38332) + Math.cos(38333) * 17;
+acc += Math.sin(38333) + Math.cos(38334) * 18;
+acc += Math.sin(38334) + Math.cos(38335) * 19;
+acc += Math.sin(38335) + Math.cos(38336) * 20;
+acc += Math.sin(38336) + Math.cos(38337) * 21;
+acc += Math.sin(38337) + Math.cos(38338) * 22;
+acc += Math.sin(38338) + Math.cos(38339) * 23;
+acc += Math.sin(38339) + Math.cos(38340) * 24;
+acc += Math.sin(38340) + Math.cos(38341) * 25;
+acc += Math.sin(38341) + Math.cos(38342) * 26;
+acc += Math.sin(38342) + Math.cos(38343) * 27;
+acc += Math.sin(38343) + Math.cos(38344) * 28;
+acc += Math.sin(38344) + Math.cos(38345) * 29;
+acc += Math.sin(38345) + Math.cos(38346) * 30;
+acc += Math.sin(38346) + Math.cos(38347) * 31;
+acc += Math.sin(38347) + Math.cos(38348) * 32;
+acc += Math.sin(38348) + Math.cos(38349) * 33;
+acc += Math.sin(38349) + Math.cos(38350) * 34;
+acc += Math.sin(38350) + Math.cos(38351) * 35;
+acc += Math.sin(38351) + Math.cos(38352) * 36;
+acc += Math.sin(38352) + Math.cos(38353) * 37;
+acc += Math.sin(38353) + Math.cos(38354) * 38;
+acc += Math.sin(38354) + Math.cos(38355) * 39;
+acc += Math.sin(38355) + Math.cos(38356) * 40;
+acc += Math.sin(38356) + Math.cos(38357) * 41;
+acc += Math.sin(38357) + Math.cos(38358) * 42;
+acc += Math.sin(38358) + Math.cos(38359) * 43;
+acc += Math.sin(38359) + Math.cos(38360) * 44;
+acc += Math.sin(38360) + Math.cos(38361) * 45;
+acc += Math.sin(38361) + Math.cos(38362) * 46;
+acc += Math.sin(38362) + Math.cos(38363) * 47;
+acc += Math.sin(38363) + Math.cos(38364) * 48;
+acc += Math.sin(38364) + Math.cos(38365) * 49;
+acc += Math.sin(38365) + Math.cos(38366) * 50;
+acc += Math.sin(38366) + Math.cos(38367) * 51;
+acc += Math.sin(38367) + Math.cos(38368) * 52;
+acc += Math.sin(38368) + Math.cos(38369) * 53;
+acc += Math.sin(38369) + Math.cos(38370) * 54;
+acc += Math.sin(38370) + Math.cos(38371) * 55;
+acc += Math.sin(38371) + Math.cos(38372) * 56;
+acc += Math.sin(38372) + Math.cos(38373) * 57;
+acc += Math.sin(38373) + Math.cos(38374) * 58;
+acc += Math.sin(38374) + Math.cos(38375) * 59;
+acc += Math.sin(38375) + Math.cos(38376) * 60;
+acc += Math.sin(38376) + Math.cos(38377) * 61;
+acc += Math.sin(38377) + Math.cos(38378) * 62;
+acc += Math.sin(38378) + Math.cos(38379) * 63;
+acc += Math.sin(38379) + Math.cos(38380) * 64;
+acc += Math.sin(38380) + Math.cos(38381) * 65;
+acc += Math.sin(38381) + Math.cos(38382) * 66;
+acc += Math.sin(38382) + Math.cos(38383) * 67;
+acc += Math.sin(38383) + Math.cos(38384) * 68;
+acc += Math.sin(38384) + Math.cos(38385) * 69;
+acc += Math.sin(38385) + Math.cos(38386) * 70;
+acc += Math.sin(38386) + Math.cos(38387) * 71;
+acc += Math.sin(38387) + Math.cos(38388) * 72;
+acc += Math.sin(38388) + Math.cos(38389) * 73;
+acc += Math.sin(38389) + Math.cos(38390) * 74;
+acc += Math.sin(38390) + Math.cos(38391) * 75;
+acc += Math.sin(38391) + Math.cos(38392) * 76;
+acc += Math.sin(38392) + Math.cos(38393) * 77;
+acc += Math.sin(38393) + Math.cos(38394) * 78;
+acc += Math.sin(38394) + Math.cos(38395) * 79;
+acc += Math.sin(38395) + Math.cos(38396) * 80;
+acc += Math.sin(38396) + Math.cos(38397) * 81;
+acc += Math.sin(38397) + Math.cos(38398) * 82;
+acc += Math.sin(38398) + Math.cos(38399) * 83;
+acc += Math.sin(38399) + Math.cos(38400) * 84;
+acc += Math.sin(38400) + Math.cos(38401) * 85;
+acc += Math.sin(38401) + Math.cos(38402) * 86;
+acc += Math.sin(38402) + Math.cos(38403) * 87;
+acc += Math.sin(38403) + Math.cos(38404) * 88;
+acc += Math.sin(38404) + Math.cos(38405) * 89;
+acc += Math.sin(38405) + Math.cos(38406) * 90;
+acc += Math.sin(38406) + Math.cos(38407) * 91;
+acc += Math.sin(38407) + Math.cos(38408) * 92;
+acc += Math.sin(38408) + Math.cos(38409) * 93;
+acc += Math.sin(38409) + Math.cos(38410) * 94;
+acc += Math.sin(38410) + Math.cos(38411) * 95;
+acc += Math.sin(38411) + Math.cos(38412) * 96;
+acc += Math.sin(38412) + Math.cos(38413) * 0;
+acc += Math.sin(38413) + Math.cos(38414) * 1;
+acc += Math.sin(38414) + Math.cos(38415) * 2;
+acc += Math.sin(38415) + Math.cos(38416) * 3;
+acc += Math.sin(38416) + Math.cos(38417) * 4;
+acc += Math.sin(38417) + Math.cos(38418) * 5;
+acc += Math.sin(38418) + Math.cos(38419) * 6;
+acc += Math.sin(38419) + Math.cos(38420) * 7;
+acc += Math.sin(38420) + Math.cos(38421) * 8;
+acc += Math.sin(38421) + Math.cos(38422) * 9;
+acc += Math.sin(38422) + Math.cos(38423) * 10;
+acc += Math.sin(38423) + Math.cos(38424) * 11;
+acc += Math.sin(38424) + Math.cos(38425) * 12;
+acc += Math.sin(38425) + Math.cos(38426) * 13;
+acc += Math.sin(38426) + Math.cos(38427) * 14;
+acc += Math.sin(38427) + Math.cos(38428) * 15;
+acc += Math.sin(38428) + Math.cos(38429) * 16;
+acc += Math.sin(38429) + Math.cos(38430) * 17;
+acc += Math.sin(38430) + Math.cos(38431) * 18;
+acc += Math.sin(38431) + Math.cos(38432) * 19;
+acc += Math.sin(38432) + Math.cos(38433) * 20;
+acc += Math.sin(38433) + Math.cos(38434) * 21;
+acc += Math.sin(38434) + Math.cos(38435) * 22;
+acc += Math.sin(38435) + Math.cos(38436) * 23;
+acc += Math.sin(38436) + Math.cos(38437) * 24;
+acc += Math.sin(38437) + Math.cos(38438) * 25;
+acc += Math.sin(38438) + Math.cos(38439) * 26;
+acc += Math.sin(38439) + Math.cos(38440) * 27;
+acc += Math.sin(38440) + Math.cos(38441) * 28;
+acc += Math.sin(38441) + Math.cos(38442) * 29;
+acc += Math.sin(38442) + Math.cos(38443) * 30;
+acc += Math.sin(38443) + Math.cos(38444) * 31;
+acc += Math.sin(38444) + Math.cos(38445) * 32;
+acc += Math.sin(38445) + Math.cos(38446) * 33;
+acc += Math.sin(38446) + Math.cos(38447) * 34;
+acc += Math.sin(38447) + Math.cos(38448) * 35;
+acc += Math.sin(38448) + Math.cos(38449) * 36;
+acc += Math.sin(38449) + Math.cos(38450) * 37;
+acc += Math.sin(38450) + Math.cos(38451) * 38;
+acc += Math.sin(38451) + Math.cos(38452) * 39;
+acc += Math.sin(38452) + Math.cos(38453) * 40;
+acc += Math.sin(38453) + Math.cos(38454) * 41;
+acc += Math.sin(38454) + Math.cos(38455) * 42;
+acc += Math.sin(38455) + Math.cos(38456) * 43;
+acc += Math.sin(38456) + Math.cos(38457) * 44;
+acc += Math.sin(38457) + Math.cos(38458) * 45;
+acc += Math.sin(38458) + Math.cos(38459) * 46;
+acc += Math.sin(38459) + Math.cos(38460) * 47;
+acc += Math.sin(38460) + Math.cos(38461) * 48;
+acc += Math.sin(38461) + Math.cos(38462) * 49;
+acc += Math.sin(38462) + Math.cos(38463) * 50;
+acc += Math.sin(38463) + Math.cos(38464) * 51;
+acc += Math.sin(38464) + Math.cos(38465) * 52;
+acc += Math.sin(38465) + Math.cos(38466) * 53;
+acc += Math.sin(38466) + Math.cos(38467) * 54;
+acc += Math.sin(38467) + Math.cos(38468) * 55;
+acc += Math.sin(38468) + Math.cos(38469) * 56;
+acc += Math.sin(38469) + Math.cos(38470) * 57;
+acc += Math.sin(38470) + Math.cos(38471) * 58;
+acc += Math.sin(38471) + Math.cos(38472) * 59;
+acc += Math.sin(38472) + Math.cos(38473) * 60;
+acc += Math.sin(38473) + Math.cos(38474) * 61;
+acc += Math.sin(38474) + Math.cos(38475) * 62;
+acc += Math.sin(38475) + Math.cos(38476) * 63;
+acc += Math.sin(38476) + Math.cos(38477) * 64;
+acc += Math.sin(38477) + Math.cos(38478) * 65;
+acc += Math.sin(38478) + Math.cos(38479) * 66;
+acc += Math.sin(38479) + Math.cos(38480) * 67;
+acc += Math.sin(38480) + Math.cos(38481) * 68;
+acc += Math.sin(38481) + Math.cos(38482) * 69;
+acc += Math.sin(38482) + Math.cos(38483) * 70;
+acc += Math.sin(38483) + Math.cos(38484) * 71;
+acc += Math.sin(38484) + Math.cos(38485) * 72;
+acc += Math.sin(38485) + Math.cos(38486) * 73;
+acc += Math.sin(38486) + Math.cos(38487) * 74;
+acc += Math.sin(38487) + Math.cos(38488) * 75;
+acc += Math.sin(38488) + Math.cos(38489) * 76;
+acc += Math.sin(38489) + Math.cos(38490) * 77;
+acc += Math.sin(38490) + Math.cos(38491) * 78;
+acc += Math.sin(38491) + Math.cos(38492) * 79;
+acc += Math.sin(38492) + Math.cos(38493) * 80;
+acc += Math.sin(38493) + Math.cos(38494) * 81;
+acc += Math.sin(38494) + Math.cos(38495) * 82;
+acc += Math.sin(38495) + Math.cos(38496) * 83;
+acc += Math.sin(38496) + Math.cos(38497) * 84;
+acc += Math.sin(38497) + Math.cos(38498) * 85;
+acc += Math.sin(38498) + Math.cos(38499) * 86;
+acc += Math.sin(38499) + Math.cos(38500) * 87;
+acc += Math.sin(38500) + Math.cos(38501) * 88;
+acc += Math.sin(38501) + Math.cos(38502) * 89;
+acc += Math.sin(38502) + Math.cos(38503) * 90;
+acc += Math.sin(38503) + Math.cos(38504) * 91;
+acc += Math.sin(38504) + Math.cos(38505) * 92;
+acc += Math.sin(38505) + Math.cos(38506) * 93;
+acc += Math.sin(38506) + Math.cos(38507) * 94;
+acc += Math.sin(38507) + Math.cos(38508) * 95;
+acc += Math.sin(38508) + Math.cos(38509) * 96;
+acc += Math.sin(38509) + Math.cos(38510) * 0;
+acc += Math.sin(38510) + Math.cos(38511) * 1;
+acc += Math.sin(38511) + Math.cos(38512) * 2;
+acc += Math.sin(38512) + Math.cos(38513) * 3;
+acc += Math.sin(38513) + Math.cos(38514) * 4;
+acc += Math.sin(38514) + Math.cos(38515) * 5;
+acc += Math.sin(38515) + Math.cos(38516) * 6;
+acc += Math.sin(38516) + Math.cos(38517) * 7;
+acc += Math.sin(38517) + Math.cos(38518) * 8;
+acc += Math.sin(38518) + Math.cos(38519) * 9;
+acc += Math.sin(38519) + Math.cos(38520) * 10;
+acc += Math.sin(38520) + Math.cos(38521) * 11;
+acc += Math.sin(38521) + Math.cos(38522) * 12;
+acc += Math.sin(38522) + Math.cos(38523) * 13;
+acc += Math.sin(38523) + Math.cos(38524) * 14;
+acc += Math.sin(38524) + Math.cos(38525) * 15;
+acc += Math.sin(38525) + Math.cos(38526) * 16;
+acc += Math.sin(38526) + Math.cos(38527) * 17;
+acc += Math.sin(38527) + Math.cos(38528) * 18;
+acc += Math.sin(38528) + Math.cos(38529) * 19;
+acc += Math.sin(38529) + Math.cos(38530) * 20;
+acc += Math.sin(38530) + Math.cos(38531) * 21;
+acc += Math.sin(38531) + Math.cos(38532) * 22;
+acc += Math.sin(38532) + Math.cos(38533) * 23;
+acc += Math.sin(38533) + Math.cos(38534) * 24;
+acc += Math.sin(38534) + Math.cos(38535) * 25;
+acc += Math.sin(38535) + Math.cos(38536) * 26;
+acc += Math.sin(38536) + Math.cos(38537) * 27;
+acc += Math.sin(38537) + Math.cos(38538) * 28;
+acc += Math.sin(38538) + Math.cos(38539) * 29;
+acc += Math.sin(38539) + Math.cos(38540) * 30;
+acc += Math.sin(38540) + Math.cos(38541) * 31;
+acc += Math.sin(38541) + Math.cos(38542) * 32;
+acc += Math.sin(38542) + Math.cos(38543) * 33;
+acc += Math.sin(38543) + Math.cos(38544) * 34;
+acc += Math.sin(38544) + Math.cos(38545) * 35;
+acc += Math.sin(38545) + Math.cos(38546) * 36;
+acc += Math.sin(38546) + Math.cos(38547) * 37;
+acc += Math.sin(38547) + Math.cos(38548) * 38;
+acc += Math.sin(38548) + Math.cos(38549) * 39;
+acc += Math.sin(38549) + Math.cos(38550) * 40;
+acc += Math.sin(38550) + Math.cos(38551) * 41;
+acc += Math.sin(38551) + Math.cos(38552) * 42;
+acc += Math.sin(38552) + Math.cos(38553) * 43;
+acc += Math.sin(38553) + Math.cos(38554) * 44;
+acc += Math.sin(38554) + Math.cos(38555) * 45;
+acc += Math.sin(38555) + Math.cos(38556) * 46;
+acc += Math.sin(38556) + Math.cos(38557) * 47;
+acc += Math.sin(38557) + Math.cos(38558) * 48;
+acc += Math.sin(38558) + Math.cos(38559) * 49;
+acc += Math.sin(38559) + Math.cos(38560) * 50;
+acc += Math.sin(38560) + Math.cos(38561) * 51;
+acc += Math.sin(38561) + Math.cos(38562) * 52;
+acc += Math.sin(38562) + Math.cos(38563) * 53;
+acc += Math.sin(38563) + Math.cos(38564) * 54;
+acc += Math.sin(38564) + Math.cos(38565) * 55;
+acc += Math.sin(38565) + Math.cos(38566) * 56;
+acc += Math.sin(38566) + Math.cos(38567) * 57;
+acc += Math.sin(38567) + Math.cos(38568) * 58;
+acc += Math.sin(38568) + Math.cos(38569) * 59;
+acc += Math.sin(38569) + Math.cos(38570) * 60;
+acc += Math.sin(38570) + Math.cos(38571) * 61;
+acc += Math.sin(38571) + Math.cos(38572) * 62;
+acc += Math.sin(38572) + Math.cos(38573) * 63;
+acc += Math.sin(38573) + Math.cos(38574) * 64;
+acc += Math.sin(38574) + Math.cos(38575) * 65;
+acc += Math.sin(38575) + Math.cos(38576) * 66;
+acc += Math.sin(38576) + Math.cos(38577) * 67;
+acc += Math.sin(38577) + Math.cos(38578) * 68;
+acc += Math.sin(38578) + Math.cos(38579) * 69;
+acc += Math.sin(38579) + Math.cos(38580) * 70;
+acc += Math.sin(38580) + Math.cos(38581) * 71;
+acc += Math.sin(38581) + Math.cos(38582) * 72;
+acc += Math.sin(38582) + Math.cos(38583) * 73;
+acc += Math.sin(38583) + Math.cos(38584) * 74;
+acc += Math.sin(38584) + Math.cos(38585) * 75;
+acc += Math.sin(38585) + Math.cos(38586) * 76;
+acc += Math.sin(38586) + Math.cos(38587) * 77;
+acc += Math.sin(38587) + Math.cos(38588) * 78;
+acc += Math.sin(38588) + Math.cos(38589) * 79;
+acc += Math.sin(38589) + Math.cos(38590) * 80;
+acc += Math.sin(38590) + Math.cos(38591) * 81;
+acc += Math.sin(38591) + Math.cos(38592) * 82;
+acc += Math.sin(38592) + Math.cos(38593) * 83;
+acc += Math.sin(38593) + Math.cos(38594) * 84;
+acc += Math.sin(38594) + Math.cos(38595) * 85;
+acc += Math.sin(38595) + Math.cos(38596) * 86;
+acc += Math.sin(38596) + Math.cos(38597) * 87;
+acc += Math.sin(38597) + Math.cos(38598) * 88;
+acc += Math.sin(38598) + Math.cos(38599) * 89;
+acc += Math.sin(38599) + Math.cos(38600) * 90;
+acc += Math.sin(38600) + Math.cos(38601) * 91;
+acc += Math.sin(38601) + Math.cos(38602) * 92;
+acc += Math.sin(38602) + Math.cos(38603) * 93;
+acc += Math.sin(38603) + Math.cos(38604) * 94;
+acc += Math.sin(38604) + Math.cos(38605) * 95;
+acc += Math.sin(38605) + Math.cos(38606) * 96;
+acc += Math.sin(38606) + Math.cos(38607) * 0;
+acc += Math.sin(38607) + Math.cos(38608) * 1;
+acc += Math.sin(38608) + Math.cos(38609) * 2;
+acc += Math.sin(38609) + Math.cos(38610) * 3;
+acc += Math.sin(38610) + Math.cos(38611) * 4;
+acc += Math.sin(38611) + Math.cos(38612) * 5;
+acc += Math.sin(38612) + Math.cos(38613) * 6;
+acc += Math.sin(38613) + Math.cos(38614) * 7;
+acc += Math.sin(38614) + Math.cos(38615) * 8;
+acc += Math.sin(38615) + Math.cos(38616) * 9;
+acc += Math.sin(38616) + Math.cos(38617) * 10;
+acc += Math.sin(38617) + Math.cos(38618) * 11;
+acc += Math.sin(38618) + Math.cos(38619) * 12;
+acc += Math.sin(38619) + Math.cos(38620) * 13;
+acc += Math.sin(38620) + Math.cos(38621) * 14;
+acc += Math.sin(38621) + Math.cos(38622) * 15;
+acc += Math.sin(38622) + Math.cos(38623) * 16;
+acc += Math.sin(38623) + Math.cos(38624) * 17;
+acc += Math.sin(38624) + Math.cos(38625) * 18;
+acc += Math.sin(38625) + Math.cos(38626) * 19;
+acc += Math.sin(38626) + Math.cos(38627) * 20;
+acc += Math.sin(38627) + Math.cos(38628) * 21;
+acc += Math.sin(38628) + Math.cos(38629) * 22;
+acc += Math.sin(38629) + Math.cos(38630) * 23;
+acc += Math.sin(38630) + Math.cos(38631) * 24;
+acc += Math.sin(38631) + Math.cos(38632) * 25;
+acc += Math.sin(38632) + Math.cos(38633) * 26;
+acc += Math.sin(38633) + Math.cos(38634) * 27;
+acc += Math.sin(38634) + Math.cos(38635) * 28;
+acc += Math.sin(38635) + Math.cos(38636) * 29;
+acc += Math.sin(38636) + Math.cos(38637) * 30;
+acc += Math.sin(38637) + Math.cos(38638) * 31;
+acc += Math.sin(38638) + Math.cos(38639) * 32;
+acc += Math.sin(38639) + Math.cos(38640) * 33;
+acc += Math.sin(38640) + Math.cos(38641) * 34;
+acc += Math.sin(38641) + Math.cos(38642) * 35;
+acc += Math.sin(38642) + Math.cos(38643) * 36;
+acc += Math.sin(38643) + Math.cos(38644) * 37;
+acc += Math.sin(38644) + Math.cos(38645) * 38;
+acc += Math.sin(38645) + Math.cos(38646) * 39;
+acc += Math.sin(38646) + Math.cos(38647) * 40;
+acc += Math.sin(38647) + Math.cos(38648) * 41;
+acc += Math.sin(38648) + Math.cos(38649) * 42;
+acc += Math.sin(38649) + Math.cos(38650) * 43;
+acc += Math.sin(38650) + Math.cos(38651) * 44;
+acc += Math.sin(38651) + Math.cos(38652) * 45;
+acc += Math.sin(38652) + Math.cos(38653) * 46;
+acc += Math.sin(38653) + Math.cos(38654) * 47;
+acc += Math.sin(38654) + Math.cos(38655) * 48;
+acc += Math.sin(38655) + Math.cos(38656) * 49;
+acc += Math.sin(38656) + Math.cos(38657) * 50;
+acc += Math.sin(38657) + Math.cos(38658) * 51;
+acc += Math.sin(38658) + Math.cos(38659) * 52;
+acc += Math.sin(38659) + Math.cos(38660) * 53;
+acc += Math.sin(38660) + Math.cos(38661) * 54;
+acc += Math.sin(38661) + Math.cos(38662) * 55;
+acc += Math.sin(38662) + Math.cos(38663) * 56;
+acc += Math.sin(38663) + Math.cos(38664) * 57;
+acc += Math.sin(38664) + Math.cos(38665) * 58;
+acc += Math.sin(38665) + Math.cos(38666) * 59;
+acc += Math.sin(38666) + Math.cos(38667) * 60;
+acc += Math.sin(38667) + Math.cos(38668) * 61;
+acc += Math.sin(38668) + Math.cos(38669) * 62;
+acc += Math.sin(38669) + Math.cos(38670) * 63;
+acc += Math.sin(38670) + Math.cos(38671) * 64;
+acc += Math.sin(38671) + Math.cos(38672) * 65;
+acc += Math.sin(38672) + Math.cos(38673) * 66;
+acc += Math.sin(38673) + Math.cos(38674) * 67;
+acc += Math.sin(38674) + Math.cos(38675) * 68;
+acc += Math.sin(38675) + Math.cos(38676) * 69;
+acc += Math.sin(38676) + Math.cos(38677) * 70;
+acc += Math.sin(38677) + Math.cos(38678) * 71;
+acc += Math.sin(38678) + Math.cos(38679) * 72;
+acc += Math.sin(38679) + Math.cos(38680) * 73;
+acc += Math.sin(38680) + Math.cos(38681) * 74;
+acc += Math.sin(38681) + Math.cos(38682) * 75;
+acc += Math.sin(38682) + Math.cos(38683) * 76;
+acc += Math.sin(38683) + Math.cos(38684) * 77;
+acc += Math.sin(38684) + Math.cos(38685) * 78;
+acc += Math.sin(38685) + Math.cos(38686) * 79;
+acc += Math.sin(38686) + Math.cos(38687) * 80;
+acc += Math.sin(38687) + Math.cos(38688) * 81;
+acc += Math.sin(38688) + Math.cos(38689) * 82;
+acc += Math.sin(38689) + Math.cos(38690) * 83;
+acc += Math.sin(38690) + Math.cos(38691) * 84;
+acc += Math.sin(38691) + Math.cos(38692) * 85;
+acc += Math.sin(38692) + Math.cos(38693) * 86;
+acc += Math.sin(38693) + Math.cos(38694) * 87;
+acc += Math.sin(38694) + Math.cos(38695) * 88;
+acc += Math.sin(38695) + Math.cos(38696) * 89;
+acc += Math.sin(38696) + Math.cos(38697) * 90;
+acc += Math.sin(38697) + Math.cos(38698) * 91;
+acc += Math.sin(38698) + Math.cos(38699) * 92;
+acc += Math.sin(38699) + Math.cos(38700) * 93;
+acc += Math.sin(38700) + Math.cos(38701) * 94;
+acc += Math.sin(38701) + Math.cos(38702) * 95;
+acc += Math.sin(38702) + Math.cos(38703) * 96;
+acc += Math.sin(38703) + Math.cos(38704) * 0;
+acc += Math.sin(38704) + Math.cos(38705) * 1;
+acc += Math.sin(38705) + Math.cos(38706) * 2;
+acc += Math.sin(38706) + Math.cos(38707) * 3;
+acc += Math.sin(38707) + Math.cos(38708) * 4;
+acc += Math.sin(38708) + Math.cos(38709) * 5;
+acc += Math.sin(38709) + Math.cos(38710) * 6;
+acc += Math.sin(38710) + Math.cos(38711) * 7;
+acc += Math.sin(38711) + Math.cos(38712) * 8;
+acc += Math.sin(38712) + Math.cos(38713) * 9;
+acc += Math.sin(38713) + Math.cos(38714) * 10;
+acc += Math.sin(38714) + Math.cos(38715) * 11;
+acc += Math.sin(38715) + Math.cos(38716) * 12;
+acc += Math.sin(38716) + Math.cos(38717) * 13;
+acc += Math.sin(38717) + Math.cos(38718) * 14;
+acc += Math.sin(38718) + Math.cos(38719) * 15;
+acc += Math.sin(38719) + Math.cos(38720) * 16;
+acc += Math.sin(38720) + Math.cos(38721) * 17;
+acc += Math.sin(38721) + Math.cos(38722) * 18;
+acc += Math.sin(38722) + Math.cos(38723) * 19;
+acc += Math.sin(38723) + Math.cos(38724) * 20;
+acc += Math.sin(38724) + Math.cos(38725) * 21;
+acc += Math.sin(38725) + Math.cos(38726) * 22;
+acc += Math.sin(38726) + Math.cos(38727) * 23;
+acc += Math.sin(38727) + Math.cos(38728) * 24;
+acc += Math.sin(38728) + Math.cos(38729) * 25;
+acc += Math.sin(38729) + Math.cos(38730) * 26;
+acc += Math.sin(38730) + Math.cos(38731) * 27;
+acc += Math.sin(38731) + Math.cos(38732) * 28;
+acc += Math.sin(38732) + Math.cos(38733) * 29;
+acc += Math.sin(38733) + Math.cos(38734) * 30;
+acc += Math.sin(38734) + Math.cos(38735) * 31;
+acc += Math.sin(38735) + Math.cos(38736) * 32;
+acc += Math.sin(38736) + Math.cos(38737) * 33;
+acc += Math.sin(38737) + Math.cos(38738) * 34;
+acc += Math.sin(38738) + Math.cos(38739) * 35;
+acc += Math.sin(38739) + Math.cos(38740) * 36;
+acc += Math.sin(38740) + Math.cos(38741) * 37;
+acc += Math.sin(38741) + Math.cos(38742) * 38;
+acc += Math.sin(38742) + Math.cos(38743) * 39;
+acc += Math.sin(38743) + Math.cos(38744) * 40;
+acc += Math.sin(38744) + Math.cos(38745) * 41;
+acc += Math.sin(38745) + Math.cos(38746) * 42;
+acc += Math.sin(38746) + Math.cos(38747) * 43;
+acc += Math.sin(38747) + Math.cos(38748) * 44;
+acc += Math.sin(38748) + Math.cos(38749) * 45;
+acc += Math.sin(38749) + Math.cos(38750) * 46;
+acc += Math.sin(38750) + Math.cos(38751) * 47;
+acc += Math.sin(38751) + Math.cos(38752) * 48;
+acc += Math.sin(38752) + Math.cos(38753) * 49;
+acc += Math.sin(38753) + Math.cos(38754) * 50;
+acc += Math.sin(38754) + Math.cos(38755) * 51;
+acc += Math.sin(38755) + Math.cos(38756) * 52;
+acc += Math.sin(38756) + Math.cos(38757) * 53;
+acc += Math.sin(38757) + Math.cos(38758) * 54;
+acc += Math.sin(38758) + Math.cos(38759) * 55;
+acc += Math.sin(38759) + Math.cos(38760) * 56;
+acc += Math.sin(38760) + Math.cos(38761) * 57;
+acc += Math.sin(38761) + Math.cos(38762) * 58;
+acc += Math.sin(38762) + Math.cos(38763) * 59;
+acc += Math.sin(38763) + Math.cos(38764) * 60;
+acc += Math.sin(38764) + Math.cos(38765) * 61;
+acc += Math.sin(38765) + Math.cos(38766) * 62;
+acc += Math.sin(38766) + Math.cos(38767) * 63;
+acc += Math.sin(38767) + Math.cos(38768) * 64;
+acc += Math.sin(38768) + Math.cos(38769) * 65;
+acc += Math.sin(38769) + Math.cos(38770) * 66;
+acc += Math.sin(38770) + Math.cos(38771) * 67;
+acc += Math.sin(38771) + Math.cos(38772) * 68;
+acc += Math.sin(38772) + Math.cos(38773) * 69;
+acc += Math.sin(38773) + Math.cos(38774) * 70;
+acc += Math.sin(38774) + Math.cos(38775) * 71;
+acc += Math.sin(38775) + Math.cos(38776) * 72;
+acc += Math.sin(38776) + Math.cos(38777) * 73;
+acc += Math.sin(38777) + Math.cos(38778) * 74;
+acc += Math.sin(38778) + Math.cos(38779) * 75;
+acc += Math.sin(38779) + Math.cos(38780) * 76;
+acc += Math.sin(38780) + Math.cos(38781) * 77;
+acc += Math.sin(38781) + Math.cos(38782) * 78;
+acc += Math.sin(38782) + Math.cos(38783) * 79;
+acc += Math.sin(38783) + Math.cos(38784) * 80;
+acc += Math.sin(38784) + Math.cos(38785) * 81;
+acc += Math.sin(38785) + Math.cos(38786) * 82;
+acc += Math.sin(38786) + Math.cos(38787) * 83;
+acc += Math.sin(38787) + Math.cos(38788) * 84;
+acc += Math.sin(38788) + Math.cos(38789) * 85;
+acc += Math.sin(38789) + Math.cos(38790) * 86;
+acc += Math.sin(38790) + Math.cos(38791) * 87;
+acc += Math.sin(38791) + Math.cos(38792) * 88;
+acc += Math.sin(38792) + Math.cos(38793) * 89;
+acc += Math.sin(38793) + Math.cos(38794) * 90;
+acc += Math.sin(38794) + Math.cos(38795) * 91;
+acc += Math.sin(38795) + Math.cos(38796) * 92;
+acc += Math.sin(38796) + Math.cos(38797) * 93;
+acc += Math.sin(38797) + Math.cos(38798) * 94;
+acc += Math.sin(38798) + Math.cos(38799) * 95;
+acc += Math.sin(38799) + Math.cos(38800) * 96;
+acc += Math.sin(38800) + Math.cos(38801) * 0;
+acc += Math.sin(38801) + Math.cos(38802) * 1;
+acc += Math.sin(38802) + Math.cos(38803) * 2;
+acc += Math.sin(38803) + Math.cos(38804) * 3;
+acc += Math.sin(38804) + Math.cos(38805) * 4;
+acc += Math.sin(38805) + Math.cos(38806) * 5;
+acc += Math.sin(38806) + Math.cos(38807) * 6;
+acc += Math.sin(38807) + Math.cos(38808) * 7;
+acc += Math.sin(38808) + Math.cos(38809) * 8;
+acc += Math.sin(38809) + Math.cos(38810) * 9;
+acc += Math.sin(38810) + Math.cos(38811) * 10;
+acc += Math.sin(38811) + Math.cos(38812) * 11;
+acc += Math.sin(38812) + Math.cos(38813) * 12;
+acc += Math.sin(38813) + Math.cos(38814) * 13;
+acc += Math.sin(38814) + Math.cos(38815) * 14;
+acc += Math.sin(38815) + Math.cos(38816) * 15;
+acc += Math.sin(38816) + Math.cos(38817) * 16;
+acc += Math.sin(38817) + Math.cos(38818) * 17;
+acc += Math.sin(38818) + Math.cos(38819) * 18;
+acc += Math.sin(38819) + Math.cos(38820) * 19;
+acc += Math.sin(38820) + Math.cos(38821) * 20;
+acc += Math.sin(38821) + Math.cos(38822) * 21;
+acc += Math.sin(38822) + Math.cos(38823) * 22;
+acc += Math.sin(38823) + Math.cos(38824) * 23;
+acc += Math.sin(38824) + Math.cos(38825) * 24;
+acc += Math.sin(38825) + Math.cos(38826) * 25;
+acc += Math.sin(38826) + Math.cos(38827) * 26;
+acc += Math.sin(38827) + Math.cos(38828) * 27;
+acc += Math.sin(38828) + Math.cos(38829) * 28;
+acc += Math.sin(38829) + Math.cos(38830) * 29;
+acc += Math.sin(38830) + Math.cos(38831) * 30;
+acc += Math.sin(38831) + Math.cos(38832) * 31;
+acc += Math.sin(38832) + Math.cos(38833) * 32;
+acc += Math.sin(38833) + Math.cos(38834) * 33;
+acc += Math.sin(38834) + Math.cos(38835) * 34;
+acc += Math.sin(38835) + Math.cos(38836) * 35;
+acc += Math.sin(38836) + Math.cos(38837) * 36;
+acc += Math.sin(38837) + Math.cos(38838) * 37;
+acc += Math.sin(38838) + Math.cos(38839) * 38;
+acc += Math.sin(38839) + Math.cos(38840) * 39;
+acc += Math.sin(38840) + Math.cos(38841) * 40;
+acc += Math.sin(38841) + Math.cos(38842) * 41;
+acc += Math.sin(38842) + Math.cos(38843) * 42;
+acc += Math.sin(38843) + Math.cos(38844) * 43;
+acc += Math.sin(38844) + Math.cos(38845) * 44;
+acc += Math.sin(38845) + Math.cos(38846) * 45;
+acc += Math.sin(38846) + Math.cos(38847) * 46;
+acc += Math.sin(38847) + Math.cos(38848) * 47;
+acc += Math.sin(38848) + Math.cos(38849) * 48;
+acc += Math.sin(38849) + Math.cos(38850) * 49;
+acc += Math.sin(38850) + Math.cos(38851) * 50;
+acc += Math.sin(38851) + Math.cos(38852) * 51;
+acc += Math.sin(38852) + Math.cos(38853) * 52;
+acc += Math.sin(38853) + Math.cos(38854) * 53;
+acc += Math.sin(38854) + Math.cos(38855) * 54;
+acc += Math.sin(38855) + Math.cos(38856) * 55;
+acc += Math.sin(38856) + Math.cos(38857) * 56;
+acc += Math.sin(38857) + Math.cos(38858) * 57;
+acc += Math.sin(38858) + Math.cos(38859) * 58;
+acc += Math.sin(38859) + Math.cos(38860) * 59;
+acc += Math.sin(38860) + Math.cos(38861) * 60;
+acc += Math.sin(38861) + Math.cos(38862) * 61;
+acc += Math.sin(38862) + Math.cos(38863) * 62;
+acc += Math.sin(38863) + Math.cos(38864) * 63;
+acc += Math.sin(38864) + Math.cos(38865) * 64;
+acc += Math.sin(38865) + Math.cos(38866) * 65;
+acc += Math.sin(38866) + Math.cos(38867) * 66;
+acc += Math.sin(38867) + Math.cos(38868) * 67;
+acc += Math.sin(38868) + Math.cos(38869) * 68;
+acc += Math.sin(38869) + Math.cos(38870) * 69;
+acc += Math.sin(38870) + Math.cos(38871) * 70;
+acc += Math.sin(38871) + Math.cos(38872) * 71;
+acc += Math.sin(38872) + Math.cos(38873) * 72;
+acc += Math.sin(38873) + Math.cos(38874) * 73;
+acc += Math.sin(38874) + Math.cos(38875) * 74;
+acc += Math.sin(38875) + Math.cos(38876) * 75;
+acc += Math.sin(38876) + Math.cos(38877) * 76;
+acc += Math.sin(38877) + Math.cos(38878) * 77;
+acc += Math.sin(38878) + Math.cos(38879) * 78;
+acc += Math.sin(38879) + Math.cos(38880) * 79;
+acc += Math.sin(38880) + Math.cos(38881) * 80;
+acc += Math.sin(38881) + Math.cos(38882) * 81;
+acc += Math.sin(38882) + Math.cos(38883) * 82;
+acc += Math.sin(38883) + Math.cos(38884) * 83;
+acc += Math.sin(38884) + Math.cos(38885) * 84;
+acc += Math.sin(38885) + Math.cos(38886) * 85;
+acc += Math.sin(38886) + Math.cos(38887) * 86;
+acc += Math.sin(38887) + Math.cos(38888) * 87;
+acc += Math.sin(38888) + Math.cos(38889) * 88;
+acc += Math.sin(38889) + Math.cos(38890) * 89;
+acc += Math.sin(38890) + Math.cos(38891) * 90;
+acc += Math.sin(38891) + Math.cos(38892) * 91;
+acc += Math.sin(38892) + Math.cos(38893) * 92;
+acc += Math.sin(38893) + Math.cos(38894) * 93;
+acc += Math.sin(38894) + Math.cos(38895) * 94;
+acc += Math.sin(38895) + Math.cos(38896) * 95;
+acc += Math.sin(38896) + Math.cos(38897) * 96;
+acc += Math.sin(38897) + Math.cos(38898) * 0;
+acc += Math.sin(38898) + Math.cos(38899) * 1;
+acc += Math.sin(38899) + Math.cos(38900) * 2;
+acc += Math.sin(38900) + Math.cos(38901) * 3;
+acc += Math.sin(38901) + Math.cos(38902) * 4;
+acc += Math.sin(38902) + Math.cos(38903) * 5;
+acc += Math.sin(38903) + Math.cos(38904) * 6;
+acc += Math.sin(38904) + Math.cos(38905) * 7;
+acc += Math.sin(38905) + Math.cos(38906) * 8;
+acc += Math.sin(38906) + Math.cos(38907) * 9;
+acc += Math.sin(38907) + Math.cos(38908) * 10;
+acc += Math.sin(38908) + Math.cos(38909) * 11;
+acc += Math.sin(38909) + Math.cos(38910) * 12;
+acc += Math.sin(38910) + Math.cos(38911) * 13;
+acc += Math.sin(38911) + Math.cos(38912) * 14;
+acc += Math.sin(38912) + Math.cos(38913) * 15;
+acc += Math.sin(38913) + Math.cos(38914) * 16;
+acc += Math.sin(38914) + Math.cos(38915) * 17;
+acc += Math.sin(38915) + Math.cos(38916) * 18;
+acc += Math.sin(38916) + Math.cos(38917) * 19;
+acc += Math.sin(38917) + Math.cos(38918) * 20;
+acc += Math.sin(38918) + Math.cos(38919) * 21;
+acc += Math.sin(38919) + Math.cos(38920) * 22;
+acc += Math.sin(38920) + Math.cos(38921) * 23;
+acc += Math.sin(38921) + Math.cos(38922) * 24;
+acc += Math.sin(38922) + Math.cos(38923) * 25;
+acc += Math.sin(38923) + Math.cos(38924) * 26;
+acc += Math.sin(38924) + Math.cos(38925) * 27;
+acc += Math.sin(38925) + Math.cos(38926) * 28;
+acc += Math.sin(38926) + Math.cos(38927) * 29;
+acc += Math.sin(38927) + Math.cos(38928) * 30;
+acc += Math.sin(38928) + Math.cos(38929) * 31;
+acc += Math.sin(38929) + Math.cos(38930) * 32;
+acc += Math.sin(38930) + Math.cos(38931) * 33;
+acc += Math.sin(38931) + Math.cos(38932) * 34;
+acc += Math.sin(38932) + Math.cos(38933) * 35;
+acc += Math.sin(38933) + Math.cos(38934) * 36;
+acc += Math.sin(38934) + Math.cos(38935) * 37;
+acc += Math.sin(38935) + Math.cos(38936) * 38;
+acc += Math.sin(38936) + Math.cos(38937) * 39;
+acc += Math.sin(38937) + Math.cos(38938) * 40;
+acc += Math.sin(38938) + Math.cos(38939) * 41;
+acc += Math.sin(38939) + Math.cos(38940) * 42;
+acc += Math.sin(38940) + Math.cos(38941) * 43;
+acc += Math.sin(38941) + Math.cos(38942) * 44;
+acc += Math.sin(38942) + Math.cos(38943) * 45;
+acc += Math.sin(38943) + Math.cos(38944) * 46;
+acc += Math.sin(38944) + Math.cos(38945) * 47;
+acc += Math.sin(38945) + Math.cos(38946) * 48;
+acc += Math.sin(38946) + Math.cos(38947) * 49;
+acc += Math.sin(38947) + Math.cos(38948) * 50;
+acc += Math.sin(38948) + Math.cos(38949) * 51;
+acc += Math.sin(38949) + Math.cos(38950) * 52;
+acc += Math.sin(38950) + Math.cos(38951) * 53;
+acc += Math.sin(38951) + Math.cos(38952) * 54;
+acc += Math.sin(38952) + Math.cos(38953) * 55;
+acc += Math.sin(38953) + Math.cos(38954) * 56;
+acc += Math.sin(38954) + Math.cos(38955) * 57;
+acc += Math.sin(38955) + Math.cos(38956) * 58;
+acc += Math.sin(38956) + Math.cos(38957) * 59;
+acc += Math.sin(38957) + Math.cos(38958) * 60;
+acc += Math.sin(38958) + Math.cos(38959) * 61;
+acc += Math.sin(38959) + Math.cos(38960) * 62;
+acc += Math.sin(38960) + Math.cos(38961) * 63;
+acc += Math.sin(38961) + Math.cos(38962) * 64;
+acc += Math.sin(38962) + Math.cos(38963) * 65;
+acc += Math.sin(38963) + Math.cos(38964) * 66;
+acc += Math.sin(38964) + Math.cos(38965) * 67;
+acc += Math.sin(38965) + Math.cos(38966) * 68;
+acc += Math.sin(38966) + Math.cos(38967) * 69;
+acc += Math.sin(38967) + Math.cos(38968) * 70;
+acc += Math.sin(38968) + Math.cos(38969) * 71;
+acc += Math.sin(38969) + Math.cos(38970) * 72;
+acc += Math.sin(38970) + Math.cos(38971) * 73;
+acc += Math.sin(38971) + Math.cos(38972) * 74;
+acc += Math.sin(38972) + Math.cos(38973) * 75;
+acc += Math.sin(38973) + Math.cos(38974) * 76;
+acc += Math.sin(38974) + Math.cos(38975) * 77;
+acc += Math.sin(38975) + Math.cos(38976) * 78;
+acc += Math.sin(38976) + Math.cos(38977) * 79;
+acc += Math.sin(38977) + Math.cos(38978) * 80;
+acc += Math.sin(38978) + Math.cos(38979) * 81;
+acc += Math.sin(38979) + Math.cos(38980) * 82;
+acc += Math.sin(38980) + Math.cos(38981) * 83;
+acc += Math.sin(38981) + Math.cos(38982) * 84;
+acc += Math.sin(38982) + Math.cos(38983) * 85;
+acc += Math.sin(38983) + Math.cos(38984) * 86;
+acc += Math.sin(38984) + Math.cos(38985) * 87;
+acc += Math.sin(38985) + Math.cos(38986) * 88;
+acc += Math.sin(38986) + Math.cos(38987) * 89;
+acc += Math.sin(38987) + Math.cos(38988) * 90;
+acc += Math.sin(38988) + Math.cos(38989) * 91;
+acc += Math.sin(38989) + Math.cos(38990) * 92;
+acc += Math.sin(38990) + Math.cos(38991) * 93;
+acc += Math.sin(38991) + Math.cos(38992) * 94;
+acc += Math.sin(38992) + Math.cos(38993) * 95;
+acc += Math.sin(38993) + Math.cos(38994) * 96;
+acc += Math.sin(38994) + Math.cos(38995) * 0;
+acc += Math.sin(38995) + Math.cos(38996) * 1;
+acc += Math.sin(38996) + Math.cos(38997) * 2;
+acc += Math.sin(38997) + Math.cos(38998) * 3;
+acc += Math.sin(38998) + Math.cos(38999) * 4;
+acc += Math.sin(38999) + Math.cos(39000) * 5;
+acc += Math.sin(39000) + Math.cos(39001) * 6;
+acc += Math.sin(39001) + Math.cos(39002) * 7;
+acc += Math.sin(39002) + Math.cos(39003) * 8;
+acc += Math.sin(39003) + Math.cos(39004) * 9;
+acc += Math.sin(39004) + Math.cos(39005) * 10;
+acc += Math.sin(39005) + Math.cos(39006) * 11;
+acc += Math.sin(39006) + Math.cos(39007) * 12;
+acc += Math.sin(39007) + Math.cos(39008) * 13;
+acc += Math.sin(39008) + Math.cos(39009) * 14;
+acc += Math.sin(39009) + Math.cos(39010) * 15;
+acc += Math.sin(39010) + Math.cos(39011) * 16;
+acc += Math.sin(39011) + Math.cos(39012) * 17;
+acc += Math.sin(39012) + Math.cos(39013) * 18;
+acc += Math.sin(39013) + Math.cos(39014) * 19;
+acc += Math.sin(39014) + Math.cos(39015) * 20;
+acc += Math.sin(39015) + Math.cos(39016) * 21;
+acc += Math.sin(39016) + Math.cos(39017) * 22;
+acc += Math.sin(39017) + Math.cos(39018) * 23;
+acc += Math.sin(39018) + Math.cos(39019) * 24;
+acc += Math.sin(39019) + Math.cos(39020) * 25;
+acc += Math.sin(39020) + Math.cos(39021) * 26;
+acc += Math.sin(39021) + Math.cos(39022) * 27;
+acc += Math.sin(39022) + Math.cos(39023) * 28;
+acc += Math.sin(39023) + Math.cos(39024) * 29;
+acc += Math.sin(39024) + Math.cos(39025) * 30;
+acc += Math.sin(39025) + Math.cos(39026) * 31;
+acc += Math.sin(39026) + Math.cos(39027) * 32;
+acc += Math.sin(39027) + Math.cos(39028) * 33;
+acc += Math.sin(39028) + Math.cos(39029) * 34;
+acc += Math.sin(39029) + Math.cos(39030) * 35;
+acc += Math.sin(39030) + Math.cos(39031) * 36;
+acc += Math.sin(39031) + Math.cos(39032) * 37;
+acc += Math.sin(39032) + Math.cos(39033) * 38;
+acc += Math.sin(39033) + Math.cos(39034) * 39;
+acc += Math.sin(39034) + Math.cos(39035) * 40;
+acc += Math.sin(39035) + Math.cos(39036) * 41;
+acc += Math.sin(39036) + Math.cos(39037) * 42;
+acc += Math.sin(39037) + Math.cos(39038) * 43;
+acc += Math.sin(39038) + Math.cos(39039) * 44;
+acc += Math.sin(39039) + Math.cos(39040) * 45;
+acc += Math.sin(39040) + Math.cos(39041) * 46;
+acc += Math.sin(39041) + Math.cos(39042) * 47;
+acc += Math.sin(39042) + Math.cos(39043) * 48;
+acc += Math.sin(39043) + Math.cos(39044) * 49;
+acc += Math.sin(39044) + Math.cos(39045) * 50;
+acc += Math.sin(39045) + Math.cos(39046) * 51;
+acc += Math.sin(39046) + Math.cos(39047) * 52;
+acc += Math.sin(39047) + Math.cos(39048) * 53;
+acc += Math.sin(39048) + Math.cos(39049) * 54;
+acc += Math.sin(39049) + Math.cos(39050) * 55;
+acc += Math.sin(39050) + Math.cos(39051) * 56;
+acc += Math.sin(39051) + Math.cos(39052) * 57;
+acc += Math.sin(39052) + Math.cos(39053) * 58;
+acc += Math.sin(39053) + Math.cos(39054) * 59;
+acc += Math.sin(39054) + Math.cos(39055) * 60;
+acc += Math.sin(39055) + Math.cos(39056) * 61;
+acc += Math.sin(39056) + Math.cos(39057) * 62;
+acc += Math.sin(39057) + Math.cos(39058) * 63;
+acc += Math.sin(39058) + Math.cos(39059) * 64;
+acc += Math.sin(39059) + Math.cos(39060) * 65;
+acc += Math.sin(39060) + Math.cos(39061) * 66;
+acc += Math.sin(39061) + Math.cos(39062) * 67;
+acc += Math.sin(39062) + Math.cos(39063) * 68;
+acc += Math.sin(39063) + Math.cos(39064) * 69;
+acc += Math.sin(39064) + Math.cos(39065) * 70;
+acc += Math.sin(39065) + Math.cos(39066) * 71;
+acc += Math.sin(39066) + Math.cos(39067) * 72;
+acc += Math.sin(39067) + Math.cos(39068) * 73;
+acc += Math.sin(39068) + Math.cos(39069) * 74;
+acc += Math.sin(39069) + Math.cos(39070) * 75;
+acc += Math.sin(39070) + Math.cos(39071) * 76;
+acc += Math.sin(39071) + Math.cos(39072) * 77;
+acc += Math.sin(39072) + Math.cos(39073) * 78;
+acc += Math.sin(39073) + Math.cos(39074) * 79;
+acc += Math.sin(39074) + Math.cos(39075) * 80;
+acc += Math.sin(39075) + Math.cos(39076) * 81;
+acc += Math.sin(39076) + Math.cos(39077) * 82;
+acc += Math.sin(39077) + Math.cos(39078) * 83;
+acc += Math.sin(39078) + Math.cos(39079) * 84;
+acc += Math.sin(39079) + Math.cos(39080) * 85;
+acc += Math.sin(39080) + Math.cos(39081) * 86;
+acc += Math.sin(39081) + Math.cos(39082) * 87;
+acc += Math.sin(39082) + Math.cos(39083) * 88;
+acc += Math.sin(39083) + Math.cos(39084) * 89;
+acc += Math.sin(39084) + Math.cos(39085) * 90;
+acc += Math.sin(39085) + Math.cos(39086) * 91;
+acc += Math.sin(39086) + Math.cos(39087) * 92;
+acc += Math.sin(39087) + Math.cos(39088) * 93;
+acc += Math.sin(39088) + Math.cos(39089) * 94;
+acc += Math.sin(39089) + Math.cos(39090) * 95;
+acc += Math.sin(39090) + Math.cos(39091) * 96;
+acc += Math.sin(39091) + Math.cos(39092) * 0;
+acc += Math.sin(39092) + Math.cos(39093) * 1;
+acc += Math.sin(39093) + Math.cos(39094) * 2;
+acc += Math.sin(39094) + Math.cos(39095) * 3;
+acc += Math.sin(39095) + Math.cos(39096) * 4;
+acc += Math.sin(39096) + Math.cos(39097) * 5;
+acc += Math.sin(39097) + Math.cos(39098) * 6;
+acc += Math.sin(39098) + Math.cos(39099) * 7;
+acc += Math.sin(39099) + Math.cos(39100) * 8;
+acc += Math.sin(39100) + Math.cos(39101) * 9;
+acc += Math.sin(39101) + Math.cos(39102) * 10;
+acc += Math.sin(39102) + Math.cos(39103) * 11;
+acc += Math.sin(39103) + Math.cos(39104) * 12;
+acc += Math.sin(39104) + Math.cos(39105) * 13;
+acc += Math.sin(39105) + Math.cos(39106) * 14;
+acc += Math.sin(39106) + Math.cos(39107) * 15;
+acc += Math.sin(39107) + Math.cos(39108) * 16;
+acc += Math.sin(39108) + Math.cos(39109) * 17;
+acc += Math.sin(39109) + Math.cos(39110) * 18;
+acc += Math.sin(39110) + Math.cos(39111) * 19;
+acc += Math.sin(39111) + Math.cos(39112) * 20;
+acc += Math.sin(39112) + Math.cos(39113) * 21;
+acc += Math.sin(39113) + Math.cos(39114) * 22;
+acc += Math.sin(39114) + Math.cos(39115) * 23;
+acc += Math.sin(39115) + Math.cos(39116) * 24;
+acc += Math.sin(39116) + Math.cos(39117) * 25;
+acc += Math.sin(39117) + Math.cos(39118) * 26;
+acc += Math.sin(39118) + Math.cos(39119) * 27;
+acc += Math.sin(39119) + Math.cos(39120) * 28;
+acc += Math.sin(39120) + Math.cos(39121) * 29;
+acc += Math.sin(39121) + Math.cos(39122) * 30;
+acc += Math.sin(39122) + Math.cos(39123) * 31;
+acc += Math.sin(39123) + Math.cos(39124) * 32;
+acc += Math.sin(39124) + Math.cos(39125) * 33;
+acc += Math.sin(39125) + Math.cos(39126) * 34;
+acc += Math.sin(39126) + Math.cos(39127) * 35;
+acc += Math.sin(39127) + Math.cos(39128) * 36;
+acc += Math.sin(39128) + Math.cos(39129) * 37;
+acc += Math.sin(39129) + Math.cos(39130) * 38;
+acc += Math.sin(39130) + Math.cos(39131) * 39;
+acc += Math.sin(39131) + Math.cos(39132) * 40;
+acc += Math.sin(39132) + Math.cos(39133) * 41;
+acc += Math.sin(39133) + Math.cos(39134) * 42;
+acc += Math.sin(39134) + Math.cos(39135) * 43;
+acc += Math.sin(39135) + Math.cos(39136) * 44;
+acc += Math.sin(39136) + Math.cos(39137) * 45;
+acc += Math.sin(39137) + Math.cos(39138) * 46;
+acc += Math.sin(39138) + Math.cos(39139) * 47;
+acc += Math.sin(39139) + Math.cos(39140) * 48;
+acc += Math.sin(39140) + Math.cos(39141) * 49;
+acc += Math.sin(39141) + Math.cos(39142) * 50;
+acc += Math.sin(39142) + Math.cos(39143) * 51;
+acc += Math.sin(39143) + Math.cos(39144) * 52;
+acc += Math.sin(39144) + Math.cos(39145) * 53;
+acc += Math.sin(39145) + Math.cos(39146) * 54;
+acc += Math.sin(39146) + Math.cos(39147) * 55;
+acc += Math.sin(39147) + Math.cos(39148) * 56;
+acc += Math.sin(39148) + Math.cos(39149) * 57;
+acc += Math.sin(39149) + Math.cos(39150) * 58;
+acc += Math.sin(39150) + Math.cos(39151) * 59;
+acc += Math.sin(39151) + Math.cos(39152) * 60;
+acc += Math.sin(39152) + Math.cos(39153) * 61;
+acc += Math.sin(39153) + Math.cos(39154) * 62;
+acc += Math.sin(39154) + Math.cos(39155) * 63;
+acc += Math.sin(39155) + Math.cos(39156) * 64;
+acc += Math.sin(39156) + Math.cos(39157) * 65;
+acc += Math.sin(39157) + Math.cos(39158) * 66;
+acc += Math.sin(39158) + Math.cos(39159) * 67;
+acc += Math.sin(39159) + Math.cos(39160) * 68;
+acc += Math.sin(39160) + Math.cos(39161) * 69;
+acc += Math.sin(39161) + Math.cos(39162) * 70;
+acc += Math.sin(39162) + Math.cos(39163) * 71;
+acc += Math.sin(39163) + Math.cos(39164) * 72;
+acc += Math.sin(39164) + Math.cos(39165) * 73;
+acc += Math.sin(39165) + Math.cos(39166) * 74;
+acc += Math.sin(39166) + Math.cos(39167) * 75;
+acc += Math.sin(39167) + Math.cos(39168) * 76;
+acc += Math.sin(39168) + Math.cos(39169) * 77;
+acc += Math.sin(39169) + Math.cos(39170) * 78;
+acc += Math.sin(39170) + Math.cos(39171) * 79;
+acc += Math.sin(39171) + Math.cos(39172) * 80;
+acc += Math.sin(39172) + Math.cos(39173) * 81;
+acc += Math.sin(39173) + Math.cos(39174) * 82;
+acc += Math.sin(39174) + Math.cos(39175) * 83;
+acc += Math.sin(39175) + Math.cos(39176) * 84;
+acc += Math.sin(39176) + Math.cos(39177) * 85;
+acc += Math.sin(39177) + Math.cos(39178) * 86;
+acc += Math.sin(39178) + Math.cos(39179) * 87;
+acc += Math.sin(39179) + Math.cos(39180) * 88;
+acc += Math.sin(39180) + Math.cos(39181) * 89;
+acc += Math.sin(39181) + Math.cos(39182) * 90;
+acc += Math.sin(39182) + Math.cos(39183) * 91;
+acc += Math.sin(39183) + Math.cos(39184) * 92;
+acc += Math.sin(39184) + Math.cos(39185) * 93;
+acc += Math.sin(39185) + Math.cos(39186) * 94;
+acc += Math.sin(39186) + Math.cos(39187) * 95;
+acc += Math.sin(39187) + Math.cos(39188) * 96;
+acc += Math.sin(39188) + Math.cos(39189) * 0;
+acc += Math.sin(39189) + Math.cos(39190) * 1;
+acc += Math.sin(39190) + Math.cos(39191) * 2;
+acc += Math.sin(39191) + Math.cos(39192) * 3;
+acc += Math.sin(39192) + Math.cos(39193) * 4;
+acc += Math.sin(39193) + Math.cos(39194) * 5;
+acc += Math.sin(39194) + Math.cos(39195) * 6;
+acc += Math.sin(39195) + Math.cos(39196) * 7;
+acc += Math.sin(39196) + Math.cos(39197) * 8;
+acc += Math.sin(39197) + Math.cos(39198) * 9;
+acc += Math.sin(39198) + Math.cos(39199) * 10;
+acc += Math.sin(39199) + Math.cos(39200) * 11;
+acc += Math.sin(39200) + Math.cos(39201) * 12;
+acc += Math.sin(39201) + Math.cos(39202) * 13;
+acc += Math.sin(39202) + Math.cos(39203) * 14;
+acc += Math.sin(39203) + Math.cos(39204) * 15;
+acc += Math.sin(39204) + Math.cos(39205) * 16;
+acc += Math.sin(39205) + Math.cos(39206) * 17;
+acc += Math.sin(39206) + Math.cos(39207) * 18;
+acc += Math.sin(39207) + Math.cos(39208) * 19;
+acc += Math.sin(39208) + Math.cos(39209) * 20;
+acc += Math.sin(39209) + Math.cos(39210) * 21;
+acc += Math.sin(39210) + Math.cos(39211) * 22;
+acc += Math.sin(39211) + Math.cos(39212) * 23;
+acc += Math.sin(39212) + Math.cos(39213) * 24;
+acc += Math.sin(39213) + Math.cos(39214) * 25;
+acc += Math.sin(39214) + Math.cos(39215) * 26;
+acc += Math.sin(39215) + Math.cos(39216) * 27;
+acc += Math.sin(39216) + Math.cos(39217) * 28;
+acc += Math.sin(39217) + Math.cos(39218) * 29;
+acc += Math.sin(39218) + Math.cos(39219) * 30;
+acc += Math.sin(39219) + Math.cos(39220) * 31;
+acc += Math.sin(39220) + Math.cos(39221) * 32;
+acc += Math.sin(39221) + Math.cos(39222) * 33;
+acc += Math.sin(39222) + Math.cos(39223) * 34;
+acc += Math.sin(39223) + Math.cos(39224) * 35;
+acc += Math.sin(39224) + Math.cos(39225) * 36;
+acc += Math.sin(39225) + Math.cos(39226) * 37;
+acc += Math.sin(39226) + Math.cos(39227) * 38;
+acc += Math.sin(39227) + Math.cos(39228) * 39;
+acc += Math.sin(39228) + Math.cos(39229) * 40;
+acc += Math.sin(39229) + Math.cos(39230) * 41;
+acc += Math.sin(39230) + Math.cos(39231) * 42;
+acc += Math.sin(39231) + Math.cos(39232) * 43;
+acc += Math.sin(39232) + Math.cos(39233) * 44;
+acc += Math.sin(39233) + Math.cos(39234) * 45;
+acc += Math.sin(39234) + Math.cos(39235) * 46;
+acc += Math.sin(39235) + Math.cos(39236) * 47;
+acc += Math.sin(39236) + Math.cos(39237) * 48;
+acc += Math.sin(39237) + Math.cos(39238) * 49;
+acc += Math.sin(39238) + Math.cos(39239) * 50;
+acc += Math.sin(39239) + Math.cos(39240) * 51;
+acc += Math.sin(39240) + Math.cos(39241) * 52;
+acc += Math.sin(39241) + Math.cos(39242) * 53;
+acc += Math.sin(39242) + Math.cos(39243) * 54;
+acc += Math.sin(39243) + Math.cos(39244) * 55;
+acc += Math.sin(39244) + Math.cos(39245) * 56;
+acc += Math.sin(39245) + Math.cos(39246) * 57;
+acc += Math.sin(39246) + Math.cos(39247) * 58;
+acc += Math.sin(39247) + Math.cos(39248) * 59;
+acc += Math.sin(39248) + Math.cos(39249) * 60;
+acc += Math.sin(39249) + Math.cos(39250) * 61;
+acc += Math.sin(39250) + Math.cos(39251) * 62;
+acc += Math.sin(39251) + Math.cos(39252) * 63;
+acc += Math.sin(39252) + Math.cos(39253) * 64;
+acc += Math.sin(39253) + Math.cos(39254) * 65;
+acc += Math.sin(39254) + Math.cos(39255) * 66;
+acc += Math.sin(39255) + Math.cos(39256) * 67;
+acc += Math.sin(39256) + Math.cos(39257) * 68;
+acc += Math.sin(39257) + Math.cos(39258) * 69;
+acc += Math.sin(39258) + Math.cos(39259) * 70;
+acc += Math.sin(39259) + Math.cos(39260) * 71;
+acc += Math.sin(39260) + Math.cos(39261) * 72;
+acc += Math.sin(39261) + Math.cos(39262) * 73;
+acc += Math.sin(39262) + Math.cos(39263) * 74;
+acc += Math.sin(39263) + Math.cos(39264) * 75;
+acc += Math.sin(39264) + Math.cos(39265) * 76;
+acc += Math.sin(39265) + Math.cos(39266) * 77;
+acc += Math.sin(39266) + Math.cos(39267) * 78;
+acc += Math.sin(39267) + Math.cos(39268) * 79;
+acc += Math.sin(39268) + Math.cos(39269) * 80;
+acc += Math.sin(39269) + Math.cos(39270) * 81;
+acc += Math.sin(39270) + Math.cos(39271) * 82;
+acc += Math.sin(39271) + Math.cos(39272) * 83;
+acc += Math.sin(39272) + Math.cos(39273) * 84;
+acc += Math.sin(39273) + Math.cos(39274) * 85;
+acc += Math.sin(39274) + Math.cos(39275) * 86;
+acc += Math.sin(39275) + Math.cos(39276) * 87;
+acc += Math.sin(39276) + Math.cos(39277) * 88;
+acc += Math.sin(39277) + Math.cos(39278) * 89;
+acc += Math.sin(39278) + Math.cos(39279) * 90;
+acc += Math.sin(39279) + Math.cos(39280) * 91;
+acc += Math.sin(39280) + Math.cos(39281) * 92;
+acc += Math.sin(39281) + Math.cos(39282) * 93;
+acc += Math.sin(39282) + Math.cos(39283) * 94;
+acc += Math.sin(39283) + Math.cos(39284) * 95;
+acc += Math.sin(39284) + Math.cos(39285) * 96;
+acc += Math.sin(39285) + Math.cos(39286) * 0;
+acc += Math.sin(39286) + Math.cos(39287) * 1;
+acc += Math.sin(39287) + Math.cos(39288) * 2;
+acc += Math.sin(39288) + Math.cos(39289) * 3;
+acc += Math.sin(39289) + Math.cos(39290) * 4;
+acc += Math.sin(39290) + Math.cos(39291) * 5;
+acc += Math.sin(39291) + Math.cos(39292) * 6;
+acc += Math.sin(39292) + Math.cos(39293) * 7;
+acc += Math.sin(39293) + Math.cos(39294) * 8;
+acc += Math.sin(39294) + Math.cos(39295) * 9;
+acc += Math.sin(39295) + Math.cos(39296) * 10;
+acc += Math.sin(39296) + Math.cos(39297) * 11;
+acc += Math.sin(39297) + Math.cos(39298) * 12;
+acc += Math.sin(39298) + Math.cos(39299) * 13;
+acc += Math.sin(39299) + Math.cos(39300) * 14;
+acc += Math.sin(39300) + Math.cos(39301) * 15;
+acc += Math.sin(39301) + Math.cos(39302) * 16;
+acc += Math.sin(39302) + Math.cos(39303) * 17;
+acc += Math.sin(39303) + Math.cos(39304) * 18;
+acc += Math.sin(39304) + Math.cos(39305) * 19;
+acc += Math.sin(39305) + Math.cos(39306) * 20;
+acc += Math.sin(39306) + Math.cos(39307) * 21;
+acc += Math.sin(39307) + Math.cos(39308) * 22;
+acc += Math.sin(39308) + Math.cos(39309) * 23;
+acc += Math.sin(39309) + Math.cos(39310) * 24;
+acc += Math.sin(39310) + Math.cos(39311) * 25;
+acc += Math.sin(39311) + Math.cos(39312) * 26;
+acc += Math.sin(39312) + Math.cos(39313) * 27;
+acc += Math.sin(39313) + Math.cos(39314) * 28;
+acc += Math.sin(39314) + Math.cos(39315) * 29;
+acc += Math.sin(39315) + Math.cos(39316) * 30;
+acc += Math.sin(39316) + Math.cos(39317) * 31;
+acc += Math.sin(39317) + Math.cos(39318) * 32;
+acc += Math.sin(39318) + Math.cos(39319) * 33;
+acc += Math.sin(39319) + Math.cos(39320) * 34;
+acc += Math.sin(39320) + Math.cos(39321) * 35;
+acc += Math.sin(39321) + Math.cos(39322) * 36;
+acc += Math.sin(39322) + Math.cos(39323) * 37;
+acc += Math.sin(39323) + Math.cos(39324) * 38;
+acc += Math.sin(39324) + Math.cos(39325) * 39;
+acc += Math.sin(39325) + Math.cos(39326) * 40;
+acc += Math.sin(39326) + Math.cos(39327) * 41;
+acc += Math.sin(39327) + Math.cos(39328) * 42;
+acc += Math.sin(39328) + Math.cos(39329) * 43;
+acc += Math.sin(39329) + Math.cos(39330) * 44;
+acc += Math.sin(39330) + Math.cos(39331) * 45;
+acc += Math.sin(39331) + Math.cos(39332) * 46;
+acc += Math.sin(39332) + Math.cos(39333) * 47;
+acc += Math.sin(39333) + Math.cos(39334) * 48;
+acc += Math.sin(39334) + Math.cos(39335) * 49;
+acc += Math.sin(39335) + Math.cos(39336) * 50;
+acc += Math.sin(39336) + Math.cos(39337) * 51;
+acc += Math.sin(39337) + Math.cos(39338) * 52;
+acc += Math.sin(39338) + Math.cos(39339) * 53;
+acc += Math.sin(39339) + Math.cos(39340) * 54;
+acc += Math.sin(39340) + Math.cos(39341) * 55;
+acc += Math.sin(39341) + Math.cos(39342) * 56;
+acc += Math.sin(39342) + Math.cos(39343) * 57;
+acc += Math.sin(39343) + Math.cos(39344) * 58;
+acc += Math.sin(39344) + Math.cos(39345) * 59;
+acc += Math.sin(39345) + Math.cos(39346) * 60;
+acc += Math.sin(39346) + Math.cos(39347) * 61;
+acc += Math.sin(39347) + Math.cos(39348) * 62;
+acc += Math.sin(39348) + Math.cos(39349) * 63;
+acc += Math.sin(39349) + Math.cos(39350) * 64;
+acc += Math.sin(39350) + Math.cos(39351) * 65;
+acc += Math.sin(39351) + Math.cos(39352) * 66;
+acc += Math.sin(39352) + Math.cos(39353) * 67;
+acc += Math.sin(39353) + Math.cos(39354) * 68;
+acc += Math.sin(39354) + Math.cos(39355) * 69;
+acc += Math.sin(39355) + Math.cos(39356) * 70;
+acc += Math.sin(39356) + Math.cos(39357) * 71;
+acc += Math.sin(39357) + Math.cos(39358) * 72;
+acc += Math.sin(39358) + Math.cos(39359) * 73;
+acc += Math.sin(39359) + Math.cos(39360) * 74;
+acc += Math.sin(39360) + Math.cos(39361) * 75;
+acc += Math.sin(39361) + Math.cos(39362) * 76;
+acc += Math.sin(39362) + Math.cos(39363) * 77;
+acc += Math.sin(39363) + Math.cos(39364) * 78;
+acc += Math.sin(39364) + Math.cos(39365) * 79;
+acc += Math.sin(39365) + Math.cos(39366) * 80;
+acc += Math.sin(39366) + Math.cos(39367) * 81;
+acc += Math.sin(39367) + Math.cos(39368) * 82;
+acc += Math.sin(39368) + Math.cos(39369) * 83;
+acc += Math.sin(39369) + Math.cos(39370) * 84;
+acc += Math.sin(39370) + Math.cos(39371) * 85;
+acc += Math.sin(39371) + Math.cos(39372) * 86;
+acc += Math.sin(39372) + Math.cos(39373) * 87;
+acc += Math.sin(39373) + Math.cos(39374) * 88;
+acc += Math.sin(39374) + Math.cos(39375) * 89;
+acc += Math.sin(39375) + Math.cos(39376) * 90;
+acc += Math.sin(39376) + Math.cos(39377) * 91;
+acc += Math.sin(39377) + Math.cos(39378) * 92;
+acc += Math.sin(39378) + Math.cos(39379) * 93;
+acc += Math.sin(39379) + Math.cos(39380) * 94;
+acc += Math.sin(39380) + Math.cos(39381) * 95;
+acc += Math.sin(39381) + Math.cos(39382) * 96;
+acc += Math.sin(39382) + Math.cos(39383) * 0;
+acc += Math.sin(39383) + Math.cos(39384) * 1;
+acc += Math.sin(39384) + Math.cos(39385) * 2;
+acc += Math.sin(39385) + Math.cos(39386) * 3;
+acc += Math.sin(39386) + Math.cos(39387) * 4;
+acc += Math.sin(39387) + Math.cos(39388) * 5;
+acc += Math.sin(39388) + Math.cos(39389) * 6;
+acc += Math.sin(39389) + Math.cos(39390) * 7;
+acc += Math.sin(39390) + Math.cos(39391) * 8;
+acc += Math.sin(39391) + Math.cos(39392) * 9;
+acc += Math.sin(39392) + Math.cos(39393) * 10;
+acc += Math.sin(39393) + Math.cos(39394) * 11;
+acc += Math.sin(39394) + Math.cos(39395) * 12;
+acc += Math.sin(39395) + Math.cos(39396) * 13;
+acc += Math.sin(39396) + Math.cos(39397) * 14;
+acc += Math.sin(39397) + Math.cos(39398) * 15;
+acc += Math.sin(39398) + Math.cos(39399) * 16;
+acc += Math.sin(39399) + Math.cos(39400) * 17;
+acc += Math.sin(39400) + Math.cos(39401) * 18;
+acc += Math.sin(39401) + Math.cos(39402) * 19;
+acc += Math.sin(39402) + Math.cos(39403) * 20;
+acc += Math.sin(39403) + Math.cos(39404) * 21;
+acc += Math.sin(39404) + Math.cos(39405) * 22;
+acc += Math.sin(39405) + Math.cos(39406) * 23;
+acc += Math.sin(39406) + Math.cos(39407) * 24;
+acc += Math.sin(39407) + Math.cos(39408) * 25;
+acc += Math.sin(39408) + Math.cos(39409) * 26;
+acc += Math.sin(39409) + Math.cos(39410) * 27;
+acc += Math.sin(39410) + Math.cos(39411) * 28;
+acc += Math.sin(39411) + Math.cos(39412) * 29;
+acc += Math.sin(39412) + Math.cos(39413) * 30;
+acc += Math.sin(39413) + Math.cos(39414) * 31;
+acc += Math.sin(39414) + Math.cos(39415) * 32;
+acc += Math.sin(39415) + Math.cos(39416) * 33;
+acc += Math.sin(39416) + Math.cos(39417) * 34;
+acc += Math.sin(39417) + Math.cos(39418) * 35;
+acc += Math.sin(39418) + Math.cos(39419) * 36;
+acc += Math.sin(39419) + Math.cos(39420) * 37;
+acc += Math.sin(39420) + Math.cos(39421) * 38;
+acc += Math.sin(39421) + Math.cos(39422) * 39;
+acc += Math.sin(39422) + Math.cos(39423) * 40;
+acc += Math.sin(39423) + Math.cos(39424) * 41;
+acc += Math.sin(39424) + Math.cos(39425) * 42;
+acc += Math.sin(39425) + Math.cos(39426) * 43;
+acc += Math.sin(39426) + Math.cos(39427) * 44;
+acc += Math.sin(39427) + Math.cos(39428) * 45;
+acc += Math.sin(39428) + Math.cos(39429) * 46;
+acc += Math.sin(39429) + Math.cos(39430) * 47;
+acc += Math.sin(39430) + Math.cos(39431) * 48;
+acc += Math.sin(39431) + Math.cos(39432) * 49;
+acc += Math.sin(39432) + Math.cos(39433) * 50;
+acc += Math.sin(39433) + Math.cos(39434) * 51;
+acc += Math.sin(39434) + Math.cos(39435) * 52;
+acc += Math.sin(39435) + Math.cos(39436) * 53;
+acc += Math.sin(39436) + Math.cos(39437) * 54;
+acc += Math.sin(39437) + Math.cos(39438) * 55;
+acc += Math.sin(39438) + Math.cos(39439) * 56;
+acc += Math.sin(39439) + Math.cos(39440) * 57;
+acc += Math.sin(39440) + Math.cos(39441) * 58;
+acc += Math.sin(39441) + Math.cos(39442) * 59;
+acc += Math.sin(39442) + Math.cos(39443) * 60;
+acc += Math.sin(39443) + Math.cos(39444) * 61;
+acc += Math.sin(39444) + Math.cos(39445) * 62;
+acc += Math.sin(39445) + Math.cos(39446) * 63;
+acc += Math.sin(39446) + Math.cos(39447) * 64;
+acc += Math.sin(39447) + Math.cos(39448) * 65;
+acc += Math.sin(39448) + Math.cos(39449) * 66;
+acc += Math.sin(39449) + Math.cos(39450) * 67;
+acc += Math.sin(39450) + Math.cos(39451) * 68;
+acc += Math.sin(39451) + Math.cos(39452) * 69;
+acc += Math.sin(39452) + Math.cos(39453) * 70;
+acc += Math.sin(39453) + Math.cos(39454) * 71;
+acc += Math.sin(39454) + Math.cos(39455) * 72;
+acc += Math.sin(39455) + Math.cos(39456) * 73;
+acc += Math.sin(39456) + Math.cos(39457) * 74;
+acc += Math.sin(39457) + Math.cos(39458) * 75;
+acc += Math.sin(39458) + Math.cos(39459) * 76;
+acc += Math.sin(39459) + Math.cos(39460) * 77;
+acc += Math.sin(39460) + Math.cos(39461) * 78;
+acc += Math.sin(39461) + Math.cos(39462) * 79;
+acc += Math.sin(39462) + Math.cos(39463) * 80;
+acc += Math.sin(39463) + Math.cos(39464) * 81;
+acc += Math.sin(39464) + Math.cos(39465) * 82;
+acc += Math.sin(39465) + Math.cos(39466) * 83;
+acc += Math.sin(39466) + Math.cos(39467) * 84;
+acc += Math.sin(39467) + Math.cos(39468) * 85;
+acc += Math.sin(39468) + Math.cos(39469) * 86;
+acc += Math.sin(39469) + Math.cos(39470) * 87;
+acc += Math.sin(39470) + Math.cos(39471) * 88;
+acc += Math.sin(39471) + Math.cos(39472) * 89;
+acc += Math.sin(39472) + Math.cos(39473) * 90;
+acc += Math.sin(39473) + Math.cos(39474) * 91;
+acc += Math.sin(39474) + Math.cos(39475) * 92;
+acc += Math.sin(39475) + Math.cos(39476) * 93;
+acc += Math.sin(39476) + Math.cos(39477) * 94;
+acc += Math.sin(39477) + Math.cos(39478) * 95;
+acc += Math.sin(39478) + Math.cos(39479) * 96;
+acc += Math.sin(39479) + Math.cos(39480) * 0;
+acc += Math.sin(39480) + Math.cos(39481) * 1;
+acc += Math.sin(39481) + Math.cos(39482) * 2;
+acc += Math.sin(39482) + Math.cos(39483) * 3;
+acc += Math.sin(39483) + Math.cos(39484) * 4;
+acc += Math.sin(39484) + Math.cos(39485) * 5;
+acc += Math.sin(39485) + Math.cos(39486) * 6;
+acc += Math.sin(39486) + Math.cos(39487) * 7;
+acc += Math.sin(39487) + Math.cos(39488) * 8;
+acc += Math.sin(39488) + Math.cos(39489) * 9;
+acc += Math.sin(39489) + Math.cos(39490) * 10;
+acc += Math.sin(39490) + Math.cos(39491) * 11;
+acc += Math.sin(39491) + Math.cos(39492) * 12;
+acc += Math.sin(39492) + Math.cos(39493) * 13;
+acc += Math.sin(39493) + Math.cos(39494) * 14;
+acc += Math.sin(39494) + Math.cos(39495) * 15;
+acc += Math.sin(39495) + Math.cos(39496) * 16;
+acc += Math.sin(39496) + Math.cos(39497) * 17;
+acc += Math.sin(39497) + Math.cos(39498) * 18;
+acc += Math.sin(39498) + Math.cos(39499) * 19;
+acc += Math.sin(39499) + Math.cos(39500) * 20;
+acc += Math.sin(39500) + Math.cos(39501) * 21;
+acc += Math.sin(39501) + Math.cos(39502) * 22;
+acc += Math.sin(39502) + Math.cos(39503) * 23;
+acc += Math.sin(39503) + Math.cos(39504) * 24;
+acc += Math.sin(39504) + Math.cos(39505) * 25;
+acc += Math.sin(39505) + Math.cos(39506) * 26;
+acc += Math.sin(39506) + Math.cos(39507) * 27;
+acc += Math.sin(39507) + Math.cos(39508) * 28;
+acc += Math.sin(39508) + Math.cos(39509) * 29;
+acc += Math.sin(39509) + Math.cos(39510) * 30;
+acc += Math.sin(39510) + Math.cos(39511) * 31;
+acc += Math.sin(39511) + Math.cos(39512) * 32;
+acc += Math.sin(39512) + Math.cos(39513) * 33;
+acc += Math.sin(39513) + Math.cos(39514) * 34;
+acc += Math.sin(39514) + Math.cos(39515) * 35;
+acc += Math.sin(39515) + Math.cos(39516) * 36;
+acc += Math.sin(39516) + Math.cos(39517) * 37;
+acc += Math.sin(39517) + Math.cos(39518) * 38;
+acc += Math.sin(39518) + Math.cos(39519) * 39;
+acc += Math.sin(39519) + Math.cos(39520) * 40;
+acc += Math.sin(39520) + Math.cos(39521) * 41;
+acc += Math.sin(39521) + Math.cos(39522) * 42;
+acc += Math.sin(39522) + Math.cos(39523) * 43;
+acc += Math.sin(39523) + Math.cos(39524) * 44;
+acc += Math.sin(39524) + Math.cos(39525) * 45;
+acc += Math.sin(39525) + Math.cos(39526) * 46;
+acc += Math.sin(39526) + Math.cos(39527) * 47;
+acc += Math.sin(39527) + Math.cos(39528) * 48;
+acc += Math.sin(39528) + Math.cos(39529) * 49;
+acc += Math.sin(39529) + Math.cos(39530) * 50;
+acc += Math.sin(39530) + Math.cos(39531) * 51;
+acc += Math.sin(39531) + Math.cos(39532) * 52;
+acc += Math.sin(39532) + Math.cos(39533) * 53;
+acc += Math.sin(39533) + Math.cos(39534) * 54;
+acc += Math.sin(39534) + Math.cos(39535) * 55;
+acc += Math.sin(39535) + Math.cos(39536) * 56;
+acc += Math.sin(39536) + Math.cos(39537) * 57;
+acc += Math.sin(39537) + Math.cos(39538) * 58;
+acc += Math.sin(39538) + Math.cos(39539) * 59;
+acc += Math.sin(39539) + Math.cos(39540) * 60;
+acc += Math.sin(39540) + Math.cos(39541) * 61;
+acc += Math.sin(39541) + Math.cos(39542) * 62;
+acc += Math.sin(39542) + Math.cos(39543) * 63;
+acc += Math.sin(39543) + Math.cos(39544) * 64;
+acc += Math.sin(39544) + Math.cos(39545) * 65;
+acc += Math.sin(39545) + Math.cos(39546) * 66;
+acc += Math.sin(39546) + Math.cos(39547) * 67;
+acc += Math.sin(39547) + Math.cos(39548) * 68;
+acc += Math.sin(39548) + Math.cos(39549) * 69;
+acc += Math.sin(39549) + Math.cos(39550) * 70;
+acc += Math.sin(39550) + Math.cos(39551) * 71;
+acc += Math.sin(39551) + Math.cos(39552) * 72;
+acc += Math.sin(39552) + Math.cos(39553) * 73;
+acc += Math.sin(39553) + Math.cos(39554) * 74;
+acc += Math.sin(39554) + Math.cos(39555) * 75;
+acc += Math.sin(39555) + Math.cos(39556) * 76;
+acc += Math.sin(39556) + Math.cos(39557) * 77;
+acc += Math.sin(39557) + Math.cos(39558) * 78;
+acc += Math.sin(39558) + Math.cos(39559) * 79;
+acc += Math.sin(39559) + Math.cos(39560) * 80;
+acc += Math.sin(39560) + Math.cos(39561) * 81;
+acc += Math.sin(39561) + Math.cos(39562) * 82;
+acc += Math.sin(39562) + Math.cos(39563) * 83;
+acc += Math.sin(39563) + Math.cos(39564) * 84;
+acc += Math.sin(39564) + Math.cos(39565) * 85;
+acc += Math.sin(39565) + Math.cos(39566) * 86;
+acc += Math.sin(39566) + Math.cos(39567) * 87;
+acc += Math.sin(39567) + Math.cos(39568) * 88;
+acc += Math.sin(39568) + Math.cos(39569) * 89;
+acc += Math.sin(39569) + Math.cos(39570) * 90;
+acc += Math.sin(39570) + Math.cos(39571) * 91;
+acc += Math.sin(39571) + Math.cos(39572) * 92;
+acc += Math.sin(39572) + Math.cos(39573) * 93;
+acc += Math.sin(39573) + Math.cos(39574) * 94;
+acc += Math.sin(39574) + Math.cos(39575) * 95;
+acc += Math.sin(39575) + Math.cos(39576) * 96;
+acc += Math.sin(39576) + Math.cos(39577) * 0;
+acc += Math.sin(39577) + Math.cos(39578) * 1;
+acc += Math.sin(39578) + Math.cos(39579) * 2;
+acc += Math.sin(39579) + Math.cos(39580) * 3;
+acc += Math.sin(39580) + Math.cos(39581) * 4;
+acc += Math.sin(39581) + Math.cos(39582) * 5;
+acc += Math.sin(39582) + Math.cos(39583) * 6;
+acc += Math.sin(39583) + Math.cos(39584) * 7;
+acc += Math.sin(39584) + Math.cos(39585) * 8;
+acc += Math.sin(39585) + Math.cos(39586) * 9;
+acc += Math.sin(39586) + Math.cos(39587) * 10;
+acc += Math.sin(39587) + Math.cos(39588) * 11;
+acc += Math.sin(39588) + Math.cos(39589) * 12;
+acc += Math.sin(39589) + Math.cos(39590) * 13;
+acc += Math.sin(39590) + Math.cos(39591) * 14;
+acc += Math.sin(39591) + Math.cos(39592) * 15;
+acc += Math.sin(39592) + Math.cos(39593) * 16;
+acc += Math.sin(39593) + Math.cos(39594) * 17;
+acc += Math.sin(39594) + Math.cos(39595) * 18;
+acc += Math.sin(39595) + Math.cos(39596) * 19;
+acc += Math.sin(39596) + Math.cos(39597) * 20;
+acc += Math.sin(39597) + Math.cos(39598) * 21;
+acc += Math.sin(39598) + Math.cos(39599) * 22;
+acc += Math.sin(39599) + Math.cos(39600) * 23;
+acc += Math.sin(39600) + Math.cos(39601) * 24;
+acc += Math.sin(39601) + Math.cos(39602) * 25;
+acc += Math.sin(39602) + Math.cos(39603) * 26;
+acc += Math.sin(39603) + Math.cos(39604) * 27;
+acc += Math.sin(39604) + Math.cos(39605) * 28;
+acc += Math.sin(39605) + Math.cos(39606) * 29;
+acc += Math.sin(39606) + Math.cos(39607) * 30;
+acc += Math.sin(39607) + Math.cos(39608) * 31;
+acc += Math.sin(39608) + Math.cos(39609) * 32;
+acc += Math.sin(39609) + Math.cos(39610) * 33;
+acc += Math.sin(39610) + Math.cos(39611) * 34;
+acc += Math.sin(39611) + Math.cos(39612) * 35;
+acc += Math.sin(39612) + Math.cos(39613) * 36;
+acc += Math.sin(39613) + Math.cos(39614) * 37;
+acc += Math.sin(39614) + Math.cos(39615) * 38;
+acc += Math.sin(39615) + Math.cos(39616) * 39;
+acc += Math.sin(39616) + Math.cos(39617) * 40;
+acc += Math.sin(39617) + Math.cos(39618) * 41;
+acc += Math.sin(39618) + Math.cos(39619) * 42;
+acc += Math.sin(39619) + Math.cos(39620) * 43;
+acc += Math.sin(39620) + Math.cos(39621) * 44;
+acc += Math.sin(39621) + Math.cos(39622) * 45;
+acc += Math.sin(39622) + Math.cos(39623) * 46;
+acc += Math.sin(39623) + Math.cos(39624) * 47;
+acc += Math.sin(39624) + Math.cos(39625) * 48;
+acc += Math.sin(39625) + Math.cos(39626) * 49;
+acc += Math.sin(39626) + Math.cos(39627) * 50;
+acc += Math.sin(39627) + Math.cos(39628) * 51;
+acc += Math.sin(39628) + Math.cos(39629) * 52;
+acc += Math.sin(39629) + Math.cos(39630) * 53;
+acc += Math.sin(39630) + Math.cos(39631) * 54;
+acc += Math.sin(39631) + Math.cos(39632) * 55;
+acc += Math.sin(39632) + Math.cos(39633) * 56;
+acc += Math.sin(39633) + Math.cos(39634) * 57;
+acc += Math.sin(39634) + Math.cos(39635) * 58;
+acc += Math.sin(39635) + Math.cos(39636) * 59;
+acc += Math.sin(39636) + Math.cos(39637) * 60;
+acc += Math.sin(39637) + Math.cos(39638) * 61;
+acc += Math.sin(39638) + Math.cos(39639) * 62;
+acc += Math.sin(39639) + Math.cos(39640) * 63;
+acc += Math.sin(39640) + Math.cos(39641) * 64;
+acc += Math.sin(39641) + Math.cos(39642) * 65;
+acc += Math.sin(39642) + Math.cos(39643) * 66;
+acc += Math.sin(39643) + Math.cos(39644) * 67;
+acc += Math.sin(39644) + Math.cos(39645) * 68;
+acc += Math.sin(39645) + Math.cos(39646) * 69;
+acc += Math.sin(39646) + Math.cos(39647) * 70;
+acc += Math.sin(39647) + Math.cos(39648) * 71;
+acc += Math.sin(39648) + Math.cos(39649) * 72;
+acc += Math.sin(39649) + Math.cos(39650) * 73;
+acc += Math.sin(39650) + Math.cos(39651) * 74;
+acc += Math.sin(39651) + Math.cos(39652) * 75;
+acc += Math.sin(39652) + Math.cos(39653) * 76;
+acc += Math.sin(39653) + Math.cos(39654) * 77;
+acc += Math.sin(39654) + Math.cos(39655) * 78;
+acc += Math.sin(39655) + Math.cos(39656) * 79;
+acc += Math.sin(39656) + Math.cos(39657) * 80;
+acc += Math.sin(39657) + Math.cos(39658) * 81;
+acc += Math.sin(39658) + Math.cos(39659) * 82;
+acc += Math.sin(39659) + Math.cos(39660) * 83;
+acc += Math.sin(39660) + Math.cos(39661) * 84;
+acc += Math.sin(39661) + Math.cos(39662) * 85;
+acc += Math.sin(39662) + Math.cos(39663) * 86;
+acc += Math.sin(39663) + Math.cos(39664) * 87;
+acc += Math.sin(39664) + Math.cos(39665) * 88;
+acc += Math.sin(39665) + Math.cos(39666) * 89;
+acc += Math.sin(39666) + Math.cos(39667) * 90;
+acc += Math.sin(39667) + Math.cos(39668) * 91;
+acc += Math.sin(39668) + Math.cos(39669) * 92;
+acc += Math.sin(39669) + Math.cos(39670) * 93;
+acc += Math.sin(39670) + Math.cos(39671) * 94;
+acc += Math.sin(39671) + Math.cos(39672) * 95;
+acc += Math.sin(39672) + Math.cos(39673) * 96;
+acc += Math.sin(39673) + Math.cos(39674) * 0;
+acc += Math.sin(39674) + Math.cos(39675) * 1;
+acc += Math.sin(39675) + Math.cos(39676) * 2;
+acc += Math.sin(39676) + Math.cos(39677) * 3;
+acc += Math.sin(39677) + Math.cos(39678) * 4;
+acc += Math.sin(39678) + Math.cos(39679) * 5;
+acc += Math.sin(39679) + Math.cos(39680) * 6;
+acc += Math.sin(39680) + Math.cos(39681) * 7;
+acc += Math.sin(39681) + Math.cos(39682) * 8;
+acc += Math.sin(39682) + Math.cos(39683) * 9;
+acc += Math.sin(39683) + Math.cos(39684) * 10;
+acc += Math.sin(39684) + Math.cos(39685) * 11;
+acc += Math.sin(39685) + Math.cos(39686) * 12;
+acc += Math.sin(39686) + Math.cos(39687) * 13;
+acc += Math.sin(39687) + Math.cos(39688) * 14;
+acc += Math.sin(39688) + Math.cos(39689) * 15;
+acc += Math.sin(39689) + Math.cos(39690) * 16;
+acc += Math.sin(39690) + Math.cos(39691) * 17;
+acc += Math.sin(39691) + Math.cos(39692) * 18;
+acc += Math.sin(39692) + Math.cos(39693) * 19;
+acc += Math.sin(39693) + Math.cos(39694) * 20;
+acc += Math.sin(39694) + Math.cos(39695) * 21;
+acc += Math.sin(39695) + Math.cos(39696) * 22;
+acc += Math.sin(39696) + Math.cos(39697) * 23;
+acc += Math.sin(39697) + Math.cos(39698) * 24;
+acc += Math.sin(39698) + Math.cos(39699) * 25;
+acc += Math.sin(39699) + Math.cos(39700) * 26;
+acc += Math.sin(39700) + Math.cos(39701) * 27;
+acc += Math.sin(39701) + Math.cos(39702) * 28;
+acc += Math.sin(39702) + Math.cos(39703) * 29;
+acc += Math.sin(39703) + Math.cos(39704) * 30;
+acc += Math.sin(39704) + Math.cos(39705) * 31;
+acc += Math.sin(39705) + Math.cos(39706) * 32;
+acc += Math.sin(39706) + Math.cos(39707) * 33;
+acc += Math.sin(39707) + Math.cos(39708) * 34;
+acc += Math.sin(39708) + Math.cos(39709) * 35;
+acc += Math.sin(39709) + Math.cos(39710) * 36;
+acc += Math.sin(39710) + Math.cos(39711) * 37;
+acc += Math.sin(39711) + Math.cos(39712) * 38;
+acc += Math.sin(39712) + Math.cos(39713) * 39;
+acc += Math.sin(39713) + Math.cos(39714) * 40;
+acc += Math.sin(39714) + Math.cos(39715) * 41;
+acc += Math.sin(39715) + Math.cos(39716) * 42;
+acc += Math.sin(39716) + Math.cos(39717) * 43;
+acc += Math.sin(39717) + Math.cos(39718) * 44;
+acc += Math.sin(39718) + Math.cos(39719) * 45;
+acc += Math.sin(39719) + Math.cos(39720) * 46;
+acc += Math.sin(39720) + Math.cos(39721) * 47;
+acc += Math.sin(39721) + Math.cos(39722) * 48;
+acc += Math.sin(39722) + Math.cos(39723) * 49;
+acc += Math.sin(39723) + Math.cos(39724) * 50;
+acc += Math.sin(39724) + Math.cos(39725) * 51;
+acc += Math.sin(39725) + Math.cos(39726) * 52;
+acc += Math.sin(39726) + Math.cos(39727) * 53;
+acc += Math.sin(39727) + Math.cos(39728) * 54;
+acc += Math.sin(39728) + Math.cos(39729) * 55;
+acc += Math.sin(39729) + Math.cos(39730) * 56;
+acc += Math.sin(39730) + Math.cos(39731) * 57;
+acc += Math.sin(39731) + Math.cos(39732) * 58;
+acc += Math.sin(39732) + Math.cos(39733) * 59;
+acc += Math.sin(39733) + Math.cos(39734) * 60;
+acc += Math.sin(39734) + Math.cos(39735) * 61;
+acc += Math.sin(39735) + Math.cos(39736) * 62;
+acc += Math.sin(39736) + Math.cos(39737) * 63;
+acc += Math.sin(39737) + Math.cos(39738) * 64;
+acc += Math.sin(39738) + Math.cos(39739) * 65;
+acc += Math.sin(39739) + Math.cos(39740) * 66;
+acc += Math.sin(39740) + Math.cos(39741) * 67;
+acc += Math.sin(39741) + Math.cos(39742) * 68;
+acc += Math.sin(39742) + Math.cos(39743) * 69;
+acc += Math.sin(39743) + Math.cos(39744) * 70;
+acc += Math.sin(39744) + Math.cos(39745) * 71;
+acc += Math.sin(39745) + Math.cos(39746) * 72;
+acc += Math.sin(39746) + Math.cos(39747) * 73;
+acc += Math.sin(39747) + Math.cos(39748) * 74;
+acc += Math.sin(39748) + Math.cos(39749) * 75;
+acc += Math.sin(39749) + Math.cos(39750) * 76;
+acc += Math.sin(39750) + Math.cos(39751) * 77;
+acc += Math.sin(39751) + Math.cos(39752) * 78;
+acc += Math.sin(39752) + Math.cos(39753) * 79;
+acc += Math.sin(39753) + Math.cos(39754) * 80;
+acc += Math.sin(39754) + Math.cos(39755) * 81;
+acc += Math.sin(39755) + Math.cos(39756) * 82;
+acc += Math.sin(39756) + Math.cos(39757) * 83;
+acc += Math.sin(39757) + Math.cos(39758) * 84;
+acc += Math.sin(39758) + Math.cos(39759) * 85;
+acc += Math.sin(39759) + Math.cos(39760) * 86;
+acc += Math.sin(39760) + Math.cos(39761) * 87;
+acc += Math.sin(39761) + Math.cos(39762) * 88;
+acc += Math.sin(39762) + Math.cos(39763) * 89;
+acc += Math.sin(39763) + Math.cos(39764) * 90;
+acc += Math.sin(39764) + Math.cos(39765) * 91;
+acc += Math.sin(39765) + Math.cos(39766) * 92;
+acc += Math.sin(39766) + Math.cos(39767) * 93;
+acc += Math.sin(39767) + Math.cos(39768) * 94;
+acc += Math.sin(39768) + Math.cos(39769) * 95;
+acc += Math.sin(39769) + Math.cos(39770) * 96;
+acc += Math.sin(39770) + Math.cos(39771) * 0;
+acc += Math.sin(39771) + Math.cos(39772) * 1;
+acc += Math.sin(39772) + Math.cos(39773) * 2;
+acc += Math.sin(39773) + Math.cos(39774) * 3;
+acc += Math.sin(39774) + Math.cos(39775) * 4;
+acc += Math.sin(39775) + Math.cos(39776) * 5;
+acc += Math.sin(39776) + Math.cos(39777) * 6;
+acc += Math.sin(39777) + Math.cos(39778) * 7;
+acc += Math.sin(39778) + Math.cos(39779) * 8;
+acc += Math.sin(39779) + Math.cos(39780) * 9;
+acc += Math.sin(39780) + Math.cos(39781) * 10;
+acc += Math.sin(39781) + Math.cos(39782) * 11;
+acc += Math.sin(39782) + Math.cos(39783) * 12;
+acc += Math.sin(39783) + Math.cos(39784) * 13;
+acc += Math.sin(39784) + Math.cos(39785) * 14;
+acc += Math.sin(39785) + Math.cos(39786) * 15;
+acc += Math.sin(39786) + Math.cos(39787) * 16;
+acc += Math.sin(39787) + Math.cos(39788) * 17;
+acc += Math.sin(39788) + Math.cos(39789) * 18;
+acc += Math.sin(39789) + Math.cos(39790) * 19;
+acc += Math.sin(39790) + Math.cos(39791) * 20;
+acc += Math.sin(39791) + Math.cos(39792) * 21;
+acc += Math.sin(39792) + Math.cos(39793) * 22;
+acc += Math.sin(39793) + Math.cos(39794) * 23;
+acc += Math.sin(39794) + Math.cos(39795) * 24;
+acc += Math.sin(39795) + Math.cos(39796) * 25;
+acc += Math.sin(39796) + Math.cos(39797) * 26;
+acc += Math.sin(39797) + Math.cos(39798) * 27;
+acc += Math.sin(39798) + Math.cos(39799) * 28;
+acc += Math.sin(39799) + Math.cos(39800) * 29;
+acc += Math.sin(39800) + Math.cos(39801) * 30;
+acc += Math.sin(39801) + Math.cos(39802) * 31;
+acc += Math.sin(39802) + Math.cos(39803) * 32;
+acc += Math.sin(39803) + Math.cos(39804) * 33;
+acc += Math.sin(39804) + Math.cos(39805) * 34;
+acc += Math.sin(39805) + Math.cos(39806) * 35;
+acc += Math.sin(39806) + Math.cos(39807) * 36;
+acc += Math.sin(39807) + Math.cos(39808) * 37;
+acc += Math.sin(39808) + Math.cos(39809) * 38;
+acc += Math.sin(39809) + Math.cos(39810) * 39;
+acc += Math.sin(39810) + Math.cos(39811) * 40;
+acc += Math.sin(39811) + Math.cos(39812) * 41;
+acc += Math.sin(39812) + Math.cos(39813) * 42;
+acc += Math.sin(39813) + Math.cos(39814) * 43;
+acc += Math.sin(39814) + Math.cos(39815) * 44;
+acc += Math.sin(39815) + Math.cos(39816) * 45;
+acc += Math.sin(39816) + Math.cos(39817) * 46;
+acc += Math.sin(39817) + Math.cos(39818) * 47;
+acc += Math.sin(39818) + Math.cos(39819) * 48;
+acc += Math.sin(39819) + Math.cos(39820) * 49;
+acc += Math.sin(39820) + Math.cos(39821) * 50;
+acc += Math.sin(39821) + Math.cos(39822) * 51;
+acc += Math.sin(39822) + Math.cos(39823) * 52;
+acc += Math.sin(39823) + Math.cos(39824) * 53;
+acc += Math.sin(39824) + Math.cos(39825) * 54;
+acc += Math.sin(39825) + Math.cos(39826) * 55;
+acc += Math.sin(39826) + Math.cos(39827) * 56;
+acc += Math.sin(39827) + Math.cos(39828) * 57;
+acc += Math.sin(39828) + Math.cos(39829) * 58;
+acc += Math.sin(39829) + Math.cos(39830) * 59;
+acc += Math.sin(39830) + Math.cos(39831) * 60;
+acc += Math.sin(39831) + Math.cos(39832) * 61;
+acc += Math.sin(39832) + Math.cos(39833) * 62;
+acc += Math.sin(39833) + Math.cos(39834) * 63;
+acc += Math.sin(39834) + Math.cos(39835) * 64;
+acc += Math.sin(39835) + Math.cos(39836) * 65;
+acc += Math.sin(39836) + Math.cos(39837) * 66;
+acc += Math.sin(39837) + Math.cos(39838) * 67;
+acc += Math.sin(39838) + Math.cos(39839) * 68;
+acc += Math.sin(39839) + Math.cos(39840) * 69;
+acc += Math.sin(39840) + Math.cos(39841) * 70;
+acc += Math.sin(39841) + Math.cos(39842) * 71;
+acc += Math.sin(39842) + Math.cos(39843) * 72;
+acc += Math.sin(39843) + Math.cos(39844) * 73;
+acc += Math.sin(39844) + Math.cos(39845) * 74;
+acc += Math.sin(39845) + Math.cos(39846) * 75;
+acc += Math.sin(39846) + Math.cos(39847) * 76;
+acc += Math.sin(39847) + Math.cos(39848) * 77;
+acc += Math.sin(39848) + Math.cos(39849) * 78;
+acc += Math.sin(39849) + Math.cos(39850) * 79;
+acc += Math.sin(39850) + Math.cos(39851) * 80;
+acc += Math.sin(39851) + Math.cos(39852) * 81;
+acc += Math.sin(39852) + Math.cos(39853) * 82;
+acc += Math.sin(39853) + Math.cos(39854) * 83;
+acc += Math.sin(39854) + Math.cos(39855) * 84;
+acc += Math.sin(39855) + Math.cos(39856) * 85;
+acc += Math.sin(39856) + Math.cos(39857) * 86;
+acc += Math.sin(39857) + Math.cos(39858) * 87;
+acc += Math.sin(39858) + Math.cos(39859) * 88;
+acc += Math.sin(39859) + Math.cos(39860) * 89;
+acc += Math.sin(39860) + Math.cos(39861) * 90;
+acc += Math.sin(39861) + Math.cos(39862) * 91;
+acc += Math.sin(39862) + Math.cos(39863) * 92;
+acc += Math.sin(39863) + Math.cos(39864) * 93;
+acc += Math.sin(39864) + Math.cos(39865) * 94;
+acc += Math.sin(39865) + Math.cos(39866) * 95;
+acc += Math.sin(39866) + Math.cos(39867) * 96;
+acc += Math.sin(39867) + Math.cos(39868) * 0;
+acc += Math.sin(39868) + Math.cos(39869) * 1;
+acc += Math.sin(39869) + Math.cos(39870) * 2;
+acc += Math.sin(39870) + Math.cos(39871) * 3;
+acc += Math.sin(39871) + Math.cos(39872) * 4;
+acc += Math.sin(39872) + Math.cos(39873) * 5;
+acc += Math.sin(39873) + Math.cos(39874) * 6;
+acc += Math.sin(39874) + Math.cos(39875) * 7;
+acc += Math.sin(39875) + Math.cos(39876) * 8;
+acc += Math.sin(39876) + Math.cos(39877) * 9;
+acc += Math.sin(39877) + Math.cos(39878) * 10;
+acc += Math.sin(39878) + Math.cos(39879) * 11;
+acc += Math.sin(39879) + Math.cos(39880) * 12;
+acc += Math.sin(39880) + Math.cos(39881) * 13;
+acc += Math.sin(39881) + Math.cos(39882) * 14;
+acc += Math.sin(39882) + Math.cos(39883) * 15;
+acc += Math.sin(39883) + Math.cos(39884) * 16;
+acc += Math.sin(39884) + Math.cos(39885) * 17;
+acc += Math.sin(39885) + Math.cos(39886) * 18;
+acc += Math.sin(39886) + Math.cos(39887) * 19;
+acc += Math.sin(39887) + Math.cos(39888) * 20;
+acc += Math.sin(39888) + Math.cos(39889) * 21;
+acc += Math.sin(39889) + Math.cos(39890) * 22;
+acc += Math.sin(39890) + Math.cos(39891) * 23;
+acc += Math.sin(39891) + Math.cos(39892) * 24;
+acc += Math.sin(39892) + Math.cos(39893) * 25;
+acc += Math.sin(39893) + Math.cos(39894) * 26;
+acc += Math.sin(39894) + Math.cos(39895) * 27;
+acc += Math.sin(39895) + Math.cos(39896) * 28;
+acc += Math.sin(39896) + Math.cos(39897) * 29;
+acc += Math.sin(39897) + Math.cos(39898) * 30;
+acc += Math.sin(39898) + Math.cos(39899) * 31;
+acc += Math.sin(39899) + Math.cos(39900) * 32;
+acc += Math.sin(39900) + Math.cos(39901) * 33;
+acc += Math.sin(39901) + Math.cos(39902) * 34;
+acc += Math.sin(39902) + Math.cos(39903) * 35;
+acc += Math.sin(39903) + Math.cos(39904) * 36;
+acc += Math.sin(39904) + Math.cos(39905) * 37;
+acc += Math.sin(39905) + Math.cos(39906) * 38;
+acc += Math.sin(39906) + Math.cos(39907) * 39;
+acc += Math.sin(39907) + Math.cos(39908) * 40;
+acc += Math.sin(39908) + Math.cos(39909) * 41;
+acc += Math.sin(39909) + Math.cos(39910) * 42;
+acc += Math.sin(39910) + Math.cos(39911) * 43;
+acc += Math.sin(39911) + Math.cos(39912) * 44;
+acc += Math.sin(39912) + Math.cos(39913) * 45;
+acc += Math.sin(39913) + Math.cos(39914) * 46;
+acc += Math.sin(39914) + Math.cos(39915) * 47;
+acc += Math.sin(39915) + Math.cos(39916) * 48;
+acc += Math.sin(39916) + Math.cos(39917) * 49;
+acc += Math.sin(39917) + Math.cos(39918) * 50;
+acc += Math.sin(39918) + Math.cos(39919) * 51;
+acc += Math.sin(39919) + Math.cos(39920) * 52;
+acc += Math.sin(39920) + Math.cos(39921) * 53;
+acc += Math.sin(39921) + Math.cos(39922) * 54;
+acc += Math.sin(39922) + Math.cos(39923) * 55;
+acc += Math.sin(39923) + Math.cos(39924) * 56;
+acc += Math.sin(39924) + Math.cos(39925) * 57;
+acc += Math.sin(39925) + Math.cos(39926) * 58;
+acc += Math.sin(39926) + Math.cos(39927) * 59;
+acc += Math.sin(39927) + Math.cos(39928) * 60;
+acc += Math.sin(39928) + Math.cos(39929) * 61;
+acc += Math.sin(39929) + Math.cos(39930) * 62;
+acc += Math.sin(39930) + Math.cos(39931) * 63;
+acc += Math.sin(39931) + Math.cos(39932) * 64;
+acc += Math.sin(39932) + Math.cos(39933) * 65;
+acc += Math.sin(39933) + Math.cos(39934) * 66;
+acc += Math.sin(39934) + Math.cos(39935) * 67;
+acc += Math.sin(39935) + Math.cos(39936) * 68;
+acc += Math.sin(39936) + Math.cos(39937) * 69;
+acc += Math.sin(39937) + Math.cos(39938) * 70;
+acc += Math.sin(39938) + Math.cos(39939) * 71;
+acc += Math.sin(39939) + Math.cos(39940) * 72;
+acc += Math.sin(39940) + Math.cos(39941) * 73;
+acc += Math.sin(39941) + Math.cos(39942) * 74;
+acc += Math.sin(39942) + Math.cos(39943) * 75;
+acc += Math.sin(39943) + Math.cos(39944) * 76;
+acc += Math.sin(39944) + Math.cos(39945) * 77;
+acc += Math.sin(39945) + Math.cos(39946) * 78;
+acc += Math.sin(39946) + Math.cos(39947) * 79;
+acc += Math.sin(39947) + Math.cos(39948) * 80;
+acc += Math.sin(39948) + Math.cos(39949) * 81;
+acc += Math.sin(39949) + Math.cos(39950) * 82;
+acc += Math.sin(39950) + Math.cos(39951) * 83;
+acc += Math.sin(39951) + Math.cos(39952) * 84;
+acc += Math.sin(39952) + Math.cos(39953) * 85;
+acc += Math.sin(39953) + Math.cos(39954) * 86;
+acc += Math.sin(39954) + Math.cos(39955) * 87;
+acc += Math.sin(39955) + Math.cos(39956) * 88;
+acc += Math.sin(39956) + Math.cos(39957) * 89;
+acc += Math.sin(39957) + Math.cos(39958) * 90;
+acc += Math.sin(39958) + Math.cos(39959) * 91;
+acc += Math.sin(39959) + Math.cos(39960) * 92;
+acc += Math.sin(39960) + Math.cos(39961) * 93;
+acc += Math.sin(39961) + Math.cos(39962) * 94;
+acc += Math.sin(39962) + Math.cos(39963) * 95;
+acc += Math.sin(39963) + Math.cos(39964) * 96;
+acc += Math.sin(39964) + Math.cos(39965) * 0;
+acc += Math.sin(39965) + Math.cos(39966) * 1;
+acc += Math.sin(39966) + Math.cos(39967) * 2;
+acc += Math.sin(39967) + Math.cos(39968) * 3;
+acc += Math.sin(39968) + Math.cos(39969) * 4;
+acc += Math.sin(39969) + Math.cos(39970) * 5;
+acc += Math.sin(39970) + Math.cos(39971) * 6;
+acc += Math.sin(39971) + Math.cos(39972) * 7;
+acc += Math.sin(39972) + Math.cos(39973) * 8;
+acc += Math.sin(39973) + Math.cos(39974) * 9;
+acc += Math.sin(39974) + Math.cos(39975) * 10;
+acc += Math.sin(39975) + Math.cos(39976) * 11;
+acc += Math.sin(39976) + Math.cos(39977) * 12;
+acc += Math.sin(39977) + Math.cos(39978) * 13;
+acc += Math.sin(39978) + Math.cos(39979) * 14;
+acc += Math.sin(39979) + Math.cos(39980) * 15;
+acc += Math.sin(39980) + Math.cos(39981) * 16;
+acc += Math.sin(39981) + Math.cos(39982) * 17;
+acc += Math.sin(39982) + Math.cos(39983) * 18;
+acc += Math.sin(39983) + Math.cos(39984) * 19;
+acc += Math.sin(39984) + Math.cos(39985) * 20;
+acc += Math.sin(39985) + Math.cos(39986) * 21;
+acc += Math.sin(39986) + Math.cos(39987) * 22;
+acc += Math.sin(39987) + Math.cos(39988) * 23;
+acc += Math.sin(39988) + Math.cos(39989) * 24;
+acc += Math.sin(39989) + Math.cos(39990) * 25;
+acc += Math.sin(39990) + Math.cos(39991) * 26;
+acc += Math.sin(39991) + Math.cos(39992) * 27;
+acc += Math.sin(39992) + Math.cos(39993) * 28;
+acc += Math.sin(39993) + Math.cos(39994) * 29;
+acc += Math.sin(39994) + Math.cos(39995) * 30;
+acc += Math.sin(39995) + Math.cos(39996) * 31;
+acc += Math.sin(39996) + Math.cos(39997) * 32;
+acc += Math.sin(39997) + Math.cos(39998) * 33;
+acc += Math.sin(39998) + Math.cos(39999) * 34;
+acc += Math.sin(39999) + Math.cos(40000) * 35;
+acc += Math.sin(40000) + Math.cos(40001) * 36;
+acc += Math.sin(40001) + Math.cos(40002) * 37;
+acc += Math.sin(40002) + Math.cos(40003) * 38;
+acc += Math.sin(40003) + Math.cos(40004) * 39;
+acc += Math.sin(40004) + Math.cos(40005) * 40;
+acc += Math.sin(40005) + Math.cos(40006) * 41;
+acc += Math.sin(40006) + Math.cos(40007) * 42;
+acc += Math.sin(40007) + Math.cos(40008) * 43;
+acc += Math.sin(40008) + Math.cos(40009) * 44;
+acc += Math.sin(40009) + Math.cos(40010) * 45;
+acc += Math.sin(40010) + Math.cos(40011) * 46;
+acc += Math.sin(40011) + Math.cos(40012) * 47;
+acc += Math.sin(40012) + Math.cos(40013) * 48;
+acc += Math.sin(40013) + Math.cos(40014) * 49;
+acc += Math.sin(40014) + Math.cos(40015) * 50;
+acc += Math.sin(40015) + Math.cos(40016) * 51;
+acc += Math.sin(40016) + Math.cos(40017) * 52;
+acc += Math.sin(40017) + Math.cos(40018) * 53;
+acc += Math.sin(40018) + Math.cos(40019) * 54;
+acc += Math.sin(40019) + Math.cos(40020) * 55;
+acc += Math.sin(40020) + Math.cos(40021) * 56;
+acc += Math.sin(40021) + Math.cos(40022) * 57;
+acc += Math.sin(40022) + Math.cos(40023) * 58;
+acc += Math.sin(40023) + Math.cos(40024) * 59;
+acc += Math.sin(40024) + Math.cos(40025) * 60;
+acc += Math.sin(40025) + Math.cos(40026) * 61;
+acc += Math.sin(40026) + Math.cos(40027) * 62;
+acc += Math.sin(40027) + Math.cos(40028) * 63;
+acc += Math.sin(40028) + Math.cos(40029) * 64;
+acc += Math.sin(40029) + Math.cos(40030) * 65;
+acc += Math.sin(40030) + Math.cos(40031) * 66;
+acc += Math.sin(40031) + Math.cos(40032) * 67;
+acc += Math.sin(40032) + Math.cos(40033) * 68;
+acc += Math.sin(40033) + Math.cos(40034) * 69;
+acc += Math.sin(40034) + Math.cos(40035) * 70;
+acc += Math.sin(40035) + Math.cos(40036) * 71;
+acc += Math.sin(40036) + Math.cos(40037) * 72;
+acc += Math.sin(40037) + Math.cos(40038) * 73;
+acc += Math.sin(40038) + Math.cos(40039) * 74;
+acc += Math.sin(40039) + Math.cos(40040) * 75;
+acc += Math.sin(40040) + Math.cos(40041) * 76;
+acc += Math.sin(40041) + Math.cos(40042) * 77;
+acc += Math.sin(40042) + Math.cos(40043) * 78;
+acc += Math.sin(40043) + Math.cos(40044) * 79;
+acc += Math.sin(40044) + Math.cos(40045) * 80;
+acc += Math.sin(40045) + Math.cos(40046) * 81;
+acc += Math.sin(40046) + Math.cos(40047) * 82;
+acc += Math.sin(40047) + Math.cos(40048) * 83;
+acc += Math.sin(40048) + Math.cos(40049) * 84;
+acc += Math.sin(40049) + Math.cos(40050) * 85;
+acc += Math.sin(40050) + Math.cos(40051) * 86;
+acc += Math.sin(40051) + Math.cos(40052) * 87;
+acc += Math.sin(40052) + Math.cos(40053) * 88;
+acc += Math.sin(40053) + Math.cos(40054) * 89;
+acc += Math.sin(40054) + Math.cos(40055) * 90;
+acc += Math.sin(40055) + Math.cos(40056) * 91;
+acc += Math.sin(40056) + Math.cos(40057) * 92;
+acc += Math.sin(40057) + Math.cos(40058) * 93;
+acc += Math.sin(40058) + Math.cos(40059) * 94;
+acc += Math.sin(40059) + Math.cos(40060) * 95;
+acc += Math.sin(40060) + Math.cos(40061) * 96;
+acc += Math.sin(40061) + Math.cos(40062) * 0;
+acc += Math.sin(40062) + Math.cos(40063) * 1;
+acc += Math.sin(40063) + Math.cos(40064) * 2;
+acc += Math.sin(40064) + Math.cos(40065) * 3;
+acc += Math.sin(40065) + Math.cos(40066) * 4;
+acc += Math.sin(40066) + Math.cos(40067) * 5;
+acc += Math.sin(40067) + Math.cos(40068) * 6;
+acc += Math.sin(40068) + Math.cos(40069) * 7;
+acc += Math.sin(40069) + Math.cos(40070) * 8;
+acc += Math.sin(40070) + Math.cos(40071) * 9;
+acc += Math.sin(40071) + Math.cos(40072) * 10;
+acc += Math.sin(40072) + Math.cos(40073) * 11;
+acc += Math.sin(40073) + Math.cos(40074) * 12;
+acc += Math.sin(40074) + Math.cos(40075) * 13;
+acc += Math.sin(40075) + Math.cos(40076) * 14;
+acc += Math.sin(40076) + Math.cos(40077) * 15;
+acc += Math.sin(40077) + Math.cos(40078) * 16;
+acc += Math.sin(40078) + Math.cos(40079) * 17;
+acc += Math.sin(40079) + Math.cos(40080) * 18;
+acc += Math.sin(40080) + Math.cos(40081) * 19;
+acc += Math.sin(40081) + Math.cos(40082) * 20;
+acc += Math.sin(40082) + Math.cos(40083) * 21;
+acc += Math.sin(40083) + Math.cos(40084) * 22;
+acc += Math.sin(40084) + Math.cos(40085) * 23;
+acc += Math.sin(40085) + Math.cos(40086) * 24;
+acc += Math.sin(40086) + Math.cos(40087) * 25;
+acc += Math.sin(40087) + Math.cos(40088) * 26;
+acc += Math.sin(40088) + Math.cos(40089) * 27;
+acc += Math.sin(40089) + Math.cos(40090) * 28;
+acc += Math.sin(40090) + Math.cos(40091) * 29;
+acc += Math.sin(40091) + Math.cos(40092) * 30;
+acc += Math.sin(40092) + Math.cos(40093) * 31;
+acc += Math.sin(40093) + Math.cos(40094) * 32;
+acc += Math.sin(40094) + Math.cos(40095) * 33;
+acc += Math.sin(40095) + Math.cos(40096) * 34;
+acc += Math.sin(40096) + Math.cos(40097) * 35;
+acc += Math.sin(40097) + Math.cos(40098) * 36;
+acc += Math.sin(40098) + Math.cos(40099) * 37;
+acc += Math.sin(40099) + Math.cos(40100) * 38;
+acc += Math.sin(40100) + Math.cos(40101) * 39;
+acc += Math.sin(40101) + Math.cos(40102) * 40;
+acc += Math.sin(40102) + Math.cos(40103) * 41;
+acc += Math.sin(40103) + Math.cos(40104) * 42;
+acc += Math.sin(40104) + Math.cos(40105) * 43;
+acc += Math.sin(40105) + Math.cos(40106) * 44;
+acc += Math.sin(40106) + Math.cos(40107) * 45;
+acc += Math.sin(40107) + Math.cos(40108) * 46;
+acc += Math.sin(40108) + Math.cos(40109) * 47;
+acc += Math.sin(40109) + Math.cos(40110) * 48;
+acc += Math.sin(40110) + Math.cos(40111) * 49;
+acc += Math.sin(40111) + Math.cos(40112) * 50;
+acc += Math.sin(40112) + Math.cos(40113) * 51;
+acc += Math.sin(40113) + Math.cos(40114) * 52;
+acc += Math.sin(40114) + Math.cos(40115) * 53;
+acc += Math.sin(40115) + Math.cos(40116) * 54;
+acc += Math.sin(40116) + Math.cos(40117) * 55;
+acc += Math.sin(40117) + Math.cos(40118) * 56;
+acc += Math.sin(40118) + Math.cos(40119) * 57;
+acc += Math.sin(40119) + Math.cos(40120) * 58;
+acc += Math.sin(40120) + Math.cos(40121) * 59;
+acc += Math.sin(40121) + Math.cos(40122) * 60;
+acc += Math.sin(40122) + Math.cos(40123) * 61;
+acc += Math.sin(40123) + Math.cos(40124) * 62;
+acc += Math.sin(40124) + Math.cos(40125) * 63;
+acc += Math.sin(40125) + Math.cos(40126) * 64;
+acc += Math.sin(40126) + Math.cos(40127) * 65;
+acc += Math.sin(40127) + Math.cos(40128) * 66;
+acc += Math.sin(40128) + Math.cos(40129) * 67;
+acc += Math.sin(40129) + Math.cos(40130) * 68;
+acc += Math.sin(40130) + Math.cos(40131) * 69;
+acc += Math.sin(40131) + Math.cos(40132) * 70;
+acc += Math.sin(40132) + Math.cos(40133) * 71;
+acc += Math.sin(40133) + Math.cos(40134) * 72;
+acc += Math.sin(40134) + Math.cos(40135) * 73;
+acc += Math.sin(40135) + Math.cos(40136) * 74;
+acc += Math.sin(40136) + Math.cos(40137) * 75;
+acc += Math.sin(40137) + Math.cos(40138) * 76;
+acc += Math.sin(40138) + Math.cos(40139) * 77;
+acc += Math.sin(40139) + Math.cos(40140) * 78;
+acc += Math.sin(40140) + Math.cos(40141) * 79;
+acc += Math.sin(40141) + Math.cos(40142) * 80;
+acc += Math.sin(40142) + Math.cos(40143) * 81;
+acc += Math.sin(40143) + Math.cos(40144) * 82;
+acc += Math.sin(40144) + Math.cos(40145) * 83;
+acc += Math.sin(40145) + Math.cos(40146) * 84;
+acc += Math.sin(40146) + Math.cos(40147) * 85;
+acc += Math.sin(40147) + Math.cos(40148) * 86;
+acc += Math.sin(40148) + Math.cos(40149) * 87;
+acc += Math.sin(40149) + Math.cos(40150) * 88;
+acc += Math.sin(40150) + Math.cos(40151) * 89;
+acc += Math.sin(40151) + Math.cos(40152) * 90;
+acc += Math.sin(40152) + Math.cos(40153) * 91;
+acc += Math.sin(40153) + Math.cos(40154) * 92;
+acc += Math.sin(40154) + Math.cos(40155) * 93;
+acc += Math.sin(40155) + Math.cos(40156) * 94;
+acc += Math.sin(40156) + Math.cos(40157) * 95;
+acc += Math.sin(40157) + Math.cos(40158) * 96;
+acc += Math.sin(40158) + Math.cos(40159) * 0;
+acc += Math.sin(40159) + Math.cos(40160) * 1;
+acc += Math.sin(40160) + Math.cos(40161) * 2;
+acc += Math.sin(40161) + Math.cos(40162) * 3;
+acc += Math.sin(40162) + Math.cos(40163) * 4;
+acc += Math.sin(40163) + Math.cos(40164) * 5;
+acc += Math.sin(40164) + Math.cos(40165) * 6;
+acc += Math.sin(40165) + Math.cos(40166) * 7;
+acc += Math.sin(40166) + Math.cos(40167) * 8;
+acc += Math.sin(40167) + Math.cos(40168) * 9;
+acc += Math.sin(40168) + Math.cos(40169) * 10;
+acc += Math.sin(40169) + Math.cos(40170) * 11;
+acc += Math.sin(40170) + Math.cos(40171) * 12;
+acc += Math.sin(40171) + Math.cos(40172) * 13;
+acc += Math.sin(40172) + Math.cos(40173) * 14;
+acc += Math.sin(40173) + Math.cos(40174) * 15;
+acc += Math.sin(40174) + Math.cos(40175) * 16;
+acc += Math.sin(40175) + Math.cos(40176) * 17;
+acc += Math.sin(40176) + Math.cos(40177) * 18;
+acc += Math.sin(40177) + Math.cos(40178) * 19;
+acc += Math.sin(40178) + Math.cos(40179) * 20;
+acc += Math.sin(40179) + Math.cos(40180) * 21;
+acc += Math.sin(40180) + Math.cos(40181) * 22;
+acc += Math.sin(40181) + Math.cos(40182) * 23;
+acc += Math.sin(40182) + Math.cos(40183) * 24;
+acc += Math.sin(40183) + Math.cos(40184) * 25;
+acc += Math.sin(40184) + Math.cos(40185) * 26;
+acc += Math.sin(40185) + Math.cos(40186) * 27;
+acc += Math.sin(40186) + Math.cos(40187) * 28;
+acc += Math.sin(40187) + Math.cos(40188) * 29;
+acc += Math.sin(40188) + Math.cos(40189) * 30;
+acc += Math.sin(40189) + Math.cos(40190) * 31;
+acc += Math.sin(40190) + Math.cos(40191) * 32;
+acc += Math.sin(40191) + Math.cos(40192) * 33;
+acc += Math.sin(40192) + Math.cos(40193) * 34;
+acc += Math.sin(40193) + Math.cos(40194) * 35;
+acc += Math.sin(40194) + Math.cos(40195) * 36;
+acc += Math.sin(40195) + Math.cos(40196) * 37;
+acc += Math.sin(40196) + Math.cos(40197) * 38;
+acc += Math.sin(40197) + Math.cos(40198) * 39;
+acc += Math.sin(40198) + Math.cos(40199) * 40;
+acc += Math.sin(40199) + Math.cos(40200) * 41;
+acc += Math.sin(40200) + Math.cos(40201) * 42;
+acc += Math.sin(40201) + Math.cos(40202) * 43;
+acc += Math.sin(40202) + Math.cos(40203) * 44;
+acc += Math.sin(40203) + Math.cos(40204) * 45;
+acc += Math.sin(40204) + Math.cos(40205) * 46;
+acc += Math.sin(40205) + Math.cos(40206) * 47;
+acc += Math.sin(40206) + Math.cos(40207) * 48;
+acc += Math.sin(40207) + Math.cos(40208) * 49;
+acc += Math.sin(40208) + Math.cos(40209) * 50;
+acc += Math.sin(40209) + Math.cos(40210) * 51;
+acc += Math.sin(40210) + Math.cos(40211) * 52;
+acc += Math.sin(40211) + Math.cos(40212) * 53;
+acc += Math.sin(40212) + Math.cos(40213) * 54;
+acc += Math.sin(40213) + Math.cos(40214) * 55;
+acc += Math.sin(40214) + Math.cos(40215) * 56;
+acc += Math.sin(40215) + Math.cos(40216) * 57;
+acc += Math.sin(40216) + Math.cos(40217) * 58;
+acc += Math.sin(40217) + Math.cos(40218) * 59;
+acc += Math.sin(40218) + Math.cos(40219) * 60;
+acc += Math.sin(40219) + Math.cos(40220) * 61;
+acc += Math.sin(40220) + Math.cos(40221) * 62;
+acc += Math.sin(40221) + Math.cos(40222) * 63;
+acc += Math.sin(40222) + Math.cos(40223) * 64;
+acc += Math.sin(40223) + Math.cos(40224) * 65;
+acc += Math.sin(40224) + Math.cos(40225) * 66;
+acc += Math.sin(40225) + Math.cos(40226) * 67;
+acc += Math.sin(40226) + Math.cos(40227) * 68;
+acc += Math.sin(40227) + Math.cos(40228) * 69;
+acc += Math.sin(40228) + Math.cos(40229) * 70;
+acc += Math.sin(40229) + Math.cos(40230) * 71;
+acc += Math.sin(40230) + Math.cos(40231) * 72;
+acc += Math.sin(40231) + Math.cos(40232) * 73;
+acc += Math.sin(40232) + Math.cos(40233) * 74;
+acc += Math.sin(40233) + Math.cos(40234) * 75;
+acc += Math.sin(40234) + Math.cos(40235) * 76;
+acc += Math.sin(40235) + Math.cos(40236) * 77;
+acc += Math.sin(40236) + Math.cos(40237) * 78;
+acc += Math.sin(40237) + Math.cos(40238) * 79;
+acc += Math.sin(40238) + Math.cos(40239) * 80;
+acc += Math.sin(40239) + Math.cos(40240) * 81;
+acc += Math.sin(40240) + Math.cos(40241) * 82;
+acc += Math.sin(40241) + Math.cos(40242) * 83;
+acc += Math.sin(40242) + Math.cos(40243) * 84;
+acc += Math.sin(40243) + Math.cos(40244) * 85;
+acc += Math.sin(40244) + Math.cos(40245) * 86;
+acc += Math.sin(40245) + Math.cos(40246) * 87;
+acc += Math.sin(40246) + Math.cos(40247) * 88;
+acc += Math.sin(40247) + Math.cos(40248) * 89;
+acc += Math.sin(40248) + Math.cos(40249) * 90;
+acc += Math.sin(40249) + Math.cos(40250) * 91;
+acc += Math.sin(40250) + Math.cos(40251) * 92;
+acc += Math.sin(40251) + Math.cos(40252) * 93;
+acc += Math.sin(40252) + Math.cos(40253) * 94;
+acc += Math.sin(40253) + Math.cos(40254) * 95;
+acc += Math.sin(40254) + Math.cos(40255) * 96;
+acc += Math.sin(40255) + Math.cos(40256) * 0;
+acc += Math.sin(40256) + Math.cos(40257) * 1;
+acc += Math.sin(40257) + Math.cos(40258) * 2;
+acc += Math.sin(40258) + Math.cos(40259) * 3;
+acc += Math.sin(40259) + Math.cos(40260) * 4;
+acc += Math.sin(40260) + Math.cos(40261) * 5;
+acc += Math.sin(40261) + Math.cos(40262) * 6;
+acc += Math.sin(40262) + Math.cos(40263) * 7;
+acc += Math.sin(40263) + Math.cos(40264) * 8;
+acc += Math.sin(40264) + Math.cos(40265) * 9;
+acc += Math.sin(40265) + Math.cos(40266) * 10;
+acc += Math.sin(40266) + Math.cos(40267) * 11;
+acc += Math.sin(40267) + Math.cos(40268) * 12;
+acc += Math.sin(40268) + Math.cos(40269) * 13;
+acc += Math.sin(40269) + Math.cos(40270) * 14;
+acc += Math.sin(40270) + Math.cos(40271) * 15;
+acc += Math.sin(40271) + Math.cos(40272) * 16;
+acc += Math.sin(40272) + Math.cos(40273) * 17;
+acc += Math.sin(40273) + Math.cos(40274) * 18;
+acc += Math.sin(40274) + Math.cos(40275) * 19;
+acc += Math.sin(40275) + Math.cos(40276) * 20;
+acc += Math.sin(40276) + Math.cos(40277) * 21;
+acc += Math.sin(40277) + Math.cos(40278) * 22;
+acc += Math.sin(40278) + Math.cos(40279) * 23;
+acc += Math.sin(40279) + Math.cos(40280) * 24;
+acc += Math.sin(40280) + Math.cos(40281) * 25;
+acc += Math.sin(40281) + Math.cos(40282) * 26;
+acc += Math.sin(40282) + Math.cos(40283) * 27;
+acc += Math.sin(40283) + Math.cos(40284) * 28;
+acc += Math.sin(40284) + Math.cos(40285) * 29;
+acc += Math.sin(40285) + Math.cos(40286) * 30;
+acc += Math.sin(40286) + Math.cos(40287) * 31;
+acc += Math.sin(40287) + Math.cos(40288) * 32;
+acc += Math.sin(40288) + Math.cos(40289) * 33;
+acc += Math.sin(40289) + Math.cos(40290) * 34;
+acc += Math.sin(40290) + Math.cos(40291) * 35;
+acc += Math.sin(40291) + Math.cos(40292) * 36;
+acc += Math.sin(40292) + Math.cos(40293) * 37;
+acc += Math.sin(40293) + Math.cos(40294) * 38;
+acc += Math.sin(40294) + Math.cos(40295) * 39;
+acc += Math.sin(40295) + Math.cos(40296) * 40;
+acc += Math.sin(40296) + Math.cos(40297) * 41;
+acc += Math.sin(40297) + Math.cos(40298) * 42;
+acc += Math.sin(40298) + Math.cos(40299) * 43;
+acc += Math.sin(40299) + Math.cos(40300) * 44;
+acc += Math.sin(40300) + Math.cos(40301) * 45;
+acc += Math.sin(40301) + Math.cos(40302) * 46;
+acc += Math.sin(40302) + Math.cos(40303) * 47;
+acc += Math.sin(40303) + Math.cos(40304) * 48;
+acc += Math.sin(40304) + Math.cos(40305) * 49;
+acc += Math.sin(40305) + Math.cos(40306) * 50;
+acc += Math.sin(40306) + Math.cos(40307) * 51;
+acc += Math.sin(40307) + Math.cos(40308) * 52;
+acc += Math.sin(40308) + Math.cos(40309) * 53;
+acc += Math.sin(40309) + Math.cos(40310) * 54;
+acc += Math.sin(40310) + Math.cos(40311) * 55;
+acc += Math.sin(40311) + Math.cos(40312) * 56;
+acc += Math.sin(40312) + Math.cos(40313) * 57;
+acc += Math.sin(40313) + Math.cos(40314) * 58;
+acc += Math.sin(40314) + Math.cos(40315) * 59;
+acc += Math.sin(40315) + Math.cos(40316) * 60;
+acc += Math.sin(40316) + Math.cos(40317) * 61;
+acc += Math.sin(40317) + Math.cos(40318) * 62;
+acc += Math.sin(40318) + Math.cos(40319) * 63;
+acc += Math.sin(40319) + Math.cos(40320) * 64;
+acc += Math.sin(40320) + Math.cos(40321) * 65;
+acc += Math.sin(40321) + Math.cos(40322) * 66;
+acc += Math.sin(40322) + Math.cos(40323) * 67;
+acc += Math.sin(40323) + Math.cos(40324) * 68;
+acc += Math.sin(40324) + Math.cos(40325) * 69;
+acc += Math.sin(40325) + Math.cos(40326) * 70;
+acc += Math.sin(40326) + Math.cos(40327) * 71;
+acc += Math.sin(40327) + Math.cos(40328) * 72;
+acc += Math.sin(40328) + Math.cos(40329) * 73;
+acc += Math.sin(40329) + Math.cos(40330) * 74;
+acc += Math.sin(40330) + Math.cos(40331) * 75;
+acc += Math.sin(40331) + Math.cos(40332) * 76;
+acc += Math.sin(40332) + Math.cos(40333) * 77;
+acc += Math.sin(40333) + Math.cos(40334) * 78;
+acc += Math.sin(40334) + Math.cos(40335) * 79;
+acc += Math.sin(40335) + Math.cos(40336) * 80;
+acc += Math.sin(40336) + Math.cos(40337) * 81;
+acc += Math.sin(40337) + Math.cos(40338) * 82;
+acc += Math.sin(40338) + Math.cos(40339) * 83;
+acc += Math.sin(40339) + Math.cos(40340) * 84;
+acc += Math.sin(40340) + Math.cos(40341) * 85;
+acc += Math.sin(40341) + Math.cos(40342) * 86;
+acc += Math.sin(40342) + Math.cos(40343) * 87;
+acc += Math.sin(40343) + Math.cos(40344) * 88;
+acc += Math.sin(40344) + Math.cos(40345) * 89;
+acc += Math.sin(40345) + Math.cos(40346) * 90;
+acc += Math.sin(40346) + Math.cos(40347) * 91;
+acc += Math.sin(40347) + Math.cos(40348) * 92;
+acc += Math.sin(40348) + Math.cos(40349) * 93;
+acc += Math.sin(40349) + Math.cos(40350) * 94;
+acc += Math.sin(40350) + Math.cos(40351) * 95;
+acc += Math.sin(40351) + Math.cos(40352) * 96;
+acc += Math.sin(40352) + Math.cos(40353) * 0;
+acc += Math.sin(40353) + Math.cos(40354) * 1;
+acc += Math.sin(40354) + Math.cos(40355) * 2;
+acc += Math.sin(40355) + Math.cos(40356) * 3;
+acc += Math.sin(40356) + Math.cos(40357) * 4;
+acc += Math.sin(40357) + Math.cos(40358) * 5;
+acc += Math.sin(40358) + Math.cos(40359) * 6;
+acc += Math.sin(40359) + Math.cos(40360) * 7;
+acc += Math.sin(40360) + Math.cos(40361) * 8;
+acc += Math.sin(40361) + Math.cos(40362) * 9;
+acc += Math.sin(40362) + Math.cos(40363) * 10;
+acc += Math.sin(40363) + Math.cos(40364) * 11;
+acc += Math.sin(40364) + Math.cos(40365) * 12;
+acc += Math.sin(40365) + Math.cos(40366) * 13;
+acc += Math.sin(40366) + Math.cos(40367) * 14;
+acc += Math.sin(40367) + Math.cos(40368) * 15;
+acc += Math.sin(40368) + Math.cos(40369) * 16;
+acc += Math.sin(40369) + Math.cos(40370) * 17;
+acc += Math.sin(40370) + Math.cos(40371) * 18;
+acc += Math.sin(40371) + Math.cos(40372) * 19;
+acc += Math.sin(40372) + Math.cos(40373) * 20;
+acc += Math.sin(40373) + Math.cos(40374) * 21;
+acc += Math.sin(40374) + Math.cos(40375) * 22;
+acc += Math.sin(40375) + Math.cos(40376) * 23;
+acc += Math.sin(40376) + Math.cos(40377) * 24;
+acc += Math.sin(40377) + Math.cos(40378) * 25;
+acc += Math.sin(40378) + Math.cos(40379) * 26;
+acc += Math.sin(40379) + Math.cos(40380) * 27;
+acc += Math.sin(40380) + Math.cos(40381) * 28;
+acc += Math.sin(40381) + Math.cos(40382) * 29;
+acc += Math.sin(40382) + Math.cos(40383) * 30;
+acc += Math.sin(40383) + Math.cos(40384) * 31;
+acc += Math.sin(40384) + Math.cos(40385) * 32;
+acc += Math.sin(40385) + Math.cos(40386) * 33;
+acc += Math.sin(40386) + Math.cos(40387) * 34;
+acc += Math.sin(40387) + Math.cos(40388) * 35;
+acc += Math.sin(40388) + Math.cos(40389) * 36;
+acc += Math.sin(40389) + Math.cos(40390) * 37;
+acc += Math.sin(40390) + Math.cos(40391) * 38;
+acc += Math.sin(40391) + Math.cos(40392) * 39;
+acc += Math.sin(40392) + Math.cos(40393) * 40;
+acc += Math.sin(40393) + Math.cos(40394) * 41;
+acc += Math.sin(40394) + Math.cos(40395) * 42;
+acc += Math.sin(40395) + Math.cos(40396) * 43;
+acc += Math.sin(40396) + Math.cos(40397) * 44;
+acc += Math.sin(40397) + Math.cos(40398) * 45;
+acc += Math.sin(40398) + Math.cos(40399) * 46;
+acc += Math.sin(40399) + Math.cos(40400) * 47;
+acc += Math.sin(40400) + Math.cos(40401) * 48;
+acc += Math.sin(40401) + Math.cos(40402) * 49;
+acc += Math.sin(40402) + Math.cos(40403) * 50;
+acc += Math.sin(40403) + Math.cos(40404) * 51;
+acc += Math.sin(40404) + Math.cos(40405) * 52;
+acc += Math.sin(40405) + Math.cos(40406) * 53;
+acc += Math.sin(40406) + Math.cos(40407) * 54;
+acc += Math.sin(40407) + Math.cos(40408) * 55;
+acc += Math.sin(40408) + Math.cos(40409) * 56;
+acc += Math.sin(40409) + Math.cos(40410) * 57;
+acc += Math.sin(40410) + Math.cos(40411) * 58;
+acc += Math.sin(40411) + Math.cos(40412) * 59;
+acc += Math.sin(40412) + Math.cos(40413) * 60;
+acc += Math.sin(40413) + Math.cos(40414) * 61;
+acc += Math.sin(40414) + Math.cos(40415) * 62;
+acc += Math.sin(40415) + Math.cos(40416) * 63;
+acc += Math.sin(40416) + Math.cos(40417) * 64;
+acc += Math.sin(40417) + Math.cos(40418) * 65;
+acc += Math.sin(40418) + Math.cos(40419) * 66;
+acc += Math.sin(40419) + Math.cos(40420) * 67;
+acc += Math.sin(40420) + Math.cos(40421) * 68;
+acc += Math.sin(40421) + Math.cos(40422) * 69;
+acc += Math.sin(40422) + Math.cos(40423) * 70;
+acc += Math.sin(40423) + Math.cos(40424) * 71;
+acc += Math.sin(40424) + Math.cos(40425) * 72;
+acc += Math.sin(40425) + Math.cos(40426) * 73;
+acc += Math.sin(40426) + Math.cos(40427) * 74;
+acc += Math.sin(40427) + Math.cos(40428) * 75;
+acc += Math.sin(40428) + Math.cos(40429) * 76;
+acc += Math.sin(40429) + Math.cos(40430) * 77;
+acc += Math.sin(40430) + Math.cos(40431) * 78;
+acc += Math.sin(40431) + Math.cos(40432) * 79;
+acc += Math.sin(40432) + Math.cos(40433) * 80;
+acc += Math.sin(40433) + Math.cos(40434) * 81;
+acc += Math.sin(40434) + Math.cos(40435) * 82;
+acc += Math.sin(40435) + Math.cos(40436) * 83;
+acc += Math.sin(40436) + Math.cos(40437) * 84;
+acc += Math.sin(40437) + Math.cos(40438) * 85;
+acc += Math.sin(40438) + Math.cos(40439) * 86;
+acc += Math.sin(40439) + Math.cos(40440) * 87;
+acc += Math.sin(40440) + Math.cos(40441) * 88;
+acc += Math.sin(40441) + Math.cos(40442) * 89;
+acc += Math.sin(40442) + Math.cos(40443) * 90;
+acc += Math.sin(40443) + Math.cos(40444) * 91;
+acc += Math.sin(40444) + Math.cos(40445) * 92;
+acc += Math.sin(40445) + Math.cos(40446) * 93;
+acc += Math.sin(40446) + Math.cos(40447) * 94;
+acc += Math.sin(40447) + Math.cos(40448) * 95;
+acc += Math.sin(40448) + Math.cos(40449) * 96;
+acc += Math.sin(40449) + Math.cos(40450) * 0;
+acc += Math.sin(40450) + Math.cos(40451) * 1;
+acc += Math.sin(40451) + Math.cos(40452) * 2;
+acc += Math.sin(40452) + Math.cos(40453) * 3;
+acc += Math.sin(40453) + Math.cos(40454) * 4;
+acc += Math.sin(40454) + Math.cos(40455) * 5;
+acc += Math.sin(40455) + Math.cos(40456) * 6;
+acc += Math.sin(40456) + Math.cos(40457) * 7;
+acc += Math.sin(40457) + Math.cos(40458) * 8;
+acc += Math.sin(40458) + Math.cos(40459) * 9;
+acc += Math.sin(40459) + Math.cos(40460) * 10;
+acc += Math.sin(40460) + Math.cos(40461) * 11;
+acc += Math.sin(40461) + Math.cos(40462) * 12;
+acc += Math.sin(40462) + Math.cos(40463) * 13;
+acc += Math.sin(40463) + Math.cos(40464) * 14;
+acc += Math.sin(40464) + Math.cos(40465) * 15;
+acc += Math.sin(40465) + Math.cos(40466) * 16;
+acc += Math.sin(40466) + Math.cos(40467) * 17;
+acc += Math.sin(40467) + Math.cos(40468) * 18;
+acc += Math.sin(40468) + Math.cos(40469) * 19;
+acc += Math.sin(40469) + Math.cos(40470) * 20;
+acc += Math.sin(40470) + Math.cos(40471) * 21;
+acc += Math.sin(40471) + Math.cos(40472) * 22;
+acc += Math.sin(40472) + Math.cos(40473) * 23;
+acc += Math.sin(40473) + Math.cos(40474) * 24;
+acc += Math.sin(40474) + Math.cos(40475) * 25;
+acc += Math.sin(40475) + Math.cos(40476) * 26;
+acc += Math.sin(40476) + Math.cos(40477) * 27;
+acc += Math.sin(40477) + Math.cos(40478) * 28;
+acc += Math.sin(40478) + Math.cos(40479) * 29;
+acc += Math.sin(40479) + Math.cos(40480) * 30;
+acc += Math.sin(40480) + Math.cos(40481) * 31;
+acc += Math.sin(40481) + Math.cos(40482) * 32;
+acc += Math.sin(40482) + Math.cos(40483) * 33;
+acc += Math.sin(40483) + Math.cos(40484) * 34;
+acc += Math.sin(40484) + Math.cos(40485) * 35;
+acc += Math.sin(40485) + Math.cos(40486) * 36;
+acc += Math.sin(40486) + Math.cos(40487) * 37;
+acc += Math.sin(40487) + Math.cos(40488) * 38;
+acc += Math.sin(40488) + Math.cos(40489) * 39;
+acc += Math.sin(40489) + Math.cos(40490) * 40;
+acc += Math.sin(40490) + Math.cos(40491) * 41;
+acc += Math.sin(40491) + Math.cos(40492) * 42;
+acc += Math.sin(40492) + Math.cos(40493) * 43;
+acc += Math.sin(40493) + Math.cos(40494) * 44;
+acc += Math.sin(40494) + Math.cos(40495) * 45;
+acc += Math.sin(40495) + Math.cos(40496) * 46;
+acc += Math.sin(40496) + Math.cos(40497) * 47;
+acc += Math.sin(40497) + Math.cos(40498) * 48;
+acc += Math.sin(40498) + Math.cos(40499) * 49;
+acc += Math.sin(40499) + Math.cos(40500) * 50;
+acc += Math.sin(40500) + Math.cos(40501) * 51;
+acc += Math.sin(40501) + Math.cos(40502) * 52;
+acc += Math.sin(40502) + Math.cos(40503) * 53;
+acc += Math.sin(40503) + Math.cos(40504) * 54;
+acc += Math.sin(40504) + Math.cos(40505) * 55;
+acc += Math.sin(40505) + Math.cos(40506) * 56;
+acc += Math.sin(40506) + Math.cos(40507) * 57;
+acc += Math.sin(40507) + Math.cos(40508) * 58;
+acc += Math.sin(40508) + Math.cos(40509) * 59;
+acc += Math.sin(40509) + Math.cos(40510) * 60;
+acc += Math.sin(40510) + Math.cos(40511) * 61;
+acc += Math.sin(40511) + Math.cos(40512) * 62;
+acc += Math.sin(40512) + Math.cos(40513) * 63;
+acc += Math.sin(40513) + Math.cos(40514) * 64;
+acc += Math.sin(40514) + Math.cos(40515) * 65;
+acc += Math.sin(40515) + Math.cos(40516) * 66;
+acc += Math.sin(40516) + Math.cos(40517) * 67;
+acc += Math.sin(40517) + Math.cos(40518) * 68;
+acc += Math.sin(40518) + Math.cos(40519) * 69;
+acc += Math.sin(40519) + Math.cos(40520) * 70;
+acc += Math.sin(40520) + Math.cos(40521) * 71;
+acc += Math.sin(40521) + Math.cos(40522) * 72;
+acc += Math.sin(40522) + Math.cos(40523) * 73;
+acc += Math.sin(40523) + Math.cos(40524) * 74;
+acc += Math.sin(40524) + Math.cos(40525) * 75;
+acc += Math.sin(40525) + Math.cos(40526) * 76;
+acc += Math.sin(40526) + Math.cos(40527) * 77;
+acc += Math.sin(40527) + Math.cos(40528) * 78;
+acc += Math.sin(40528) + Math.cos(40529) * 79;
+acc += Math.sin(40529) + Math.cos(40530) * 80;
+acc += Math.sin(40530) + Math.cos(40531) * 81;
+acc += Math.sin(40531) + Math.cos(40532) * 82;
+acc += Math.sin(40532) + Math.cos(40533) * 83;
+acc += Math.sin(40533) + Math.cos(40534) * 84;
+acc += Math.sin(40534) + Math.cos(40535) * 85;
+acc += Math.sin(40535) + Math.cos(40536) * 86;
+acc += Math.sin(40536) + Math.cos(40537) * 87;
+acc += Math.sin(40537) + Math.cos(40538) * 88;
+acc += Math.sin(40538) + Math.cos(40539) * 89;
+acc += Math.sin(40539) + Math.cos(40540) * 90;
+acc += Math.sin(40540) + Math.cos(40541) * 91;
+acc += Math.sin(40541) + Math.cos(40542) * 92;
+acc += Math.sin(40542) + Math.cos(40543) * 93;
+acc += Math.sin(40543) + Math.cos(40544) * 94;
+acc += Math.sin(40544) + Math.cos(40545) * 95;
+acc += Math.sin(40545) + Math.cos(40546) * 96;
+acc += Math.sin(40546) + Math.cos(40547) * 0;
+acc += Math.sin(40547) + Math.cos(40548) * 1;
+acc += Math.sin(40548) + Math.cos(40549) * 2;
+acc += Math.sin(40549) + Math.cos(40550) * 3;
+acc += Math.sin(40550) + Math.cos(40551) * 4;
+acc += Math.sin(40551) + Math.cos(40552) * 5;
+acc += Math.sin(40552) + Math.cos(40553) * 6;
+acc += Math.sin(40553) + Math.cos(40554) * 7;
+acc += Math.sin(40554) + Math.cos(40555) * 8;
+acc += Math.sin(40555) + Math.cos(40556) * 9;
+acc += Math.sin(40556) + Math.cos(40557) * 10;
+acc += Math.sin(40557) + Math.cos(40558) * 11;
+acc += Math.sin(40558) + Math.cos(40559) * 12;
+acc += Math.sin(40559) + Math.cos(40560) * 13;
+acc += Math.sin(40560) + Math.cos(40561) * 14;
+acc += Math.sin(40561) + Math.cos(40562) * 15;
+acc += Math.sin(40562) + Math.cos(40563) * 16;
+acc += Math.sin(40563) + Math.cos(40564) * 17;
+acc += Math.sin(40564) + Math.cos(40565) * 18;
+acc += Math.sin(40565) + Math.cos(40566) * 19;
+acc += Math.sin(40566) + Math.cos(40567) * 20;
+acc += Math.sin(40567) + Math.cos(40568) * 21;
+acc += Math.sin(40568) + Math.cos(40569) * 22;
+acc += Math.sin(40569) + Math.cos(40570) * 23;
+acc += Math.sin(40570) + Math.cos(40571) * 24;
+acc += Math.sin(40571) + Math.cos(40572) * 25;
+acc += Math.sin(40572) + Math.cos(40573) * 26;
+acc += Math.sin(40573) + Math.cos(40574) * 27;
+acc += Math.sin(40574) + Math.cos(40575) * 28;
+acc += Math.sin(40575) + Math.cos(40576) * 29;
+acc += Math.sin(40576) + Math.cos(40577) * 30;
+acc += Math.sin(40577) + Math.cos(40578) * 31;
+acc += Math.sin(40578) + Math.cos(40579) * 32;
+acc += Math.sin(40579) + Math.cos(40580) * 33;
+acc += Math.sin(40580) + Math.cos(40581) * 34;
+acc += Math.sin(40581) + Math.cos(40582) * 35;
+acc += Math.sin(40582) + Math.cos(40583) * 36;
+acc += Math.sin(40583) + Math.cos(40584) * 37;
+acc += Math.sin(40584) + Math.cos(40585) * 38;
+acc += Math.sin(40585) + Math.cos(40586) * 39;
+acc += Math.sin(40586) + Math.cos(40587) * 40;
+acc += Math.sin(40587) + Math.cos(40588) * 41;
+acc += Math.sin(40588) + Math.cos(40589) * 42;
+acc += Math.sin(40589) + Math.cos(40590) * 43;
+acc += Math.sin(40590) + Math.cos(40591) * 44;
+acc += Math.sin(40591) + Math.cos(40592) * 45;
+acc += Math.sin(40592) + Math.cos(40593) * 46;
+acc += Math.sin(40593) + Math.cos(40594) * 47;
+acc += Math.sin(40594) + Math.cos(40595) * 48;
+acc += Math.sin(40595) + Math.cos(40596) * 49;
+acc += Math.sin(40596) + Math.cos(40597) * 50;
+acc += Math.sin(40597) + Math.cos(40598) * 51;
+acc += Math.sin(40598) + Math.cos(40599) * 52;
+acc += Math.sin(40599) + Math.cos(40600) * 53;
+acc += Math.sin(40600) + Math.cos(40601) * 54;
+acc += Math.sin(40601) + Math.cos(40602) * 55;
+acc += Math.sin(40602) + Math.cos(40603) * 56;
+acc += Math.sin(40603) + Math.cos(40604) * 57;
+acc += Math.sin(40604) + Math.cos(40605) * 58;
+acc += Math.sin(40605) + Math.cos(40606) * 59;
+acc += Math.sin(40606) + Math.cos(40607) * 60;
+acc += Math.sin(40607) + Math.cos(40608) * 61;
+acc += Math.sin(40608) + Math.cos(40609) * 62;
+acc += Math.sin(40609) + Math.cos(40610) * 63;
+acc += Math.sin(40610) + Math.cos(40611) * 64;
+acc += Math.sin(40611) + Math.cos(40612) * 65;
+acc += Math.sin(40612) + Math.cos(40613) * 66;
+acc += Math.sin(40613) + Math.cos(40614) * 67;
+acc += Math.sin(40614) + Math.cos(40615) * 68;
+acc += Math.sin(40615) + Math.cos(40616) * 69;
+acc += Math.sin(40616) + Math.cos(40617) * 70;
+acc += Math.sin(40617) + Math.cos(40618) * 71;
+acc += Math.sin(40618) + Math.cos(40619) * 72;
+acc += Math.sin(40619) + Math.cos(40620) * 73;
+acc += Math.sin(40620) + Math.cos(40621) * 74;
+acc += Math.sin(40621) + Math.cos(40622) * 75;
+acc += Math.sin(40622) + Math.cos(40623) * 76;
+acc += Math.sin(40623) + Math.cos(40624) * 77;
+acc += Math.sin(40624) + Math.cos(40625) * 78;
+acc += Math.sin(40625) + Math.cos(40626) * 79;
+acc += Math.sin(40626) + Math.cos(40627) * 80;
+acc += Math.sin(40627) + Math.cos(40628) * 81;
+acc += Math.sin(40628) + Math.cos(40629) * 82;
+acc += Math.sin(40629) + Math.cos(40630) * 83;
+acc += Math.sin(40630) + Math.cos(40631) * 84;
+acc += Math.sin(40631) + Math.cos(40632) * 85;
+acc += Math.sin(40632) + Math.cos(40633) * 86;
+acc += Math.sin(40633) + Math.cos(40634) * 87;
+acc += Math.sin(40634) + Math.cos(40635) * 88;
+acc += Math.sin(40635) + Math.cos(40636) * 89;
+acc += Math.sin(40636) + Math.cos(40637) * 90;
+acc += Math.sin(40637) + Math.cos(40638) * 91;
+acc += Math.sin(40638) + Math.cos(40639) * 92;
+acc += Math.sin(40639) + Math.cos(40640) * 93;
+acc += Math.sin(40640) + Math.cos(40641) * 94;
+acc += Math.sin(40641) + Math.cos(40642) * 95;
+acc += Math.sin(40642) + Math.cos(40643) * 96;
+acc += Math.sin(40643) + Math.cos(40644) * 0;
+acc += Math.sin(40644) + Math.cos(40645) * 1;
+acc += Math.sin(40645) + Math.cos(40646) * 2;
+acc += Math.sin(40646) + Math.cos(40647) * 3;
+acc += Math.sin(40647) + Math.cos(40648) * 4;
+acc += Math.sin(40648) + Math.cos(40649) * 5;
+acc += Math.sin(40649) + Math.cos(40650) * 6;
+acc += Math.sin(40650) + Math.cos(40651) * 7;
+acc += Math.sin(40651) + Math.cos(40652) * 8;
+acc += Math.sin(40652) + Math.cos(40653) * 9;
+acc += Math.sin(40653) + Math.cos(40654) * 10;
+acc += Math.sin(40654) + Math.cos(40655) * 11;
+acc += Math.sin(40655) + Math.cos(40656) * 12;
+acc += Math.sin(40656) + Math.cos(40657) * 13;
+acc += Math.sin(40657) + Math.cos(40658) * 14;
+acc += Math.sin(40658) + Math.cos(40659) * 15;
+acc += Math.sin(40659) + Math.cos(40660) * 16;
+acc += Math.sin(40660) + Math.cos(40661) * 17;
+acc += Math.sin(40661) + Math.cos(40662) * 18;
+acc += Math.sin(40662) + Math.cos(40663) * 19;
+acc += Math.sin(40663) + Math.cos(40664) * 20;
+acc += Math.sin(40664) + Math.cos(40665) * 21;
+acc += Math.sin(40665) + Math.cos(40666) * 22;
+acc += Math.sin(40666) + Math.cos(40667) * 23;
+acc += Math.sin(40667) + Math.cos(40668) * 24;
+acc += Math.sin(40668) + Math.cos(40669) * 25;
+acc += Math.sin(40669) + Math.cos(40670) * 26;
+acc += Math.sin(40670) + Math.cos(40671) * 27;
+acc += Math.sin(40671) + Math.cos(40672) * 28;
+acc += Math.sin(40672) + Math.cos(40673) * 29;
+acc += Math.sin(40673) + Math.cos(40674) * 30;
+acc += Math.sin(40674) + Math.cos(40675) * 31;
+acc += Math.sin(40675) + Math.cos(40676) * 32;
+acc += Math.sin(40676) + Math.cos(40677) * 33;
+acc += Math.sin(40677) + Math.cos(40678) * 34;
+acc += Math.sin(40678) + Math.cos(40679) * 35;
+acc += Math.sin(40679) + Math.cos(40680) * 36;
+acc += Math.sin(40680) + Math.cos(40681) * 37;
+acc += Math.sin(40681) + Math.cos(40682) * 38;
+acc += Math.sin(40682) + Math.cos(40683) * 39;
+acc += Math.sin(40683) + Math.cos(40684) * 40;
+acc += Math.sin(40684) + Math.cos(40685) * 41;
+acc += Math.sin(40685) + Math.cos(40686) * 42;
+acc += Math.sin(40686) + Math.cos(40687) * 43;
+acc += Math.sin(40687) + Math.cos(40688) * 44;
+acc += Math.sin(40688) + Math.cos(40689) * 45;
+acc += Math.sin(40689) + Math.cos(40690) * 46;
+acc += Math.sin(40690) + Math.cos(40691) * 47;
+acc += Math.sin(40691) + Math.cos(40692) * 48;
+acc += Math.sin(40692) + Math.cos(40693) * 49;
+acc += Math.sin(40693) + Math.cos(40694) * 50;
+acc += Math.sin(40694) + Math.cos(40695) * 51;
+acc += Math.sin(40695) + Math.cos(40696) * 52;
+acc += Math.sin(40696) + Math.cos(40697) * 53;
+acc += Math.sin(40697) + Math.cos(40698) * 54;
+acc += Math.sin(40698) + Math.cos(40699) * 55;
+acc += Math.sin(40699) + Math.cos(40700) * 56;
+acc += Math.sin(40700) + Math.cos(40701) * 57;
+acc += Math.sin(40701) + Math.cos(40702) * 58;
+acc += Math.sin(40702) + Math.cos(40703) * 59;
+acc += Math.sin(40703) + Math.cos(40704) * 60;
+acc += Math.sin(40704) + Math.cos(40705) * 61;
+acc += Math.sin(40705) + Math.cos(40706) * 62;
+acc += Math.sin(40706) + Math.cos(40707) * 63;
+acc += Math.sin(40707) + Math.cos(40708) * 64;
+acc += Math.sin(40708) + Math.cos(40709) * 65;
+acc += Math.sin(40709) + Math.cos(40710) * 66;
+acc += Math.sin(40710) + Math.cos(40711) * 67;
+acc += Math.sin(40711) + Math.cos(40712) * 68;
+acc += Math.sin(40712) + Math.cos(40713) * 69;
+acc += Math.sin(40713) + Math.cos(40714) * 70;
+acc += Math.sin(40714) + Math.cos(40715) * 71;
+acc += Math.sin(40715) + Math.cos(40716) * 72;
+acc += Math.sin(40716) + Math.cos(40717) * 73;
+acc += Math.sin(40717) + Math.cos(40718) * 74;
+acc += Math.sin(40718) + Math.cos(40719) * 75;
+acc += Math.sin(40719) + Math.cos(40720) * 76;
+acc += Math.sin(40720) + Math.cos(40721) * 77;
+acc += Math.sin(40721) + Math.cos(40722) * 78;
+acc += Math.sin(40722) + Math.cos(40723) * 79;
+acc += Math.sin(40723) + Math.cos(40724) * 80;
+acc += Math.sin(40724) + Math.cos(40725) * 81;
+acc += Math.sin(40725) + Math.cos(40726) * 82;
+acc += Math.sin(40726) + Math.cos(40727) * 83;
+acc += Math.sin(40727) + Math.cos(40728) * 84;
+acc += Math.sin(40728) + Math.cos(40729) * 85;
+acc += Math.sin(40729) + Math.cos(40730) * 86;
+acc += Math.sin(40730) + Math.cos(40731) * 87;
+acc += Math.sin(40731) + Math.cos(40732) * 88;
+acc += Math.sin(40732) + Math.cos(40733) * 89;
+acc += Math.sin(40733) + Math.cos(40734) * 90;
+acc += Math.sin(40734) + Math.cos(40735) * 91;
+acc += Math.sin(40735) + Math.cos(40736) * 92;
+acc += Math.sin(40736) + Math.cos(40737) * 93;
+acc += Math.sin(40737) + Math.cos(40738) * 94;
+acc += Math.sin(40738) + Math.cos(40739) * 95;
+acc += Math.sin(40739) + Math.cos(40740) * 96;
+acc += Math.sin(40740) + Math.cos(40741) * 0;
+acc += Math.sin(40741) + Math.cos(40742) * 1;
+acc += Math.sin(40742) + Math.cos(40743) * 2;
+acc += Math.sin(40743) + Math.cos(40744) * 3;
+acc += Math.sin(40744) + Math.cos(40745) * 4;
+acc += Math.sin(40745) + Math.cos(40746) * 5;
+acc += Math.sin(40746) + Math.cos(40747) * 6;
+acc += Math.sin(40747) + Math.cos(40748) * 7;
+acc += Math.sin(40748) + Math.cos(40749) * 8;
+acc += Math.sin(40749) + Math.cos(40750) * 9;
+acc += Math.sin(40750) + Math.cos(40751) * 10;
+acc += Math.sin(40751) + Math.cos(40752) * 11;
+acc += Math.sin(40752) + Math.cos(40753) * 12;
+acc += Math.sin(40753) + Math.cos(40754) * 13;
+acc += Math.sin(40754) + Math.cos(40755) * 14;
+acc += Math.sin(40755) + Math.cos(40756) * 15;
+acc += Math.sin(40756) + Math.cos(40757) * 16;
+acc += Math.sin(40757) + Math.cos(40758) * 17;
+acc += Math.sin(40758) + Math.cos(40759) * 18;
+acc += Math.sin(40759) + Math.cos(40760) * 19;
+acc += Math.sin(40760) + Math.cos(40761) * 20;
+acc += Math.sin(40761) + Math.cos(40762) * 21;
+acc += Math.sin(40762) + Math.cos(40763) * 22;
+acc += Math.sin(40763) + Math.cos(40764) * 23;
+acc += Math.sin(40764) + Math.cos(40765) * 24;
+acc += Math.sin(40765) + Math.cos(40766) * 25;
+acc += Math.sin(40766) + Math.cos(40767) * 26;
+acc += Math.sin(40767) + Math.cos(40768) * 27;
+acc += Math.sin(40768) + Math.cos(40769) * 28;
+acc += Math.sin(40769) + Math.cos(40770) * 29;
+acc += Math.sin(40770) + Math.cos(40771) * 30;
+acc += Math.sin(40771) + Math.cos(40772) * 31;
+acc += Math.sin(40772) + Math.cos(40773) * 32;
+acc += Math.sin(40773) + Math.cos(40774) * 33;
+acc += Math.sin(40774) + Math.cos(40775) * 34;
+acc += Math.sin(40775) + Math.cos(40776) * 35;
+acc += Math.sin(40776) + Math.cos(40777) * 36;
+acc += Math.sin(40777) + Math.cos(40778) * 37;
+acc += Math.sin(40778) + Math.cos(40779) * 38;
+acc += Math.sin(40779) + Math.cos(40780) * 39;
+acc += Math.sin(40780) + Math.cos(40781) * 40;
+acc += Math.sin(40781) + Math.cos(40782) * 41;
+acc += Math.sin(40782) + Math.cos(40783) * 42;
+acc += Math.sin(40783) + Math.cos(40784) * 43;
+acc += Math.sin(40784) + Math.cos(40785) * 44;
+acc += Math.sin(40785) + Math.cos(40786) * 45;
+acc += Math.sin(40786) + Math.cos(40787) * 46;
+acc += Math.sin(40787) + Math.cos(40788) * 47;
+acc += Math.sin(40788) + Math.cos(40789) * 48;
+acc += Math.sin(40789) + Math.cos(40790) * 49;
+acc += Math.sin(40790) + Math.cos(40791) * 50;
+acc += Math.sin(40791) + Math.cos(40792) * 51;
+acc += Math.sin(40792) + Math.cos(40793) * 52;
+acc += Math.sin(40793) + Math.cos(40794) * 53;
+acc += Math.sin(40794) + Math.cos(40795) * 54;
+acc += Math.sin(40795) + Math.cos(40796) * 55;
+acc += Math.sin(40796) + Math.cos(40797) * 56;
+acc += Math.sin(40797) + Math.cos(40798) * 57;
+acc += Math.sin(40798) + Math.cos(40799) * 58;
+acc += Math.sin(40799) + Math.cos(40800) * 59;
+acc += Math.sin(40800) + Math.cos(40801) * 60;
+acc += Math.sin(40801) + Math.cos(40802) * 61;
+acc += Math.sin(40802) + Math.cos(40803) * 62;
+acc += Math.sin(40803) + Math.cos(40804) * 63;
+acc += Math.sin(40804) + Math.cos(40805) * 64;
+acc += Math.sin(40805) + Math.cos(40806) * 65;
+acc += Math.sin(40806) + Math.cos(40807) * 66;
+acc += Math.sin(40807) + Math.cos(40808) * 67;
+acc += Math.sin(40808) + Math.cos(40809) * 68;
+acc += Math.sin(40809) + Math.cos(40810) * 69;
+acc += Math.sin(40810) + Math.cos(40811) * 70;
+acc += Math.sin(40811) + Math.cos(40812) * 71;
+acc += Math.sin(40812) + Math.cos(40813) * 72;
+acc += Math.sin(40813) + Math.cos(40814) * 73;
+acc += Math.sin(40814) + Math.cos(40815) * 74;
+acc += Math.sin(40815) + Math.cos(40816) * 75;
+acc += Math.sin(40816) + Math.cos(40817) * 76;
+acc += Math.sin(40817) + Math.cos(40818) * 77;
+acc += Math.sin(40818) + Math.cos(40819) * 78;
+acc += Math.sin(40819) + Math.cos(40820) * 79;
+acc += Math.sin(40820) + Math.cos(40821) * 80;
+acc += Math.sin(40821) + Math.cos(40822) * 81;
+acc += Math.sin(40822) + Math.cos(40823) * 82;
+acc += Math.sin(40823) + Math.cos(40824) * 83;
+acc += Math.sin(40824) + Math.cos(40825) * 84;
+acc += Math.sin(40825) + Math.cos(40826) * 85;
+acc += Math.sin(40826) + Math.cos(40827) * 86;
+acc += Math.sin(40827) + Math.cos(40828) * 87;
+acc += Math.sin(40828) + Math.cos(40829) * 88;
+acc += Math.sin(40829) + Math.cos(40830) * 89;
+acc += Math.sin(40830) + Math.cos(40831) * 90;
+acc += Math.sin(40831) + Math.cos(40832) * 91;
+acc += Math.sin(40832) + Math.cos(40833) * 92;
+acc += Math.sin(40833) + Math.cos(40834) * 93;
+acc += Math.sin(40834) + Math.cos(40835) * 94;
+acc += Math.sin(40835) + Math.cos(40836) * 95;
+acc += Math.sin(40836) + Math.cos(40837) * 96;
+acc += Math.sin(40837) + Math.cos(40838) * 0;
+acc += Math.sin(40838) + Math.cos(40839) * 1;
+acc += Math.sin(40839) + Math.cos(40840) * 2;
+acc += Math.sin(40840) + Math.cos(40841) * 3;
+acc += Math.sin(40841) + Math.cos(40842) * 4;
+acc += Math.sin(40842) + Math.cos(40843) * 5;
+acc += Math.sin(40843) + Math.cos(40844) * 6;
+acc += Math.sin(40844) + Math.cos(40845) * 7;
+acc += Math.sin(40845) + Math.cos(40846) * 8;
+acc += Math.sin(40846) + Math.cos(40847) * 9;
+acc += Math.sin(40847) + Math.cos(40848) * 10;
+acc += Math.sin(40848) + Math.cos(40849) * 11;
+acc += Math.sin(40849) + Math.cos(40850) * 12;
+acc += Math.sin(40850) + Math.cos(40851) * 13;
+acc += Math.sin(40851) + Math.cos(40852) * 14;
+acc += Math.sin(40852) + Math.cos(40853) * 15;
+acc += Math.sin(40853) + Math.cos(40854) * 16;
+acc += Math.sin(40854) + Math.cos(40855) * 17;
+acc += Math.sin(40855) + Math.cos(40856) * 18;
+acc += Math.sin(40856) + Math.cos(40857) * 19;
+acc += Math.sin(40857) + Math.cos(40858) * 20;
+acc += Math.sin(40858) + Math.cos(40859) * 21;
+acc += Math.sin(40859) + Math.cos(40860) * 22;
+acc += Math.sin(40860) + Math.cos(40861) * 23;
+acc += Math.sin(40861) + Math.cos(40862) * 24;
+acc += Math.sin(40862) + Math.cos(40863) * 25;
+acc += Math.sin(40863) + Math.cos(40864) * 26;
+acc += Math.sin(40864) + Math.cos(40865) * 27;
+acc += Math.sin(40865) + Math.cos(40866) * 28;
+acc += Math.sin(40866) + Math.cos(40867) * 29;
+acc += Math.sin(40867) + Math.cos(40868) * 30;
+acc += Math.sin(40868) + Math.cos(40869) * 31;
+acc += Math.sin(40869) + Math.cos(40870) * 32;
+acc += Math.sin(40870) + Math.cos(40871) * 33;
+acc += Math.sin(40871) + Math.cos(40872) * 34;
+acc += Math.sin(40872) + Math.cos(40873) * 35;
+acc += Math.sin(40873) + Math.cos(40874) * 36;
+acc += Math.sin(40874) + Math.cos(40875) * 37;
+acc += Math.sin(40875) + Math.cos(40876) * 38;
+acc += Math.sin(40876) + Math.cos(40877) * 39;
+acc += Math.sin(40877) + Math.cos(40878) * 40;
+acc += Math.sin(40878) + Math.cos(40879) * 41;
+acc += Math.sin(40879) + Math.cos(40880) * 42;
+acc += Math.sin(40880) + Math.cos(40881) * 43;
+acc += Math.sin(40881) + Math.cos(40882) * 44;
+acc += Math.sin(40882) + Math.cos(40883) * 45;
+acc += Math.sin(40883) + Math.cos(40884) * 46;
+acc += Math.sin(40884) + Math.cos(40885) * 47;
+acc += Math.sin(40885) + Math.cos(40886) * 48;
+acc += Math.sin(40886) + Math.cos(40887) * 49;
+acc += Math.sin(40887) + Math.cos(40888) * 50;
+acc += Math.sin(40888) + Math.cos(40889) * 51;
+acc += Math.sin(40889) + Math.cos(40890) * 52;
+acc += Math.sin(40890) + Math.cos(40891) * 53;
+acc += Math.sin(40891) + Math.cos(40892) * 54;
+acc += Math.sin(40892) + Math.cos(40893) * 55;
+acc += Math.sin(40893) + Math.cos(40894) * 56;
+acc += Math.sin(40894) + Math.cos(40895) * 57;
+acc += Math.sin(40895) + Math.cos(40896) * 58;
+acc += Math.sin(40896) + Math.cos(40897) * 59;
+acc += Math.sin(40897) + Math.cos(40898) * 60;
+acc += Math.sin(40898) + Math.cos(40899) * 61;
+acc += Math.sin(40899) + Math.cos(40900) * 62;
+acc += Math.sin(40900) + Math.cos(40901) * 63;
+acc += Math.sin(40901) + Math.cos(40902) * 64;
+acc += Math.sin(40902) + Math.cos(40903) * 65;
+acc += Math.sin(40903) + Math.cos(40904) * 66;
+acc += Math.sin(40904) + Math.cos(40905) * 67;
+acc += Math.sin(40905) + Math.cos(40906) * 68;
+acc += Math.sin(40906) + Math.cos(40907) * 69;
+acc += Math.sin(40907) + Math.cos(40908) * 70;
+acc += Math.sin(40908) + Math.cos(40909) * 71;
+acc += Math.sin(40909) + Math.cos(40910) * 72;
+acc += Math.sin(40910) + Math.cos(40911) * 73;
+acc += Math.sin(40911) + Math.cos(40912) * 74;
+acc += Math.sin(40912) + Math.cos(40913) * 75;
+acc += Math.sin(40913) + Math.cos(40914) * 76;
+acc += Math.sin(40914) + Math.cos(40915) * 77;
+acc += Math.sin(40915) + Math.cos(40916) * 78;
+acc += Math.sin(40916) + Math.cos(40917) * 79;
+acc += Math.sin(40917) + Math.cos(40918) * 80;
+acc += Math.sin(40918) + Math.cos(40919) * 81;
+acc += Math.sin(40919) + Math.cos(40920) * 82;
+acc += Math.sin(40920) + Math.cos(40921) * 83;
+acc += Math.sin(40921) + Math.cos(40922) * 84;
+acc += Math.sin(40922) + Math.cos(40923) * 85;
+acc += Math.sin(40923) + Math.cos(40924) * 86;
+acc += Math.sin(40924) + Math.cos(40925) * 87;
+acc += Math.sin(40925) + Math.cos(40926) * 88;
+acc += Math.sin(40926) + Math.cos(40927) * 89;
+acc += Math.sin(40927) + Math.cos(40928) * 90;
+acc += Math.sin(40928) + Math.cos(40929) * 91;
+acc += Math.sin(40929) + Math.cos(40930) * 92;
+acc += Math.sin(40930) + Math.cos(40931) * 93;
+acc += Math.sin(40931) + Math.cos(40932) * 94;
+acc += Math.sin(40932) + Math.cos(40933) * 95;
+acc += Math.sin(40933) + Math.cos(40934) * 96;
+acc += Math.sin(40934) + Math.cos(40935) * 0;
+acc += Math.sin(40935) + Math.cos(40936) * 1;
+acc += Math.sin(40936) + Math.cos(40937) * 2;
+acc += Math.sin(40937) + Math.cos(40938) * 3;
+acc += Math.sin(40938) + Math.cos(40939) * 4;
+acc += Math.sin(40939) + Math.cos(40940) * 5;
+acc += Math.sin(40940) + Math.cos(40941) * 6;
+acc += Math.sin(40941) + Math.cos(40942) * 7;
+acc += Math.sin(40942) + Math.cos(40943) * 8;
+acc += Math.sin(40943) + Math.cos(40944) * 9;
+acc += Math.sin(40944) + Math.cos(40945) * 10;
+acc += Math.sin(40945) + Math.cos(40946) * 11;
+acc += Math.sin(40946) + Math.cos(40947) * 12;
+acc += Math.sin(40947) + Math.cos(40948) * 13;
+acc += Math.sin(40948) + Math.cos(40949) * 14;
+acc += Math.sin(40949) + Math.cos(40950) * 15;
+acc += Math.sin(40950) + Math.cos(40951) * 16;
+acc += Math.sin(40951) + Math.cos(40952) * 17;
+acc += Math.sin(40952) + Math.cos(40953) * 18;
+acc += Math.sin(40953) + Math.cos(40954) * 19;
+acc += Math.sin(40954) + Math.cos(40955) * 20;
+acc += Math.sin(40955) + Math.cos(40956) * 21;
+acc += Math.sin(40956) + Math.cos(40957) * 22;
+acc += Math.sin(40957) + Math.cos(40958) * 23;
+acc += Math.sin(40958) + Math.cos(40959) * 24;
+acc += Math.sin(40959) + Math.cos(40960) * 25;
+acc += Math.sin(40960) + Math.cos(40961) * 26;
+acc += Math.sin(40961) + Math.cos(40962) * 27;
+acc += Math.sin(40962) + Math.cos(40963) * 28;
+acc += Math.sin(40963) + Math.cos(40964) * 29;
+acc += Math.sin(40964) + Math.cos(40965) * 30;
+acc += Math.sin(40965) + Math.cos(40966) * 31;
+acc += Math.sin(40966) + Math.cos(40967) * 32;
+acc += Math.sin(40967) + Math.cos(40968) * 33;
+acc += Math.sin(40968) + Math.cos(40969) * 34;
+acc += Math.sin(40969) + Math.cos(40970) * 35;
+acc += Math.sin(40970) + Math.cos(40971) * 36;
+acc += Math.sin(40971) + Math.cos(40972) * 37;
+acc += Math.sin(40972) + Math.cos(40973) * 38;
+acc += Math.sin(40973) + Math.cos(40974) * 39;
+acc += Math.sin(40974) + Math.cos(40975) * 40;
+acc += Math.sin(40975) + Math.cos(40976) * 41;
+acc += Math.sin(40976) + Math.cos(40977) * 42;
+acc += Math.sin(40977) + Math.cos(40978) * 43;
+acc += Math.sin(40978) + Math.cos(40979) * 44;
+acc += Math.sin(40979) + Math.cos(40980) * 45;
+acc += Math.sin(40980) + Math.cos(40981) * 46;
+acc += Math.sin(40981) + Math.cos(40982) * 47;
+acc += Math.sin(40982) + Math.cos(40983) * 48;
+acc += Math.sin(40983) + Math.cos(40984) * 49;
+acc += Math.sin(40984) + Math.cos(40985) * 50;
+acc += Math.sin(40985) + Math.cos(40986) * 51;
+acc += Math.sin(40986) + Math.cos(40987) * 52;
+acc += Math.sin(40987) + Math.cos(40988) * 53;
+acc += Math.sin(40988) + Math.cos(40989) * 54;
+acc += Math.sin(40989) + Math.cos(40990) * 55;
+acc += Math.sin(40990) + Math.cos(40991) * 56;
+acc += Math.sin(40991) + Math.cos(40992) * 57;
+acc += Math.sin(40992) + Math.cos(40993) * 58;
+acc += Math.sin(40993) + Math.cos(40994) * 59;
+acc += Math.sin(40994) + Math.cos(40995) * 60;
+acc += Math.sin(40995) + Math.cos(40996) * 61;
+acc += Math.sin(40996) + Math.cos(40997) * 62;
+acc += Math.sin(40997) + Math.cos(40998) * 63;
+acc += Math.sin(40998) + Math.cos(40999) * 64;
+acc += Math.sin(40999) + Math.cos(41000) * 65;
+acc += Math.sin(41000) + Math.cos(41001) * 66;
+acc += Math.sin(41001) + Math.cos(41002) * 67;
+acc += Math.sin(41002) + Math.cos(41003) * 68;
+acc += Math.sin(41003) + Math.cos(41004) * 69;
+acc += Math.sin(41004) + Math.cos(41005) * 70;
+acc += Math.sin(41005) + Math.cos(41006) * 71;
+acc += Math.sin(41006) + Math.cos(41007) * 72;
+acc += Math.sin(41007) + Math.cos(41008) * 73;
+acc += Math.sin(41008) + Math.cos(41009) * 74;
+acc += Math.sin(41009) + Math.cos(41010) * 75;
+acc += Math.sin(41010) + Math.cos(41011) * 76;
+acc += Math.sin(41011) + Math.cos(41012) * 77;
+acc += Math.sin(41012) + Math.cos(41013) * 78;
+acc += Math.sin(41013) + Math.cos(41014) * 79;
+acc += Math.sin(41014) + Math.cos(41015) * 80;
+acc += Math.sin(41015) + Math.cos(41016) * 81;
+acc += Math.sin(41016) + Math.cos(41017) * 82;
+acc += Math.sin(41017) + Math.cos(41018) * 83;
+acc += Math.sin(41018) + Math.cos(41019) * 84;
+acc += Math.sin(41019) + Math.cos(41020) * 85;
+acc += Math.sin(41020) + Math.cos(41021) * 86;
+acc += Math.sin(41021) + Math.cos(41022) * 87;
+acc += Math.sin(41022) + Math.cos(41023) * 88;
+acc += Math.sin(41023) + Math.cos(41024) * 89;
+acc += Math.sin(41024) + Math.cos(41025) * 90;
+acc += Math.sin(41025) + Math.cos(41026) * 91;
+acc += Math.sin(41026) + Math.cos(41027) * 92;
+acc += Math.sin(41027) + Math.cos(41028) * 93;
+acc += Math.sin(41028) + Math.cos(41029) * 94;
+acc += Math.sin(41029) + Math.cos(41030) * 95;
+acc += Math.sin(41030) + Math.cos(41031) * 96;
+acc += Math.sin(41031) + Math.cos(41032) * 0;
+acc += Math.sin(41032) + Math.cos(41033) * 1;
+acc += Math.sin(41033) + Math.cos(41034) * 2;
+acc += Math.sin(41034) + Math.cos(41035) * 3;
+acc += Math.sin(41035) + Math.cos(41036) * 4;
+acc += Math.sin(41036) + Math.cos(41037) * 5;
+acc += Math.sin(41037) + Math.cos(41038) * 6;
+acc += Math.sin(41038) + Math.cos(41039) * 7;
+acc += Math.sin(41039) + Math.cos(41040) * 8;
+acc += Math.sin(41040) + Math.cos(41041) * 9;
+acc += Math.sin(41041) + Math.cos(41042) * 10;
+acc += Math.sin(41042) + Math.cos(41043) * 11;
+acc += Math.sin(41043) + Math.cos(41044) * 12;
+acc += Math.sin(41044) + Math.cos(41045) * 13;
+acc += Math.sin(41045) + Math.cos(41046) * 14;
+acc += Math.sin(41046) + Math.cos(41047) * 15;
+acc += Math.sin(41047) + Math.cos(41048) * 16;
+acc += Math.sin(41048) + Math.cos(41049) * 17;
+acc += Math.sin(41049) + Math.cos(41050) * 18;
+acc += Math.sin(41050) + Math.cos(41051) * 19;
+acc += Math.sin(41051) + Math.cos(41052) * 20;
+acc += Math.sin(41052) + Math.cos(41053) * 21;
+acc += Math.sin(41053) + Math.cos(41054) * 22;
+acc += Math.sin(41054) + Math.cos(41055) * 23;
+acc += Math.sin(41055) + Math.cos(41056) * 24;
+acc += Math.sin(41056) + Math.cos(41057) * 25;
+acc += Math.sin(41057) + Math.cos(41058) * 26;
+acc += Math.sin(41058) + Math.cos(41059) * 27;
+acc += Math.sin(41059) + Math.cos(41060) * 28;
+acc += Math.sin(41060) + Math.cos(41061) * 29;
+acc += Math.sin(41061) + Math.cos(41062) * 30;
+acc += Math.sin(41062) + Math.cos(41063) * 31;
+acc += Math.sin(41063) + Math.cos(41064) * 32;
+acc += Math.sin(41064) + Math.cos(41065) * 33;
+acc += Math.sin(41065) + Math.cos(41066) * 34;
+acc += Math.sin(41066) + Math.cos(41067) * 35;
+acc += Math.sin(41067) + Math.cos(41068) * 36;
+acc += Math.sin(41068) + Math.cos(41069) * 37;
+acc += Math.sin(41069) + Math.cos(41070) * 38;
+acc += Math.sin(41070) + Math.cos(41071) * 39;
+acc += Math.sin(41071) + Math.cos(41072) * 40;
+acc += Math.sin(41072) + Math.cos(41073) * 41;
+acc += Math.sin(41073) + Math.cos(41074) * 42;
+acc += Math.sin(41074) + Math.cos(41075) * 43;
+acc += Math.sin(41075) + Math.cos(41076) * 44;
+acc += Math.sin(41076) + Math.cos(41077) * 45;
+acc += Math.sin(41077) + Math.cos(41078) * 46;
+acc += Math.sin(41078) + Math.cos(41079) * 47;
+acc += Math.sin(41079) + Math.cos(41080) * 48;
+acc += Math.sin(41080) + Math.cos(41081) * 49;
+acc += Math.sin(41081) + Math.cos(41082) * 50;
+acc += Math.sin(41082) + Math.cos(41083) * 51;
+acc += Math.sin(41083) + Math.cos(41084) * 52;
+acc += Math.sin(41084) + Math.cos(41085) * 53;
+acc += Math.sin(41085) + Math.cos(41086) * 54;
+acc += Math.sin(41086) + Math.cos(41087) * 55;
+acc += Math.sin(41087) + Math.cos(41088) * 56;
+acc += Math.sin(41088) + Math.cos(41089) * 57;
+acc += Math.sin(41089) + Math.cos(41090) * 58;
+acc += Math.sin(41090) + Math.cos(41091) * 59;
+acc += Math.sin(41091) + Math.cos(41092) * 60;
+acc += Math.sin(41092) + Math.cos(41093) * 61;
+acc += Math.sin(41093) + Math.cos(41094) * 62;
+acc += Math.sin(41094) + Math.cos(41095) * 63;
+acc += Math.sin(41095) + Math.cos(41096) * 64;
+acc += Math.sin(41096) + Math.cos(41097) * 65;
+acc += Math.sin(41097) + Math.cos(41098) * 66;
+acc += Math.sin(41098) + Math.cos(41099) * 67;
+acc += Math.sin(41099) + Math.cos(41100) * 68;
+acc += Math.sin(41100) + Math.cos(41101) * 69;
+acc += Math.sin(41101) + Math.cos(41102) * 70;
+acc += Math.sin(41102) + Math.cos(41103) * 71;
+acc += Math.sin(41103) + Math.cos(41104) * 72;
+acc += Math.sin(41104) + Math.cos(41105) * 73;
+acc += Math.sin(41105) + Math.cos(41106) * 74;
+acc += Math.sin(41106) + Math.cos(41107) * 75;
+acc += Math.sin(41107) + Math.cos(41108) * 76;
+acc += Math.sin(41108) + Math.cos(41109) * 77;
+acc += Math.sin(41109) + Math.cos(41110) * 78;
+acc += Math.sin(41110) + Math.cos(41111) * 79;
+acc += Math.sin(41111) + Math.cos(41112) * 80;
+acc += Math.sin(41112) + Math.cos(41113) * 81;
+acc += Math.sin(41113) + Math.cos(41114) * 82;
+acc += Math.sin(41114) + Math.cos(41115) * 83;
+acc += Math.sin(41115) + Math.cos(41116) * 84;
+acc += Math.sin(41116) + Math.cos(41117) * 85;
+acc += Math.sin(41117) + Math.cos(41118) * 86;
+acc += Math.sin(41118) + Math.cos(41119) * 87;
+acc += Math.sin(41119) + Math.cos(41120) * 88;
+acc += Math.sin(41120) + Math.cos(41121) * 89;
+acc += Math.sin(41121) + Math.cos(41122) * 90;
+acc += Math.sin(41122) + Math.cos(41123) * 91;
+acc += Math.sin(41123) + Math.cos(41124) * 92;
+acc += Math.sin(41124) + Math.cos(41125) * 93;
+acc += Math.sin(41125) + Math.cos(41126) * 94;
+acc += Math.sin(41126) + Math.cos(41127) * 95;
+acc += Math.sin(41127) + Math.cos(41128) * 96;
+acc += Math.sin(41128) + Math.cos(41129) * 0;
+acc += Math.sin(41129) + Math.cos(41130) * 1;
+acc += Math.sin(41130) + Math.cos(41131) * 2;
+acc += Math.sin(41131) + Math.cos(41132) * 3;
+acc += Math.sin(41132) + Math.cos(41133) * 4;
+acc += Math.sin(41133) + Math.cos(41134) * 5;
+acc += Math.sin(41134) + Math.cos(41135) * 6;
+acc += Math.sin(41135) + Math.cos(41136) * 7;
+acc += Math.sin(41136) + Math.cos(41137) * 8;
+acc += Math.sin(41137) + Math.cos(41138) * 9;
+acc += Math.sin(41138) + Math.cos(41139) * 10;
+acc += Math.sin(41139) + Math.cos(41140) * 11;
+acc += Math.sin(41140) + Math.cos(41141) * 12;
+acc += Math.sin(41141) + Math.cos(41142) * 13;
+acc += Math.sin(41142) + Math.cos(41143) * 14;
+acc += Math.sin(41143) + Math.cos(41144) * 15;
+acc += Math.sin(41144) + Math.cos(41145) * 16;
+acc += Math.sin(41145) + Math.cos(41146) * 17;
+acc += Math.sin(41146) + Math.cos(41147) * 18;
+acc += Math.sin(41147) + Math.cos(41148) * 19;
+acc += Math.sin(41148) + Math.cos(41149) * 20;
+acc += Math.sin(41149) + Math.cos(41150) * 21;
+acc += Math.sin(41150) + Math.cos(41151) * 22;
+acc += Math.sin(41151) + Math.cos(41152) * 23;
+acc += Math.sin(41152) + Math.cos(41153) * 24;
+acc += Math.sin(41153) + Math.cos(41154) * 25;
+acc += Math.sin(41154) + Math.cos(41155) * 26;
+acc += Math.sin(41155) + Math.cos(41156) * 27;
+acc += Math.sin(41156) + Math.cos(41157) * 28;
+acc += Math.sin(41157) + Math.cos(41158) * 29;
+acc += Math.sin(41158) + Math.cos(41159) * 30;
+acc += Math.sin(41159) + Math.cos(41160) * 31;
+acc += Math.sin(41160) + Math.cos(41161) * 32;
+acc += Math.sin(41161) + Math.cos(41162) * 33;
+acc += Math.sin(41162) + Math.cos(41163) * 34;
+acc += Math.sin(41163) + Math.cos(41164) * 35;
+acc += Math.sin(41164) + Math.cos(41165) * 36;
+acc += Math.sin(41165) + Math.cos(41166) * 37;
+acc += Math.sin(41166) + Math.cos(41167) * 38;
+acc += Math.sin(41167) + Math.cos(41168) * 39;
+acc += Math.sin(41168) + Math.cos(41169) * 40;
+acc += Math.sin(41169) + Math.cos(41170) * 41;
+acc += Math.sin(41170) + Math.cos(41171) * 42;
+acc += Math.sin(41171) + Math.cos(41172) * 43;
+acc += Math.sin(41172) + Math.cos(41173) * 44;
+acc += Math.sin(41173) + Math.cos(41174) * 45;
+acc += Math.sin(41174) + Math.cos(41175) * 46;
+acc += Math.sin(41175) + Math.cos(41176) * 47;
+acc += Math.sin(41176) + Math.cos(41177) * 48;
+acc += Math.sin(41177) + Math.cos(41178) * 49;
+acc += Math.sin(41178) + Math.cos(41179) * 50;
+acc += Math.sin(41179) + Math.cos(41180) * 51;
+acc += Math.sin(41180) + Math.cos(41181) * 52;
+acc += Math.sin(41181) + Math.cos(41182) * 53;
+acc += Math.sin(41182) + Math.cos(41183) * 54;
+acc += Math.sin(41183) + Math.cos(41184) * 55;
+acc += Math.sin(41184) + Math.cos(41185) * 56;
+acc += Math.sin(41185) + Math.cos(41186) * 57;
+acc += Math.sin(41186) + Math.cos(41187) * 58;
+acc += Math.sin(41187) + Math.cos(41188) * 59;
+acc += Math.sin(41188) + Math.cos(41189) * 60;
+acc += Math.sin(41189) + Math.cos(41190) * 61;
+acc += Math.sin(41190) + Math.cos(41191) * 62;
+acc += Math.sin(41191) + Math.cos(41192) * 63;
+acc += Math.sin(41192) + Math.cos(41193) * 64;
+acc += Math.sin(41193) + Math.cos(41194) * 65;
+acc += Math.sin(41194) + Math.cos(41195) * 66;
+acc += Math.sin(41195) + Math.cos(41196) * 67;
+acc += Math.sin(41196) + Math.cos(41197) * 68;
+acc += Math.sin(41197) + Math.cos(41198) * 69;
+acc += Math.sin(41198) + Math.cos(41199) * 70;
+acc += Math.sin(41199) + Math.cos(41200) * 71;
+acc += Math.sin(41200) + Math.cos(41201) * 72;
+acc += Math.sin(41201) + Math.cos(41202) * 73;
+acc += Math.sin(41202) + Math.cos(41203) * 74;
+acc += Math.sin(41203) + Math.cos(41204) * 75;
+acc += Math.sin(41204) + Math.cos(41205) * 76;
+acc += Math.sin(41205) + Math.cos(41206) * 77;
+acc += Math.sin(41206) + Math.cos(41207) * 78;
+acc += Math.sin(41207) + Math.cos(41208) * 79;
+acc += Math.sin(41208) + Math.cos(41209) * 80;
+acc += Math.sin(41209) + Math.cos(41210) * 81;
+acc += Math.sin(41210) + Math.cos(41211) * 82;
+acc += Math.sin(41211) + Math.cos(41212) * 83;
+acc += Math.sin(41212) + Math.cos(41213) * 84;
+acc += Math.sin(41213) + Math.cos(41214) * 85;
+acc += Math.sin(41214) + Math.cos(41215) * 86;
+acc += Math.sin(41215) + Math.cos(41216) * 87;
+acc += Math.sin(41216) + Math.cos(41217) * 88;
+acc += Math.sin(41217) + Math.cos(41218) * 89;
+acc += Math.sin(41218) + Math.cos(41219) * 90;
+acc += Math.sin(41219) + Math.cos(41220) * 91;
+acc += Math.sin(41220) + Math.cos(41221) * 92;
+acc += Math.sin(41221) + Math.cos(41222) * 93;
+acc += Math.sin(41222) + Math.cos(41223) * 94;
+acc += Math.sin(41223) + Math.cos(41224) * 95;
+acc += Math.sin(41224) + Math.cos(41225) * 96;
+acc += Math.sin(41225) + Math.cos(41226) * 0;
+acc += Math.sin(41226) + Math.cos(41227) * 1;
+acc += Math.sin(41227) + Math.cos(41228) * 2;
+acc += Math.sin(41228) + Math.cos(41229) * 3;
+acc += Math.sin(41229) + Math.cos(41230) * 4;
+acc += Math.sin(41230) + Math.cos(41231) * 5;
+acc += Math.sin(41231) + Math.cos(41232) * 6;
+acc += Math.sin(41232) + Math.cos(41233) * 7;
+acc += Math.sin(41233) + Math.cos(41234) * 8;
+acc += Math.sin(41234) + Math.cos(41235) * 9;
+acc += Math.sin(41235) + Math.cos(41236) * 10;
+acc += Math.sin(41236) + Math.cos(41237) * 11;
+acc += Math.sin(41237) + Math.cos(41238) * 12;
+acc += Math.sin(41238) + Math.cos(41239) * 13;
+acc += Math.sin(41239) + Math.cos(41240) * 14;
+acc += Math.sin(41240) + Math.cos(41241) * 15;
+acc += Math.sin(41241) + Math.cos(41242) * 16;
+acc += Math.sin(41242) + Math.cos(41243) * 17;
+acc += Math.sin(41243) + Math.cos(41244) * 18;
+acc += Math.sin(41244) + Math.cos(41245) * 19;
+acc += Math.sin(41245) + Math.cos(41246) * 20;
+acc += Math.sin(41246) + Math.cos(41247) * 21;
+acc += Math.sin(41247) + Math.cos(41248) * 22;
+acc += Math.sin(41248) + Math.cos(41249) * 23;
+acc += Math.sin(41249) + Math.cos(41250) * 24;
+acc += Math.sin(41250) + Math.cos(41251) * 25;
+acc += Math.sin(41251) + Math.cos(41252) * 26;
+acc += Math.sin(41252) + Math.cos(41253) * 27;
+acc += Math.sin(41253) + Math.cos(41254) * 28;
+acc += Math.sin(41254) + Math.cos(41255) * 29;
+acc += Math.sin(41255) + Math.cos(41256) * 30;
+acc += Math.sin(41256) + Math.cos(41257) * 31;
+acc += Math.sin(41257) + Math.cos(41258) * 32;
+acc += Math.sin(41258) + Math.cos(41259) * 33;
+acc += Math.sin(41259) + Math.cos(41260) * 34;
+acc += Math.sin(41260) + Math.cos(41261) * 35;
+acc += Math.sin(41261) + Math.cos(41262) * 36;
+acc += Math.sin(41262) + Math.cos(41263) * 37;
+acc += Math.sin(41263) + Math.cos(41264) * 38;
+acc += Math.sin(41264) + Math.cos(41265) * 39;
+acc += Math.sin(41265) + Math.cos(41266) * 40;
+acc += Math.sin(41266) + Math.cos(41267) * 41;
+acc += Math.sin(41267) + Math.cos(41268) * 42;
+acc += Math.sin(41268) + Math.cos(41269) * 43;
+acc += Math.sin(41269) + Math.cos(41270) * 44;
+acc += Math.sin(41270) + Math.cos(41271) * 45;
+acc += Math.sin(41271) + Math.cos(41272) * 46;
+acc += Math.sin(41272) + Math.cos(41273) * 47;
+acc += Math.sin(41273) + Math.cos(41274) * 48;
+acc += Math.sin(41274) + Math.cos(41275) * 49;
+acc += Math.sin(41275) + Math.cos(41276) * 50;
+acc += Math.sin(41276) + Math.cos(41277) * 51;
+acc += Math.sin(41277) + Math.cos(41278) * 52;
+acc += Math.sin(41278) + Math.cos(41279) * 53;
+acc += Math.sin(41279) + Math.cos(41280) * 54;
+acc += Math.sin(41280) + Math.cos(41281) * 55;
+acc += Math.sin(41281) + Math.cos(41282) * 56;
+acc += Math.sin(41282) + Math.cos(41283) * 57;
+acc += Math.sin(41283) + Math.cos(41284) * 58;
+acc += Math.sin(41284) + Math.cos(41285) * 59;
+acc += Math.sin(41285) + Math.cos(41286) * 60;
+acc += Math.sin(41286) + Math.cos(41287) * 61;
+acc += Math.sin(41287) + Math.cos(41288) * 62;
+acc += Math.sin(41288) + Math.cos(41289) * 63;
+acc += Math.sin(41289) + Math.cos(41290) * 64;
+acc += Math.sin(41290) + Math.cos(41291) * 65;
+acc += Math.sin(41291) + Math.cos(41292) * 66;
+acc += Math.sin(41292) + Math.cos(41293) * 67;
+acc += Math.sin(41293) + Math.cos(41294) * 68;
+acc += Math.sin(41294) + Math.cos(41295) * 69;
+acc += Math.sin(41295) + Math.cos(41296) * 70;
+acc += Math.sin(41296) + Math.cos(41297) * 71;
+acc += Math.sin(41297) + Math.cos(41298) * 72;
+acc += Math.sin(41298) + Math.cos(41299) * 73;
+acc += Math.sin(41299) + Math.cos(41300) * 74;
+acc += Math.sin(41300) + Math.cos(41301) * 75;
+acc += Math.sin(41301) + Math.cos(41302) * 76;
+acc += Math.sin(41302) + Math.cos(41303) * 77;
+acc += Math.sin(41303) + Math.cos(41304) * 78;
+acc += Math.sin(41304) + Math.cos(41305) * 79;
+acc += Math.sin(41305) + Math.cos(41306) * 80;
+acc += Math.sin(41306) + Math.cos(41307) * 81;
+acc += Math.sin(41307) + Math.cos(41308) * 82;
+acc += Math.sin(41308) + Math.cos(41309) * 83;
+acc += Math.sin(41309) + Math.cos(41310) * 84;
+acc += Math.sin(41310) + Math.cos(41311) * 85;
+acc += Math.sin(41311) + Math.cos(41312) * 86;
+acc += Math.sin(41312) + Math.cos(41313) * 87;
+acc += Math.sin(41313) + Math.cos(41314) * 88;
+acc += Math.sin(41314) + Math.cos(41315) * 89;
+acc += Math.sin(41315) + Math.cos(41316) * 90;
+acc += Math.sin(41316) + Math.cos(41317) * 91;
+acc += Math.sin(41317) + Math.cos(41318) * 92;
+acc += Math.sin(41318) + Math.cos(41319) * 93;
+acc += Math.sin(41319) + Math.cos(41320) * 94;
+acc += Math.sin(41320) + Math.cos(41321) * 95;
+acc += Math.sin(41321) + Math.cos(41322) * 96;
+acc += Math.sin(41322) + Math.cos(41323) * 0;
+acc += Math.sin(41323) + Math.cos(41324) * 1;
+acc += Math.sin(41324) + Math.cos(41325) * 2;
+acc += Math.sin(41325) + Math.cos(41326) * 3;
+acc += Math.sin(41326) + Math.cos(41327) * 4;
+acc += Math.sin(41327) + Math.cos(41328) * 5;
+acc += Math.sin(41328) + Math.cos(41329) * 6;
+acc += Math.sin(41329) + Math.cos(41330) * 7;
+acc += Math.sin(41330) + Math.cos(41331) * 8;
+acc += Math.sin(41331) + Math.cos(41332) * 9;
+acc += Math.sin(41332) + Math.cos(41333) * 10;
+acc += Math.sin(41333) + Math.cos(41334) * 11;
+acc += Math.sin(41334) + Math.cos(41335) * 12;
+acc += Math.sin(41335) + Math.cos(41336) * 13;
+acc += Math.sin(41336) + Math.cos(41337) * 14;
+acc += Math.sin(41337) + Math.cos(41338) * 15;
+acc += Math.sin(41338) + Math.cos(41339) * 16;
+acc += Math.sin(41339) + Math.cos(41340) * 17;
+acc += Math.sin(41340) + Math.cos(41341) * 18;
+acc += Math.sin(41341) + Math.cos(41342) * 19;
+acc += Math.sin(41342) + Math.cos(41343) * 20;
+acc += Math.sin(41343) + Math.cos(41344) * 21;
+acc += Math.sin(41344) + Math.cos(41345) * 22;
+acc += Math.sin(41345) + Math.cos(41346) * 23;
+acc += Math.sin(41346) + Math.cos(41347) * 24;
+acc += Math.sin(41347) + Math.cos(41348) * 25;
+acc += Math.sin(41348) + Math.cos(41349) * 26;
+acc += Math.sin(41349) + Math.cos(41350) * 27;
+acc += Math.sin(41350) + Math.cos(41351) * 28;
+acc += Math.sin(41351) + Math.cos(41352) * 29;
+acc += Math.sin(41352) + Math.cos(41353) * 30;
+acc += Math.sin(41353) + Math.cos(41354) * 31;
+acc += Math.sin(41354) + Math.cos(41355) * 32;
+acc += Math.sin(41355) + Math.cos(41356) * 33;
+acc += Math.sin(41356) + Math.cos(41357) * 34;
+acc += Math.sin(41357) + Math.cos(41358) * 35;
+acc += Math.sin(41358) + Math.cos(41359) * 36;
+acc += Math.sin(41359) + Math.cos(41360) * 37;
+acc += Math.sin(41360) + Math.cos(41361) * 38;
+acc += Math.sin(41361) + Math.cos(41362) * 39;
+acc += Math.sin(41362) + Math.cos(41363) * 40;
+acc += Math.sin(41363) + Math.cos(41364) * 41;
+acc += Math.sin(41364) + Math.cos(41365) * 42;
+acc += Math.sin(41365) + Math.cos(41366) * 43;
+acc += Math.sin(41366) + Math.cos(41367) * 44;
+acc += Math.sin(41367) + Math.cos(41368) * 45;
+acc += Math.sin(41368) + Math.cos(41369) * 46;
+acc += Math.sin(41369) + Math.cos(41370) * 47;
+acc += Math.sin(41370) + Math.cos(41371) * 48;
+acc += Math.sin(41371) + Math.cos(41372) * 49;
+acc += Math.sin(41372) + Math.cos(41373) * 50;
+acc += Math.sin(41373) + Math.cos(41374) * 51;
+acc += Math.sin(41374) + Math.cos(41375) * 52;
+acc += Math.sin(41375) + Math.cos(41376) * 53;
+acc += Math.sin(41376) + Math.cos(41377) * 54;
+acc += Math.sin(41377) + Math.cos(41378) * 55;
+acc += Math.sin(41378) + Math.cos(41379) * 56;
+acc += Math.sin(41379) + Math.cos(41380) * 57;
+acc += Math.sin(41380) + Math.cos(41381) * 58;
+acc += Math.sin(41381) + Math.cos(41382) * 59;
+acc += Math.sin(41382) + Math.cos(41383) * 60;
+acc += Math.sin(41383) + Math.cos(41384) * 61;
+acc += Math.sin(41384) + Math.cos(41385) * 62;
+acc += Math.sin(41385) + Math.cos(41386) * 63;
+acc += Math.sin(41386) + Math.cos(41387) * 64;
+acc += Math.sin(41387) + Math.cos(41388) * 65;
+acc += Math.sin(41388) + Math.cos(41389) * 66;
+acc += Math.sin(41389) + Math.cos(41390) * 67;
+acc += Math.sin(41390) + Math.cos(41391) * 68;
+acc += Math.sin(41391) + Math.cos(41392) * 69;
+acc += Math.sin(41392) + Math.cos(41393) * 70;
+acc += Math.sin(41393) + Math.cos(41394) * 71;
+acc += Math.sin(41394) + Math.cos(41395) * 72;
+acc += Math.sin(41395) + Math.cos(41396) * 73;
+acc += Math.sin(41396) + Math.cos(41397) * 74;
+acc += Math.sin(41397) + Math.cos(41398) * 75;
+acc += Math.sin(41398) + Math.cos(41399) * 76;
+acc += Math.sin(41399) + Math.cos(41400) * 77;
+acc += Math.sin(41400) + Math.cos(41401) * 78;
+acc += Math.sin(41401) + Math.cos(41402) * 79;
+acc += Math.sin(41402) + Math.cos(41403) * 80;
+acc += Math.sin(41403) + Math.cos(41404) * 81;
+acc += Math.sin(41404) + Math.cos(41405) * 82;
+acc += Math.sin(41405) + Math.cos(41406) * 83;
+acc += Math.sin(41406) + Math.cos(41407) * 84;
+acc += Math.sin(41407) + Math.cos(41408) * 85;
+acc += Math.sin(41408) + Math.cos(41409) * 86;
+acc += Math.sin(41409) + Math.cos(41410) * 87;
+acc += Math.sin(41410) + Math.cos(41411) * 88;
+acc += Math.sin(41411) + Math.cos(41412) * 89;
+acc += Math.sin(41412) + Math.cos(41413) * 90;
+acc += Math.sin(41413) + Math.cos(41414) * 91;
+acc += Math.sin(41414) + Math.cos(41415) * 92;
+acc += Math.sin(41415) + Math.cos(41416) * 93;
+acc += Math.sin(41416) + Math.cos(41417) * 94;
+acc += Math.sin(41417) + Math.cos(41418) * 95;
+acc += Math.sin(41418) + Math.cos(41419) * 96;
+acc += Math.sin(41419) + Math.cos(41420) * 0;
+acc += Math.sin(41420) + Math.cos(41421) * 1;
+acc += Math.sin(41421) + Math.cos(41422) * 2;
+acc += Math.sin(41422) + Math.cos(41423) * 3;
+acc += Math.sin(41423) + Math.cos(41424) * 4;
+acc += Math.sin(41424) + Math.cos(41425) * 5;
+acc += Math.sin(41425) + Math.cos(41426) * 6;
+acc += Math.sin(41426) + Math.cos(41427) * 7;
+acc += Math.sin(41427) + Math.cos(41428) * 8;
+acc += Math.sin(41428) + Math.cos(41429) * 9;
+acc += Math.sin(41429) + Math.cos(41430) * 10;
+acc += Math.sin(41430) + Math.cos(41431) * 11;
+acc += Math.sin(41431) + Math.cos(41432) * 12;
+acc += Math.sin(41432) + Math.cos(41433) * 13;
+acc += Math.sin(41433) + Math.cos(41434) * 14;
+acc += Math.sin(41434) + Math.cos(41435) * 15;
+acc += Math.sin(41435) + Math.cos(41436) * 16;
+acc += Math.sin(41436) + Math.cos(41437) * 17;
+acc += Math.sin(41437) + Math.cos(41438) * 18;
+acc += Math.sin(41438) + Math.cos(41439) * 19;
+acc += Math.sin(41439) + Math.cos(41440) * 20;
+acc += Math.sin(41440) + Math.cos(41441) * 21;
+acc += Math.sin(41441) + Math.cos(41442) * 22;
+acc += Math.sin(41442) + Math.cos(41443) * 23;
+acc += Math.sin(41443) + Math.cos(41444) * 24;
+acc += Math.sin(41444) + Math.cos(41445) * 25;
+acc += Math.sin(41445) + Math.cos(41446) * 26;
+acc += Math.sin(41446) + Math.cos(41447) * 27;
+acc += Math.sin(41447) + Math.cos(41448) * 28;
+acc += Math.sin(41448) + Math.cos(41449) * 29;
+acc += Math.sin(41449) + Math.cos(41450) * 30;
+acc += Math.sin(41450) + Math.cos(41451) * 31;
+acc += Math.sin(41451) + Math.cos(41452) * 32;
+acc += Math.sin(41452) + Math.cos(41453) * 33;
+acc += Math.sin(41453) + Math.cos(41454) * 34;
+acc += Math.sin(41454) + Math.cos(41455) * 35;
+acc += Math.sin(41455) + Math.cos(41456) * 36;
+acc += Math.sin(41456) + Math.cos(41457) * 37;
+acc += Math.sin(41457) + Math.cos(41458) * 38;
+acc += Math.sin(41458) + Math.cos(41459) * 39;
+acc += Math.sin(41459) + Math.cos(41460) * 40;
+acc += Math.sin(41460) + Math.cos(41461) * 41;
+acc += Math.sin(41461) + Math.cos(41462) * 42;
+acc += Math.sin(41462) + Math.cos(41463) * 43;
+acc += Math.sin(41463) + Math.cos(41464) * 44;
+acc += Math.sin(41464) + Math.cos(41465) * 45;
+acc += Math.sin(41465) + Math.cos(41466) * 46;
+acc += Math.sin(41466) + Math.cos(41467) * 47;
+acc += Math.sin(41467) + Math.cos(41468) * 48;
+acc += Math.sin(41468) + Math.cos(41469) * 49;
+acc += Math.sin(41469) + Math.cos(41470) * 50;
+acc += Math.sin(41470) + Math.cos(41471) * 51;
+acc += Math.sin(41471) + Math.cos(41472) * 52;
+acc += Math.sin(41472) + Math.cos(41473) * 53;
+acc += Math.sin(41473) + Math.cos(41474) * 54;
+acc += Math.sin(41474) + Math.cos(41475) * 55;
+acc += Math.sin(41475) + Math.cos(41476) * 56;
+acc += Math.sin(41476) + Math.cos(41477) * 57;
+acc += Math.sin(41477) + Math.cos(41478) * 58;
+acc += Math.sin(41478) + Math.cos(41479) * 59;
+acc += Math.sin(41479) + Math.cos(41480) * 60;
+acc += Math.sin(41480) + Math.cos(41481) * 61;
+acc += Math.sin(41481) + Math.cos(41482) * 62;
+acc += Math.sin(41482) + Math.cos(41483) * 63;
+acc += Math.sin(41483) + Math.cos(41484) * 64;
+acc += Math.sin(41484) + Math.cos(41485) * 65;
+acc += Math.sin(41485) + Math.cos(41486) * 66;
+acc += Math.sin(41486) + Math.cos(41487) * 67;
+acc += Math.sin(41487) + Math.cos(41488) * 68;
+acc += Math.sin(41488) + Math.cos(41489) * 69;
+acc += Math.sin(41489) + Math.cos(41490) * 70;
+acc += Math.sin(41490) + Math.cos(41491) * 71;
+acc += Math.sin(41491) + Math.cos(41492) * 72;
+acc += Math.sin(41492) + Math.cos(41493) * 73;
+acc += Math.sin(41493) + Math.cos(41494) * 74;
+acc += Math.sin(41494) + Math.cos(41495) * 75;
+acc += Math.sin(41495) + Math.cos(41496) * 76;
+acc += Math.sin(41496) + Math.cos(41497) * 77;
+acc += Math.sin(41497) + Math.cos(41498) * 78;
+acc += Math.sin(41498) + Math.cos(41499) * 79;
+acc += Math.sin(41499) + Math.cos(41500) * 80;
+acc += Math.sin(41500) + Math.cos(41501) * 81;
+acc += Math.sin(41501) + Math.cos(41502) * 82;
+acc += Math.sin(41502) + Math.cos(41503) * 83;
+acc += Math.sin(41503) + Math.cos(41504) * 84;
+acc += Math.sin(41504) + Math.cos(41505) * 85;
+acc += Math.sin(41505) + Math.cos(41506) * 86;
+acc += Math.sin(41506) + Math.cos(41507) * 87;
+acc += Math.sin(41507) + Math.cos(41508) * 88;
+acc += Math.sin(41508) + Math.cos(41509) * 89;
+acc += Math.sin(41509) + Math.cos(41510) * 90;
+acc += Math.sin(41510) + Math.cos(41511) * 91;
+acc += Math.sin(41511) + Math.cos(41512) * 92;
+acc += Math.sin(41512) + Math.cos(41513) * 93;
+acc += Math.sin(41513) + Math.cos(41514) * 94;
+acc += Math.sin(41514) + Math.cos(41515) * 95;
+acc += Math.sin(41515) + Math.cos(41516) * 96;
+acc += Math.sin(41516) + Math.cos(41517) * 0;
+acc += Math.sin(41517) + Math.cos(41518) * 1;
+acc += Math.sin(41518) + Math.cos(41519) * 2;
+acc += Math.sin(41519) + Math.cos(41520) * 3;
+acc += Math.sin(41520) + Math.cos(41521) * 4;
+acc += Math.sin(41521) + Math.cos(41522) * 5;
+acc += Math.sin(41522) + Math.cos(41523) * 6;
+acc += Math.sin(41523) + Math.cos(41524) * 7;
+acc += Math.sin(41524) + Math.cos(41525) * 8;
+acc += Math.sin(41525) + Math.cos(41526) * 9;
+acc += Math.sin(41526) + Math.cos(41527) * 10;
+acc += Math.sin(41527) + Math.cos(41528) * 11;
+acc += Math.sin(41528) + Math.cos(41529) * 12;
+acc += Math.sin(41529) + Math.cos(41530) * 13;
+acc += Math.sin(41530) + Math.cos(41531) * 14;
+acc += Math.sin(41531) + Math.cos(41532) * 15;
+acc += Math.sin(41532) + Math.cos(41533) * 16;
+acc += Math.sin(41533) + Math.cos(41534) * 17;
+acc += Math.sin(41534) + Math.cos(41535) * 18;
+acc += Math.sin(41535) + Math.cos(41536) * 19;
+acc += Math.sin(41536) + Math.cos(41537) * 20;
+acc += Math.sin(41537) + Math.cos(41538) * 21;
+acc += Math.sin(41538) + Math.cos(41539) * 22;
+acc += Math.sin(41539) + Math.cos(41540) * 23;
+acc += Math.sin(41540) + Math.cos(41541) * 24;
+acc += Math.sin(41541) + Math.cos(41542) * 25;
+acc += Math.sin(41542) + Math.cos(41543) * 26;
+acc += Math.sin(41543) + Math.cos(41544) * 27;
+acc += Math.sin(41544) + Math.cos(41545) * 28;
+acc += Math.sin(41545) + Math.cos(41546) * 29;
+acc += Math.sin(41546) + Math.cos(41547) * 30;
+acc += Math.sin(41547) + Math.cos(41548) * 31;
+acc += Math.sin(41548) + Math.cos(41549) * 32;
+acc += Math.sin(41549) + Math.cos(41550) * 33;
+acc += Math.sin(41550) + Math.cos(41551) * 34;
+acc += Math.sin(41551) + Math.cos(41552) * 35;
+acc += Math.sin(41552) + Math.cos(41553) * 36;
+acc += Math.sin(41553) + Math.cos(41554) * 37;
+acc += Math.sin(41554) + Math.cos(41555) * 38;
+acc += Math.sin(41555) + Math.cos(41556) * 39;
+acc += Math.sin(41556) + Math.cos(41557) * 40;
+acc += Math.sin(41557) + Math.cos(41558) * 41;
+acc += Math.sin(41558) + Math.cos(41559) * 42;
+acc += Math.sin(41559) + Math.cos(41560) * 43;
+acc += Math.sin(41560) + Math.cos(41561) * 44;
+acc += Math.sin(41561) + Math.cos(41562) * 45;
+acc += Math.sin(41562) + Math.cos(41563) * 46;
+acc += Math.sin(41563) + Math.cos(41564) * 47;
+acc += Math.sin(41564) + Math.cos(41565) * 48;
+acc += Math.sin(41565) + Math.cos(41566) * 49;
+acc += Math.sin(41566) + Math.cos(41567) * 50;
+acc += Math.sin(41567) + Math.cos(41568) * 51;
+acc += Math.sin(41568) + Math.cos(41569) * 52;
+acc += Math.sin(41569) + Math.cos(41570) * 53;
+acc += Math.sin(41570) + Math.cos(41571) * 54;
+acc += Math.sin(41571) + Math.cos(41572) * 55;
+acc += Math.sin(41572) + Math.cos(41573) * 56;
+acc += Math.sin(41573) + Math.cos(41574) * 57;
+acc += Math.sin(41574) + Math.cos(41575) * 58;
+acc += Math.sin(41575) + Math.cos(41576) * 59;
+acc += Math.sin(41576) + Math.cos(41577) * 60;
+acc += Math.sin(41577) + Math.cos(41578) * 61;
+acc += Math.sin(41578) + Math.cos(41579) * 62;
+acc += Math.sin(41579) + Math.cos(41580) * 63;
+acc += Math.sin(41580) + Math.cos(41581) * 64;
+acc += Math.sin(41581) + Math.cos(41582) * 65;
+acc += Math.sin(41582) + Math.cos(41583) * 66;
+acc += Math.sin(41583) + Math.cos(41584) * 67;
+acc += Math.sin(41584) + Math.cos(41585) * 68;
+acc += Math.sin(41585) + Math.cos(41586) * 69;
+acc += Math.sin(41586) + Math.cos(41587) * 70;
+acc += Math.sin(41587) + Math.cos(41588) * 71;
+acc += Math.sin(41588) + Math.cos(41589) * 72;
+acc += Math.sin(41589) + Math.cos(41590) * 73;
+acc += Math.sin(41590) + Math.cos(41591) * 74;
+acc += Math.sin(41591) + Math.cos(41592) * 75;
+acc += Math.sin(41592) + Math.cos(41593) * 76;
+acc += Math.sin(41593) + Math.cos(41594) * 77;
+acc += Math.sin(41594) + Math.cos(41595) * 78;
+acc += Math.sin(41595) + Math.cos(41596) * 79;
+acc += Math.sin(41596) + Math.cos(41597) * 80;
+acc += Math.sin(41597) + Math.cos(41598) * 81;
+acc += Math.sin(41598) + Math.cos(41599) * 82;
+acc += Math.sin(41599) + Math.cos(41600) * 83;
+acc += Math.sin(41600) + Math.cos(41601) * 84;
+acc += Math.sin(41601) + Math.cos(41602) * 85;
+acc += Math.sin(41602) + Math.cos(41603) * 86;
+acc += Math.sin(41603) + Math.cos(41604) * 87;
+acc += Math.sin(41604) + Math.cos(41605) * 88;
+acc += Math.sin(41605) + Math.cos(41606) * 89;
+acc += Math.sin(41606) + Math.cos(41607) * 90;
+acc += Math.sin(41607) + Math.cos(41608) * 91;
+acc += Math.sin(41608) + Math.cos(41609) * 92;
+acc += Math.sin(41609) + Math.cos(41610) * 93;
+acc += Math.sin(41610) + Math.cos(41611) * 94;
+acc += Math.sin(41611) + Math.cos(41612) * 95;
+acc += Math.sin(41612) + Math.cos(41613) * 96;
+acc += Math.sin(41613) + Math.cos(41614) * 0;
+acc += Math.sin(41614) + Math.cos(41615) * 1;
+acc += Math.sin(41615) + Math.cos(41616) * 2;
+acc += Math.sin(41616) + Math.cos(41617) * 3;
+acc += Math.sin(41617) + Math.cos(41618) * 4;
+acc += Math.sin(41618) + Math.cos(41619) * 5;
+acc += Math.sin(41619) + Math.cos(41620) * 6;
+acc += Math.sin(41620) + Math.cos(41621) * 7;
+acc += Math.sin(41621) + Math.cos(41622) * 8;
+acc += Math.sin(41622) + Math.cos(41623) * 9;
+acc += Math.sin(41623) + Math.cos(41624) * 10;
+acc += Math.sin(41624) + Math.cos(41625) * 11;
+acc += Math.sin(41625) + Math.cos(41626) * 12;
+acc += Math.sin(41626) + Math.cos(41627) * 13;
+acc += Math.sin(41627) + Math.cos(41628) * 14;
+acc += Math.sin(41628) + Math.cos(41629) * 15;
+acc += Math.sin(41629) + Math.cos(41630) * 16;
+acc += Math.sin(41630) + Math.cos(41631) * 17;
+acc += Math.sin(41631) + Math.cos(41632) * 18;
+acc += Math.sin(41632) + Math.cos(41633) * 19;
+acc += Math.sin(41633) + Math.cos(41634) * 20;
+acc += Math.sin(41634) + Math.cos(41635) * 21;
+acc += Math.sin(41635) + Math.cos(41636) * 22;
+acc += Math.sin(41636) + Math.cos(41637) * 23;
+acc += Math.sin(41637) + Math.cos(41638) * 24;
+acc += Math.sin(41638) + Math.cos(41639) * 25;
+acc += Math.sin(41639) + Math.cos(41640) * 26;
+acc += Math.sin(41640) + Math.cos(41641) * 27;
+acc += Math.sin(41641) + Math.cos(41642) * 28;
+acc += Math.sin(41642) + Math.cos(41643) * 29;
+acc += Math.sin(41643) + Math.cos(41644) * 30;
+acc += Math.sin(41644) + Math.cos(41645) * 31;
+acc += Math.sin(41645) + Math.cos(41646) * 32;
+acc += Math.sin(41646) + Math.cos(41647) * 33;
+acc += Math.sin(41647) + Math.cos(41648) * 34;
+acc += Math.sin(41648) + Math.cos(41649) * 35;
+acc += Math.sin(41649) + Math.cos(41650) * 36;
+acc += Math.sin(41650) + Math.cos(41651) * 37;
+acc += Math.sin(41651) + Math.cos(41652) * 38;
+acc += Math.sin(41652) + Math.cos(41653) * 39;
+acc += Math.sin(41653) + Math.cos(41654) * 40;
+acc += Math.sin(41654) + Math.cos(41655) * 41;
+acc += Math.sin(41655) + Math.cos(41656) * 42;
+acc += Math.sin(41656) + Math.cos(41657) * 43;
+acc += Math.sin(41657) + Math.cos(41658) * 44;
+acc += Math.sin(41658) + Math.cos(41659) * 45;
+acc += Math.sin(41659) + Math.cos(41660) * 46;
+acc += Math.sin(41660) + Math.cos(41661) * 47;
+acc += Math.sin(41661) + Math.cos(41662) * 48;
+acc += Math.sin(41662) + Math.cos(41663) * 49;
+acc += Math.sin(41663) + Math.cos(41664) * 50;
+acc += Math.sin(41664) + Math.cos(41665) * 51;
+acc += Math.sin(41665) + Math.cos(41666) * 52;
+acc += Math.sin(41666) + Math.cos(41667) * 53;
+acc += Math.sin(41667) + Math.cos(41668) * 54;
+acc += Math.sin(41668) + Math.cos(41669) * 55;
+acc += Math.sin(41669) + Math.cos(41670) * 56;
+acc += Math.sin(41670) + Math.cos(41671) * 57;
+acc += Math.sin(41671) + Math.cos(41672) * 58;
+acc += Math.sin(41672) + Math.cos(41673) * 59;
+acc += Math.sin(41673) + Math.cos(41674) * 60;
+acc += Math.sin(41674) + Math.cos(41675) * 61;
+acc += Math.sin(41675) + Math.cos(41676) * 62;
+acc += Math.sin(41676) + Math.cos(41677) * 63;
+acc += Math.sin(41677) + Math.cos(41678) * 64;
+acc += Math.sin(41678) + Math.cos(41679) * 65;
+acc += Math.sin(41679) + Math.cos(41680) * 66;
+acc += Math.sin(41680) + Math.cos(41681) * 67;
+acc += Math.sin(41681) + Math.cos(41682) * 68;
+acc += Math.sin(41682) + Math.cos(41683) * 69;
+acc += Math.sin(41683) + Math.cos(41684) * 70;
+acc += Math.sin(41684) + Math.cos(41685) * 71;
+acc += Math.sin(41685) + Math.cos(41686) * 72;
+acc += Math.sin(41686) + Math.cos(41687) * 73;
+acc += Math.sin(41687) + Math.cos(41688) * 74;
+acc += Math.sin(41688) + Math.cos(41689) * 75;
+acc += Math.sin(41689) + Math.cos(41690) * 76;
+acc += Math.sin(41690) + Math.cos(41691) * 77;
+acc += Math.sin(41691) + Math.cos(41692) * 78;
+acc += Math.sin(41692) + Math.cos(41693) * 79;
+acc += Math.sin(41693) + Math.cos(41694) * 80;
+acc += Math.sin(41694) + Math.cos(41695) * 81;
+acc += Math.sin(41695) + Math.cos(41696) * 82;
+acc += Math.sin(41696) + Math.cos(41697) * 83;
+acc += Math.sin(41697) + Math.cos(41698) * 84;
+acc += Math.sin(41698) + Math.cos(41699) * 85;
+acc += Math.sin(41699) + Math.cos(41700) * 86;
+acc += Math.sin(41700) + Math.cos(41701) * 87;
+acc += Math.sin(41701) + Math.cos(41702) * 88;
+acc += Math.sin(41702) + Math.cos(41703) * 89;
+acc += Math.sin(41703) + Math.cos(41704) * 90;
+acc += Math.sin(41704) + Math.cos(41705) * 91;
+acc += Math.sin(41705) + Math.cos(41706) * 92;
+acc += Math.sin(41706) + Math.cos(41707) * 93;
+acc += Math.sin(41707) + Math.cos(41708) * 94;
+acc += Math.sin(41708) + Math.cos(41709) * 95;
+acc += Math.sin(41709) + Math.cos(41710) * 96;
+acc += Math.sin(41710) + Math.cos(41711) * 0;
+acc += Math.sin(41711) + Math.cos(41712) * 1;
+acc += Math.sin(41712) + Math.cos(41713) * 2;
+acc += Math.sin(41713) + Math.cos(41714) * 3;
+acc += Math.sin(41714) + Math.cos(41715) * 4;
+acc += Math.sin(41715) + Math.cos(41716) * 5;
+acc += Math.sin(41716) + Math.cos(41717) * 6;
+acc += Math.sin(41717) + Math.cos(41718) * 7;
+acc += Math.sin(41718) + Math.cos(41719) * 8;
+acc += Math.sin(41719) + Math.cos(41720) * 9;
+acc += Math.sin(41720) + Math.cos(41721) * 10;
+acc += Math.sin(41721) + Math.cos(41722) * 11;
+acc += Math.sin(41722) + Math.cos(41723) * 12;
+acc += Math.sin(41723) + Math.cos(41724) * 13;
+acc += Math.sin(41724) + Math.cos(41725) * 14;
+acc += Math.sin(41725) + Math.cos(41726) * 15;
+acc += Math.sin(41726) + Math.cos(41727) * 16;
+acc += Math.sin(41727) + Math.cos(41728) * 17;
+acc += Math.sin(41728) + Math.cos(41729) * 18;
+acc += Math.sin(41729) + Math.cos(41730) * 19;
+acc += Math.sin(41730) + Math.cos(41731) * 20;
+acc += Math.sin(41731) + Math.cos(41732) * 21;
+acc += Math.sin(41732) + Math.cos(41733) * 22;
+acc += Math.sin(41733) + Math.cos(41734) * 23;
+acc += Math.sin(41734) + Math.cos(41735) * 24;
+acc += Math.sin(41735) + Math.cos(41736) * 25;
+acc += Math.sin(41736) + Math.cos(41737) * 26;
+acc += Math.sin(41737) + Math.cos(41738) * 27;
+acc += Math.sin(41738) + Math.cos(41739) * 28;
+acc += Math.sin(41739) + Math.cos(41740) * 29;
+acc += Math.sin(41740) + Math.cos(41741) * 30;
+acc += Math.sin(41741) + Math.cos(41742) * 31;
+acc += Math.sin(41742) + Math.cos(41743) * 32;
+acc += Math.sin(41743) + Math.cos(41744) * 33;
+acc += Math.sin(41744) + Math.cos(41745) * 34;
+acc += Math.sin(41745) + Math.cos(41746) * 35;
+acc += Math.sin(41746) + Math.cos(41747) * 36;
+acc += Math.sin(41747) + Math.cos(41748) * 37;
+acc += Math.sin(41748) + Math.cos(41749) * 38;
+acc += Math.sin(41749) + Math.cos(41750) * 39;
+acc += Math.sin(41750) + Math.cos(41751) * 40;
+acc += Math.sin(41751) + Math.cos(41752) * 41;
+acc += Math.sin(41752) + Math.cos(41753) * 42;
+acc += Math.sin(41753) + Math.cos(41754) * 43;
+acc += Math.sin(41754) + Math.cos(41755) * 44;
+acc += Math.sin(41755) + Math.cos(41756) * 45;
+acc += Math.sin(41756) + Math.cos(41757) * 46;
+acc += Math.sin(41757) + Math.cos(41758) * 47;
+acc += Math.sin(41758) + Math.cos(41759) * 48;
+acc += Math.sin(41759) + Math.cos(41760) * 49;
+acc += Math.sin(41760) + Math.cos(41761) * 50;
+acc += Math.sin(41761) + Math.cos(41762) * 51;
+acc += Math.sin(41762) + Math.cos(41763) * 52;
+acc += Math.sin(41763) + Math.cos(41764) * 53;
+acc += Math.sin(41764) + Math.cos(41765) * 54;
+acc += Math.sin(41765) + Math.cos(41766) * 55;
+acc += Math.sin(41766) + Math.cos(41767) * 56;
+acc += Math.sin(41767) + Math.cos(41768) * 57;
+acc += Math.sin(41768) + Math.cos(41769) * 58;
+acc += Math.sin(41769) + Math.cos(41770) * 59;
+acc += Math.sin(41770) + Math.cos(41771) * 60;
+acc += Math.sin(41771) + Math.cos(41772) * 61;
+acc += Math.sin(41772) + Math.cos(41773) * 62;
+acc += Math.sin(41773) + Math.cos(41774) * 63;
+acc += Math.sin(41774) + Math.cos(41775) * 64;
+acc += Math.sin(41775) + Math.cos(41776) * 65;
+acc += Math.sin(41776) + Math.cos(41777) * 66;
+acc += Math.sin(41777) + Math.cos(41778) * 67;
+acc += Math.sin(41778) + Math.cos(41779) * 68;
+acc += Math.sin(41779) + Math.cos(41780) * 69;
+acc += Math.sin(41780) + Math.cos(41781) * 70;
+acc += Math.sin(41781) + Math.cos(41782) * 71;
+acc += Math.sin(41782) + Math.cos(41783) * 72;
+acc += Math.sin(41783) + Math.cos(41784) * 73;
+acc += Math.sin(41784) + Math.cos(41785) * 74;
+acc += Math.sin(41785) + Math.cos(41786) * 75;
+acc += Math.sin(41786) + Math.cos(41787) * 76;
+acc += Math.sin(41787) + Math.cos(41788) * 77;
+acc += Math.sin(41788) + Math.cos(41789) * 78;
+acc += Math.sin(41789) + Math.cos(41790) * 79;
+acc += Math.sin(41790) + Math.cos(41791) * 80;
+acc += Math.sin(41791) + Math.cos(41792) * 81;
+acc += Math.sin(41792) + Math.cos(41793) * 82;
+acc += Math.sin(41793) + Math.cos(41794) * 83;
+acc += Math.sin(41794) + Math.cos(41795) * 84;
+acc += Math.sin(41795) + Math.cos(41796) * 85;
+acc += Math.sin(41796) + Math.cos(41797) * 86;
+acc += Math.sin(41797) + Math.cos(41798) * 87;
+acc += Math.sin(41798) + Math.cos(41799) * 88;
+acc += Math.sin(41799) + Math.cos(41800) * 89;
+acc += Math.sin(41800) + Math.cos(41801) * 90;
+acc += Math.sin(41801) + Math.cos(41802) * 91;
+acc += Math.sin(41802) + Math.cos(41803) * 92;
+acc += Math.sin(41803) + Math.cos(41804) * 93;
+acc += Math.sin(41804) + Math.cos(41805) * 94;
+acc += Math.sin(41805) + Math.cos(41806) * 95;
+acc += Math.sin(41806) + Math.cos(41807) * 96;
+acc += Math.sin(41807) + Math.cos(41808) * 0;
+acc += Math.sin(41808) + Math.cos(41809) * 1;
+acc += Math.sin(41809) + Math.cos(41810) * 2;
+acc += Math.sin(41810) + Math.cos(41811) * 3;
+acc += Math.sin(41811) + Math.cos(41812) * 4;
+acc += Math.sin(41812) + Math.cos(41813) * 5;
+acc += Math.sin(41813) + Math.cos(41814) * 6;
+acc += Math.sin(41814) + Math.cos(41815) * 7;
+acc += Math.sin(41815) + Math.cos(41816) * 8;
+acc += Math.sin(41816) + Math.cos(41817) * 9;
+acc += Math.sin(41817) + Math.cos(41818) * 10;
+acc += Math.sin(41818) + Math.cos(41819) * 11;
+acc += Math.sin(41819) + Math.cos(41820) * 12;
+acc += Math.sin(41820) + Math.cos(41821) * 13;
+acc += Math.sin(41821) + Math.cos(41822) * 14;
+acc += Math.sin(41822) + Math.cos(41823) * 15;
+acc += Math.sin(41823) + Math.cos(41824) * 16;
+acc += Math.sin(41824) + Math.cos(41825) * 17;
+acc += Math.sin(41825) + Math.cos(41826) * 18;
+acc += Math.sin(41826) + Math.cos(41827) * 19;
+acc += Math.sin(41827) + Math.cos(41828) * 20;
+acc += Math.sin(41828) + Math.cos(41829) * 21;
+acc += Math.sin(41829) + Math.cos(41830) * 22;
+acc += Math.sin(41830) + Math.cos(41831) * 23;
+acc += Math.sin(41831) + Math.cos(41832) * 24;
+acc += Math.sin(41832) + Math.cos(41833) * 25;
+acc += Math.sin(41833) + Math.cos(41834) * 26;
+acc += Math.sin(41834) + Math.cos(41835) * 27;
+acc += Math.sin(41835) + Math.cos(41836) * 28;
+acc += Math.sin(41836) + Math.cos(41837) * 29;
+acc += Math.sin(41837) + Math.cos(41838) * 30;
+acc += Math.sin(41838) + Math.cos(41839) * 31;
+acc += Math.sin(41839) + Math.cos(41840) * 32;
+acc += Math.sin(41840) + Math.cos(41841) * 33;
+acc += Math.sin(41841) + Math.cos(41842) * 34;
+acc += Math.sin(41842) + Math.cos(41843) * 35;
+acc += Math.sin(41843) + Math.cos(41844) * 36;
+acc += Math.sin(41844) + Math.cos(41845) * 37;
+acc += Math.sin(41845) + Math.cos(41846) * 38;
+acc += Math.sin(41846) + Math.cos(41847) * 39;
+acc += Math.sin(41847) + Math.cos(41848) * 40;
+acc += Math.sin(41848) + Math.cos(41849) * 41;
+acc += Math.sin(41849) + Math.cos(41850) * 42;
+acc += Math.sin(41850) + Math.cos(41851) * 43;
+acc += Math.sin(41851) + Math.cos(41852) * 44;
+acc += Math.sin(41852) + Math.cos(41853) * 45;
+acc += Math.sin(41853) + Math.cos(41854) * 46;
+acc += Math.sin(41854) + Math.cos(41855) * 47;
+acc += Math.sin(41855) + Math.cos(41856) * 48;
+acc += Math.sin(41856) + Math.cos(41857) * 49;
+acc += Math.sin(41857) + Math.cos(41858) * 50;
+acc += Math.sin(41858) + Math.cos(41859) * 51;
+acc += Math.sin(41859) + Math.cos(41860) * 52;
+acc += Math.sin(41860) + Math.cos(41861) * 53;
+acc += Math.sin(41861) + Math.cos(41862) * 54;
+acc += Math.sin(41862) + Math.cos(41863) * 55;
+acc += Math.sin(41863) + Math.cos(41864) * 56;
+acc += Math.sin(41864) + Math.cos(41865) * 57;
+acc += Math.sin(41865) + Math.cos(41866) * 58;
+acc += Math.sin(41866) + Math.cos(41867) * 59;
+acc += Math.sin(41867) + Math.cos(41868) * 60;
+acc += Math.sin(41868) + Math.cos(41869) * 61;
+acc += Math.sin(41869) + Math.cos(41870) * 62;
+acc += Math.sin(41870) + Math.cos(41871) * 63;
+acc += Math.sin(41871) + Math.cos(41872) * 64;
+acc += Math.sin(41872) + Math.cos(41873) * 65;
+acc += Math.sin(41873) + Math.cos(41874) * 66;
+acc += Math.sin(41874) + Math.cos(41875) * 67;
+acc += Math.sin(41875) + Math.cos(41876) * 68;
+acc += Math.sin(41876) + Math.cos(41877) * 69;
+acc += Math.sin(41877) + Math.cos(41878) * 70;
+acc += Math.sin(41878) + Math.cos(41879) * 71;
+acc += Math.sin(41879) + Math.cos(41880) * 72;
+acc += Math.sin(41880) + Math.cos(41881) * 73;
+acc += Math.sin(41881) + Math.cos(41882) * 74;
+acc += Math.sin(41882) + Math.cos(41883) * 75;
+acc += Math.sin(41883) + Math.cos(41884) * 76;
+acc += Math.sin(41884) + Math.cos(41885) * 77;
+acc += Math.sin(41885) + Math.cos(41886) * 78;
+acc += Math.sin(41886) + Math.cos(41887) * 79;
+acc += Math.sin(41887) + Math.cos(41888) * 80;
+acc += Math.sin(41888) + Math.cos(41889) * 81;
+acc += Math.sin(41889) + Math.cos(41890) * 82;
+acc += Math.sin(41890) + Math.cos(41891) * 83;
+acc += Math.sin(41891) + Math.cos(41892) * 84;
+acc += Math.sin(41892) + Math.cos(41893) * 85;
+acc += Math.sin(41893) + Math.cos(41894) * 86;
+acc += Math.sin(41894) + Math.cos(41895) * 87;
+acc += Math.sin(41895) + Math.cos(41896) * 88;
+acc += Math.sin(41896) + Math.cos(41897) * 89;
+acc += Math.sin(41897) + Math.cos(41898) * 90;
+acc += Math.sin(41898) + Math.cos(41899) * 91;
+acc += Math.sin(41899) + Math.cos(41900) * 92;
+acc += Math.sin(41900) + Math.cos(41901) * 93;
+acc += Math.sin(41901) + Math.cos(41902) * 94;
+acc += Math.sin(41902) + Math.cos(41903) * 95;
+acc += Math.sin(41903) + Math.cos(41904) * 96;
+acc += Math.sin(41904) + Math.cos(41905) * 0;
+acc += Math.sin(41905) + Math.cos(41906) * 1;
+acc += Math.sin(41906) + Math.cos(41907) * 2;
+acc += Math.sin(41907) + Math.cos(41908) * 3;
+acc += Math.sin(41908) + Math.cos(41909) * 4;
+acc += Math.sin(41909) + Math.cos(41910) * 5;
+acc += Math.sin(41910) + Math.cos(41911) * 6;
+acc += Math.sin(41911) + Math.cos(41912) * 7;
+acc += Math.sin(41912) + Math.cos(41913) * 8;
+acc += Math.sin(41913) + Math.cos(41914) * 9;
+acc += Math.sin(41914) + Math.cos(41915) * 10;
+acc += Math.sin(41915) + Math.cos(41916) * 11;
+acc += Math.sin(41916) + Math.cos(41917) * 12;
+acc += Math.sin(41917) + Math.cos(41918) * 13;
+acc += Math.sin(41918) + Math.cos(41919) * 14;
+acc += Math.sin(41919) + Math.cos(41920) * 15;
+acc += Math.sin(41920) + Math.cos(41921) * 16;
+acc += Math.sin(41921) + Math.cos(41922) * 17;
+acc += Math.sin(41922) + Math.cos(41923) * 18;
+acc += Math.sin(41923) + Math.cos(41924) * 19;
+acc += Math.sin(41924) + Math.cos(41925) * 20;
+acc += Math.sin(41925) + Math.cos(41926) * 21;
+acc += Math.sin(41926) + Math.cos(41927) * 22;
+acc += Math.sin(41927) + Math.cos(41928) * 23;
+acc += Math.sin(41928) + Math.cos(41929) * 24;
+acc += Math.sin(41929) + Math.cos(41930) * 25;
+acc += Math.sin(41930) + Math.cos(41931) * 26;
+acc += Math.sin(41931) + Math.cos(41932) * 27;
+acc += Math.sin(41932) + Math.cos(41933) * 28;
+acc += Math.sin(41933) + Math.cos(41934) * 29;
+acc += Math.sin(41934) + Math.cos(41935) * 30;
+acc += Math.sin(41935) + Math.cos(41936) * 31;
+acc += Math.sin(41936) + Math.cos(41937) * 32;
+acc += Math.sin(41937) + Math.cos(41938) * 33;
+acc += Math.sin(41938) + Math.cos(41939) * 34;
+acc += Math.sin(41939) + Math.cos(41940) * 35;
+acc += Math.sin(41940) + Math.cos(41941) * 36;
+acc += Math.sin(41941) + Math.cos(41942) * 37;
+acc += Math.sin(41942) + Math.cos(41943) * 38;
+acc += Math.sin(41943) + Math.cos(41944) * 39;
+acc += Math.sin(41944) + Math.cos(41945) * 40;
+acc += Math.sin(41945) + Math.cos(41946) * 41;
+acc += Math.sin(41946) + Math.cos(41947) * 42;
+acc += Math.sin(41947) + Math.cos(41948) * 43;
+acc += Math.sin(41948) + Math.cos(41949) * 44;
+acc += Math.sin(41949) + Math.cos(41950) * 45;
+acc += Math.sin(41950) + Math.cos(41951) * 46;
+acc += Math.sin(41951) + Math.cos(41952) * 47;
+acc += Math.sin(41952) + Math.cos(41953) * 48;
+acc += Math.sin(41953) + Math.cos(41954) * 49;
+acc += Math.sin(41954) + Math.cos(41955) * 50;
+acc += Math.sin(41955) + Math.cos(41956) * 51;
+acc += Math.sin(41956) + Math.cos(41957) * 52;
+acc += Math.sin(41957) + Math.cos(41958) * 53;
+acc += Math.sin(41958) + Math.cos(41959) * 54;
+acc += Math.sin(41959) + Math.cos(41960) * 55;
+acc += Math.sin(41960) + Math.cos(41961) * 56;
+acc += Math.sin(41961) + Math.cos(41962) * 57;
+acc += Math.sin(41962) + Math.cos(41963) * 58;
+acc += Math.sin(41963) + Math.cos(41964) * 59;
+acc += Math.sin(41964) + Math.cos(41965) * 60;
+acc += Math.sin(41965) + Math.cos(41966) * 61;
+acc += Math.sin(41966) + Math.cos(41967) * 62;
+acc += Math.sin(41967) + Math.cos(41968) * 63;
+acc += Math.sin(41968) + Math.cos(41969) * 64;
+acc += Math.sin(41969) + Math.cos(41970) * 65;
+acc += Math.sin(41970) + Math.cos(41971) * 66;
+acc += Math.sin(41971) + Math.cos(41972) * 67;
+acc += Math.sin(41972) + Math.cos(41973) * 68;
+acc += Math.sin(41973) + Math.cos(41974) * 69;
+acc += Math.sin(41974) + Math.cos(41975) * 70;
+acc += Math.sin(41975) + Math.cos(41976) * 71;
+acc += Math.sin(41976) + Math.cos(41977) * 72;
+acc += Math.sin(41977) + Math.cos(41978) * 73;
+acc += Math.sin(41978) + Math.cos(41979) * 74;
+acc += Math.sin(41979) + Math.cos(41980) * 75;
+acc += Math.sin(41980) + Math.cos(41981) * 76;
+acc += Math.sin(41981) + Math.cos(41982) * 77;
+acc += Math.sin(41982) + Math.cos(41983) * 78;
+acc += Math.sin(41983) + Math.cos(41984) * 79;
+acc += Math.sin(41984) + Math.cos(41985) * 80;
+acc += Math.sin(41985) + Math.cos(41986) * 81;
+acc += Math.sin(41986) + Math.cos(41987) * 82;
+acc += Math.sin(41987) + Math.cos(41988) * 83;
+acc += Math.sin(41988) + Math.cos(41989) * 84;
+acc += Math.sin(41989) + Math.cos(41990) * 85;
+acc += Math.sin(41990) + Math.cos(41991) * 86;
+acc += Math.sin(41991) + Math.cos(41992) * 87;
+acc += Math.sin(41992) + Math.cos(41993) * 88;
+acc += Math.sin(41993) + Math.cos(41994) * 89;
+acc += Math.sin(41994) + Math.cos(41995) * 90;
+acc += Math.sin(41995) + Math.cos(41996) * 91;
+acc += Math.sin(41996) + Math.cos(41997) * 92;
+acc += Math.sin(41997) + Math.cos(41998) * 93;
+acc += Math.sin(41998) + Math.cos(41999) * 94;
+acc += Math.sin(41999) + Math.cos(42000) * 95;
+acc += Math.sin(42000) + Math.cos(42001) * 96;
+acc += Math.sin(42001) + Math.cos(42002) * 0;
+acc += Math.sin(42002) + Math.cos(42003) * 1;
+acc += Math.sin(42003) + Math.cos(42004) * 2;
+acc += Math.sin(42004) + Math.cos(42005) * 3;
+acc += Math.sin(42005) + Math.cos(42006) * 4;
+acc += Math.sin(42006) + Math.cos(42007) * 5;
+acc += Math.sin(42007) + Math.cos(42008) * 6;
+acc += Math.sin(42008) + Math.cos(42009) * 7;
+acc += Math.sin(42009) + Math.cos(42010) * 8;
+acc += Math.sin(42010) + Math.cos(42011) * 9;
+acc += Math.sin(42011) + Math.cos(42012) * 10;
+acc += Math.sin(42012) + Math.cos(42013) * 11;
+acc += Math.sin(42013) + Math.cos(42014) * 12;
+acc += Math.sin(42014) + Math.cos(42015) * 13;
+acc += Math.sin(42015) + Math.cos(42016) * 14;
+acc += Math.sin(42016) + Math.cos(42017) * 15;
+acc += Math.sin(42017) + Math.cos(42018) * 16;
+acc += Math.sin(42018) + Math.cos(42019) * 17;
+acc += Math.sin(42019) + Math.cos(42020) * 18;
+acc += Math.sin(42020) + Math.cos(42021) * 19;
+acc += Math.sin(42021) + Math.cos(42022) * 20;
+acc += Math.sin(42022) + Math.cos(42023) * 21;
+acc += Math.sin(42023) + Math.cos(42024) * 22;
+acc += Math.sin(42024) + Math.cos(42025) * 23;
+acc += Math.sin(42025) + Math.cos(42026) * 24;
+acc += Math.sin(42026) + Math.cos(42027) * 25;
+acc += Math.sin(42027) + Math.cos(42028) * 26;
+acc += Math.sin(42028) + Math.cos(42029) * 27;
+acc += Math.sin(42029) + Math.cos(42030) * 28;
+acc += Math.sin(42030) + Math.cos(42031) * 29;
+acc += Math.sin(42031) + Math.cos(42032) * 30;
+acc += Math.sin(42032) + Math.cos(42033) * 31;
+acc += Math.sin(42033) + Math.cos(42034) * 32;
+acc += Math.sin(42034) + Math.cos(42035) * 33;
+acc += Math.sin(42035) + Math.cos(42036) * 34;
+acc += Math.sin(42036) + Math.cos(42037) * 35;
+acc += Math.sin(42037) + Math.cos(42038) * 36;
+acc += Math.sin(42038) + Math.cos(42039) * 37;
+acc += Math.sin(42039) + Math.cos(42040) * 38;
+acc += Math.sin(42040) + Math.cos(42041) * 39;
+acc += Math.sin(42041) + Math.cos(42042) * 40;
+acc += Math.sin(42042) + Math.cos(42043) * 41;
+acc += Math.sin(42043) + Math.cos(42044) * 42;
+acc += Math.sin(42044) + Math.cos(42045) * 43;
+acc += Math.sin(42045) + Math.cos(42046) * 44;
+acc += Math.sin(42046) + Math.cos(42047) * 45;
+acc += Math.sin(42047) + Math.cos(42048) * 46;
+acc += Math.sin(42048) + Math.cos(42049) * 47;
+acc += Math.sin(42049) + Math.cos(42050) * 48;
+acc += Math.sin(42050) + Math.cos(42051) * 49;
+acc += Math.sin(42051) + Math.cos(42052) * 50;
+acc += Math.sin(42052) + Math.cos(42053) * 51;
+acc += Math.sin(42053) + Math.cos(42054) * 52;
+acc += Math.sin(42054) + Math.cos(42055) * 53;
+acc += Math.sin(42055) + Math.cos(42056) * 54;
+acc += Math.sin(42056) + Math.cos(42057) * 55;
+acc += Math.sin(42057) + Math.cos(42058) * 56;
+acc += Math.sin(42058) + Math.cos(42059) * 57;
+acc += Math.sin(42059) + Math.cos(42060) * 58;
+acc += Math.sin(42060) + Math.cos(42061) * 59;
+acc += Math.sin(42061) + Math.cos(42062) * 60;
+acc += Math.sin(42062) + Math.cos(42063) * 61;
+acc += Math.sin(42063) + Math.cos(42064) * 62;
+acc += Math.sin(42064) + Math.cos(42065) * 63;
+acc += Math.sin(42065) + Math.cos(42066) * 64;
+acc += Math.sin(42066) + Math.cos(42067) * 65;
+acc += Math.sin(42067) + Math.cos(42068) * 66;
+acc += Math.sin(42068) + Math.cos(42069) * 67;
+acc += Math.sin(42069) + Math.cos(42070) * 68;
+acc += Math.sin(42070) + Math.cos(42071) * 69;
+acc += Math.sin(42071) + Math.cos(42072) * 70;
+acc += Math.sin(42072) + Math.cos(42073) * 71;
+acc += Math.sin(42073) + Math.cos(42074) * 72;
+acc += Math.sin(42074) + Math.cos(42075) * 73;
+acc += Math.sin(42075) + Math.cos(42076) * 74;
+acc += Math.sin(42076) + Math.cos(42077) * 75;
+acc += Math.sin(42077) + Math.cos(42078) * 76;
+acc += Math.sin(42078) + Math.cos(42079) * 77;
+acc += Math.sin(42079) + Math.cos(42080) * 78;
+acc += Math.sin(42080) + Math.cos(42081) * 79;
+acc += Math.sin(42081) + Math.cos(42082) * 80;
+acc += Math.sin(42082) + Math.cos(42083) * 81;
+acc += Math.sin(42083) + Math.cos(42084) * 82;
+acc += Math.sin(42084) + Math.cos(42085) * 83;
+acc += Math.sin(42085) + Math.cos(42086) * 84;
+acc += Math.sin(42086) + Math.cos(42087) * 85;
+acc += Math.sin(42087) + Math.cos(42088) * 86;
+acc += Math.sin(42088) + Math.cos(42089) * 87;
+acc += Math.sin(42089) + Math.cos(42090) * 88;
+acc += Math.sin(42090) + Math.cos(42091) * 89;
+acc += Math.sin(42091) + Math.cos(42092) * 90;
+acc += Math.sin(42092) + Math.cos(42093) * 91;
+acc += Math.sin(42093) + Math.cos(42094) * 92;
+acc += Math.sin(42094) + Math.cos(42095) * 93;
+acc += Math.sin(42095) + Math.cos(42096) * 94;
+acc += Math.sin(42096) + Math.cos(42097) * 95;
+acc += Math.sin(42097) + Math.cos(42098) * 96;
+acc += Math.sin(42098) + Math.cos(42099) * 0;
+acc += Math.sin(42099) + Math.cos(42100) * 1;
+acc += Math.sin(42100) + Math.cos(42101) * 2;
+acc += Math.sin(42101) + Math.cos(42102) * 3;
+acc += Math.sin(42102) + Math.cos(42103) * 4;
+acc += Math.sin(42103) + Math.cos(42104) * 5;
+acc += Math.sin(42104) + Math.cos(42105) * 6;
+acc += Math.sin(42105) + Math.cos(42106) * 7;
+acc += Math.sin(42106) + Math.cos(42107) * 8;
+acc += Math.sin(42107) + Math.cos(42108) * 9;
+acc += Math.sin(42108) + Math.cos(42109) * 10;
+acc += Math.sin(42109) + Math.cos(42110) * 11;
+acc += Math.sin(42110) + Math.cos(42111) * 12;
+acc += Math.sin(42111) + Math.cos(42112) * 13;
+acc += Math.sin(42112) + Math.cos(42113) * 14;
+acc += Math.sin(42113) + Math.cos(42114) * 15;
+acc += Math.sin(42114) + Math.cos(42115) * 16;
+acc += Math.sin(42115) + Math.cos(42116) * 17;
+acc += Math.sin(42116) + Math.cos(42117) * 18;
+acc += Math.sin(42117) + Math.cos(42118) * 19;
+acc += Math.sin(42118) + Math.cos(42119) * 20;
+acc += Math.sin(42119) + Math.cos(42120) * 21;
+acc += Math.sin(42120) + Math.cos(42121) * 22;
+acc += Math.sin(42121) + Math.cos(42122) * 23;
+acc += Math.sin(42122) + Math.cos(42123) * 24;
+acc += Math.sin(42123) + Math.cos(42124) * 25;
+acc += Math.sin(42124) + Math.cos(42125) * 26;
+acc += Math.sin(42125) + Math.cos(42126) * 27;
+acc += Math.sin(42126) + Math.cos(42127) * 28;
+acc += Math.sin(42127) + Math.cos(42128) * 29;
+acc += Math.sin(42128) + Math.cos(42129) * 30;
+acc += Math.sin(42129) + Math.cos(42130) * 31;
+acc += Math.sin(42130) + Math.cos(42131) * 32;
+acc += Math.sin(42131) + Math.cos(42132) * 33;
+acc += Math.sin(42132) + Math.cos(42133) * 34;
+acc += Math.sin(42133) + Math.cos(42134) * 35;
+acc += Math.sin(42134) + Math.cos(42135) * 36;
+acc += Math.sin(42135) + Math.cos(42136) * 37;
+acc += Math.sin(42136) + Math.cos(42137) * 38;
+acc += Math.sin(42137) + Math.cos(42138) * 39;
+acc += Math.sin(42138) + Math.cos(42139) * 40;
+acc += Math.sin(42139) + Math.cos(42140) * 41;
+acc += Math.sin(42140) + Math.cos(42141) * 42;
+acc += Math.sin(42141) + Math.cos(42142) * 43;
+acc += Math.sin(42142) + Math.cos(42143) * 44;
+acc += Math.sin(42143) + Math.cos(42144) * 45;
+acc += Math.sin(42144) + Math.cos(42145) * 46;
+acc += Math.sin(42145) + Math.cos(42146) * 47;
+acc += Math.sin(42146) + Math.cos(42147) * 48;
+acc += Math.sin(42147) + Math.cos(42148) * 49;
+acc += Math.sin(42148) + Math.cos(42149) * 50;
+acc += Math.sin(42149) + Math.cos(42150) * 51;
+acc += Math.sin(42150) + Math.cos(42151) * 52;
+acc += Math.sin(42151) + Math.cos(42152) * 53;
+acc += Math.sin(42152) + Math.cos(42153) * 54;
+acc += Math.sin(42153) + Math.cos(42154) * 55;
+acc += Math.sin(42154) + Math.cos(42155) * 56;
+acc += Math.sin(42155) + Math.cos(42156) * 57;
+acc += Math.sin(42156) + Math.cos(42157) * 58;
+acc += Math.sin(42157) + Math.cos(42158) * 59;
+acc += Math.sin(42158) + Math.cos(42159) * 60;
+acc += Math.sin(42159) + Math.cos(42160) * 61;
+acc += Math.sin(42160) + Math.cos(42161) * 62;
+acc += Math.sin(42161) + Math.cos(42162) * 63;
+acc += Math.sin(42162) + Math.cos(42163) * 64;
+acc += Math.sin(42163) + Math.cos(42164) * 65;
+acc += Math.sin(42164) + Math.cos(42165) * 66;
+acc += Math.sin(42165) + Math.cos(42166) * 67;
+acc += Math.sin(42166) + Math.cos(42167) * 68;
+acc += Math.sin(42167) + Math.cos(42168) * 69;
+acc += Math.sin(42168) + Math.cos(42169) * 70;
+acc += Math.sin(42169) + Math.cos(42170) * 71;
+acc += Math.sin(42170) + Math.cos(42171) * 72;
+acc += Math.sin(42171) + Math.cos(42172) * 73;
+acc += Math.sin(42172) + Math.cos(42173) * 74;
+acc += Math.sin(42173) + Math.cos(42174) * 75;
+acc += Math.sin(42174) + Math.cos(42175) * 76;
+acc += Math.sin(42175) + Math.cos(42176) * 77;
+acc += Math.sin(42176) + Math.cos(42177) * 78;
+acc += Math.sin(42177) + Math.cos(42178) * 79;
+acc += Math.sin(42178) + Math.cos(42179) * 80;
+acc += Math.sin(42179) + Math.cos(42180) * 81;
+acc += Math.sin(42180) + Math.cos(42181) * 82;
+acc += Math.sin(42181) + Math.cos(42182) * 83;
+acc += Math.sin(42182) + Math.cos(42183) * 84;
+acc += Math.sin(42183) + Math.cos(42184) * 85;
+acc += Math.sin(42184) + Math.cos(42185) * 86;
+acc += Math.sin(42185) + Math.cos(42186) * 87;
+acc += Math.sin(42186) + Math.cos(42187) * 88;
+acc += Math.sin(42187) + Math.cos(42188) * 89;
+acc += Math.sin(42188) + Math.cos(42189) * 90;
+acc += Math.sin(42189) + Math.cos(42190) * 91;
+acc += Math.sin(42190) + Math.cos(42191) * 92;
+acc += Math.sin(42191) + Math.cos(42192) * 93;
+acc += Math.sin(42192) + Math.cos(42193) * 94;
+acc += Math.sin(42193) + Math.cos(42194) * 95;
+acc += Math.sin(42194) + Math.cos(42195) * 96;
+acc += Math.sin(42195) + Math.cos(42196) * 0;
+acc += Math.sin(42196) + Math.cos(42197) * 1;
+acc += Math.sin(42197) + Math.cos(42198) * 2;
+acc += Math.sin(42198) + Math.cos(42199) * 3;
+acc += Math.sin(42199) + Math.cos(42200) * 4;
+acc += Math.sin(42200) + Math.cos(42201) * 5;
+acc += Math.sin(42201) + Math.cos(42202) * 6;
+acc += Math.sin(42202) + Math.cos(42203) * 7;
+acc += Math.sin(42203) + Math.cos(42204) * 8;
+acc += Math.sin(42204) + Math.cos(42205) * 9;
+acc += Math.sin(42205) + Math.cos(42206) * 10;
+acc += Math.sin(42206) + Math.cos(42207) * 11;
+acc += Math.sin(42207) + Math.cos(42208) * 12;
+acc += Math.sin(42208) + Math.cos(42209) * 13;
+acc += Math.sin(42209) + Math.cos(42210) * 14;
+acc += Math.sin(42210) + Math.cos(42211) * 15;
+acc += Math.sin(42211) + Math.cos(42212) * 16;
+acc += Math.sin(42212) + Math.cos(42213) * 17;
+acc += Math.sin(42213) + Math.cos(42214) * 18;
+acc += Math.sin(42214) + Math.cos(42215) * 19;
+acc += Math.sin(42215) + Math.cos(42216) * 20;
+acc += Math.sin(42216) + Math.cos(42217) * 21;
+acc += Math.sin(42217) + Math.cos(42218) * 22;
+acc += Math.sin(42218) + Math.cos(42219) * 23;
+acc += Math.sin(42219) + Math.cos(42220) * 24;
+acc += Math.sin(42220) + Math.cos(42221) * 25;
+acc += Math.sin(42221) + Math.cos(42222) * 26;
+acc += Math.sin(42222) + Math.cos(42223) * 27;
+acc += Math.sin(42223) + Math.cos(42224) * 28;
+acc += Math.sin(42224) + Math.cos(42225) * 29;
+acc += Math.sin(42225) + Math.cos(42226) * 30;
+acc += Math.sin(42226) + Math.cos(42227) * 31;
+acc += Math.sin(42227) + Math.cos(42228) * 32;
+acc += Math.sin(42228) + Math.cos(42229) * 33;
+acc += Math.sin(42229) + Math.cos(42230) * 34;
+acc += Math.sin(42230) + Math.cos(42231) * 35;
+acc += Math.sin(42231) + Math.cos(42232) * 36;
+acc += Math.sin(42232) + Math.cos(42233) * 37;
+acc += Math.sin(42233) + Math.cos(42234) * 38;
+acc += Math.sin(42234) + Math.cos(42235) * 39;
+acc += Math.sin(42235) + Math.cos(42236) * 40;
+acc += Math.sin(42236) + Math.cos(42237) * 41;
+acc += Math.sin(42237) + Math.cos(42238) * 42;
+acc += Math.sin(42238) + Math.cos(42239) * 43;
+acc += Math.sin(42239) + Math.cos(42240) * 44;
+acc += Math.sin(42240) + Math.cos(42241) * 45;
+acc += Math.sin(42241) + Math.cos(42242) * 46;
+acc += Math.sin(42242) + Math.cos(42243) * 47;
+acc += Math.sin(42243) + Math.cos(42244) * 48;
+acc += Math.sin(42244) + Math.cos(42245) * 49;
+acc += Math.sin(42245) + Math.cos(42246) * 50;
+acc += Math.sin(42246) + Math.cos(42247) * 51;
+acc += Math.sin(42247) + Math.cos(42248) * 52;
+acc += Math.sin(42248) + Math.cos(42249) * 53;
+acc += Math.sin(42249) + Math.cos(42250) * 54;
+acc += Math.sin(42250) + Math.cos(42251) * 55;
+acc += Math.sin(42251) + Math.cos(42252) * 56;
+acc += Math.sin(42252) + Math.cos(42253) * 57;
+acc += Math.sin(42253) + Math.cos(42254) * 58;
+acc += Math.sin(42254) + Math.cos(42255) * 59;
+acc += Math.sin(42255) + Math.cos(42256) * 60;
+acc += Math.sin(42256) + Math.cos(42257) * 61;
+acc += Math.sin(42257) + Math.cos(42258) * 62;
+acc += Math.sin(42258) + Math.cos(42259) * 63;
+acc += Math.sin(42259) + Math.cos(42260) * 64;
+acc += Math.sin(42260) + Math.cos(42261) * 65;
+acc += Math.sin(42261) + Math.cos(42262) * 66;
+acc += Math.sin(42262) + Math.cos(42263) * 67;
+acc += Math.sin(42263) + Math.cos(42264) * 68;
+acc += Math.sin(42264) + Math.cos(42265) * 69;
+acc += Math.sin(42265) + Math.cos(42266) * 70;
+acc += Math.sin(42266) + Math.cos(42267) * 71;
+acc += Math.sin(42267) + Math.cos(42268) * 72;
+acc += Math.sin(42268) + Math.cos(42269) * 73;
+acc += Math.sin(42269) + Math.cos(42270) * 74;
+acc += Math.sin(42270) + Math.cos(42271) * 75;
+acc += Math.sin(42271) + Math.cos(42272) * 76;
+acc += Math.sin(42272) + Math.cos(42273) * 77;
+acc += Math.sin(42273) + Math.cos(42274) * 78;
+acc += Math.sin(42274) + Math.cos(42275) * 79;
+acc += Math.sin(42275) + Math.cos(42276) * 80;
+acc += Math.sin(42276) + Math.cos(42277) * 81;
+acc += Math.sin(42277) + Math.cos(42278) * 82;
+acc += Math.sin(42278) + Math.cos(42279) * 83;
+acc += Math.sin(42279) + Math.cos(42280) * 84;
+acc += Math.sin(42280) + Math.cos(42281) * 85;
+acc += Math.sin(42281) + Math.cos(42282) * 86;
+acc += Math.sin(42282) + Math.cos(42283) * 87;
+acc += Math.sin(42283) + Math.cos(42284) * 88;
+acc += Math.sin(42284) + Math.cos(42285) * 89;
+acc += Math.sin(42285) + Math.cos(42286) * 90;
+acc += Math.sin(42286) + Math.cos(42287) * 91;
+acc += Math.sin(42287) + Math.cos(42288) * 92;
+acc += Math.sin(42288) + Math.cos(42289) * 93;
+acc += Math.sin(42289) + Math.cos(42290) * 94;
+acc += Math.sin(42290) + Math.cos(42291) * 95;
+acc += Math.sin(42291) + Math.cos(42292) * 96;
+acc += Math.sin(42292) + Math.cos(42293) * 0;
+acc += Math.sin(42293) + Math.cos(42294) * 1;
+acc += Math.sin(42294) + Math.cos(42295) * 2;
+acc += Math.sin(42295) + Math.cos(42296) * 3;
+acc += Math.sin(42296) + Math.cos(42297) * 4;
+acc += Math.sin(42297) + Math.cos(42298) * 5;
+acc += Math.sin(42298) + Math.cos(42299) * 6;
+acc += Math.sin(42299) + Math.cos(42300) * 7;
+acc += Math.sin(42300) + Math.cos(42301) * 8;
+acc += Math.sin(42301) + Math.cos(42302) * 9;
+acc += Math.sin(42302) + Math.cos(42303) * 10;
+acc += Math.sin(42303) + Math.cos(42304) * 11;
+acc += Math.sin(42304) + Math.cos(42305) * 12;
+acc += Math.sin(42305) + Math.cos(42306) * 13;
+acc += Math.sin(42306) + Math.cos(42307) * 14;
+acc += Math.sin(42307) + Math.cos(42308) * 15;
+acc += Math.sin(42308) + Math.cos(42309) * 16;
+acc += Math.sin(42309) + Math.cos(42310) * 17;
+acc += Math.sin(42310) + Math.cos(42311) * 18;
+acc += Math.sin(42311) + Math.cos(42312) * 19;
+acc += Math.sin(42312) + Math.cos(42313) * 20;
+acc += Math.sin(42313) + Math.cos(42314) * 21;
+acc += Math.sin(42314) + Math.cos(42315) * 22;
+acc += Math.sin(42315) + Math.cos(42316) * 23;
+acc += Math.sin(42316) + Math.cos(42317) * 24;
+acc += Math.sin(42317) + Math.cos(42318) * 25;
+acc += Math.sin(42318) + Math.cos(42319) * 26;
+acc += Math.sin(42319) + Math.cos(42320) * 27;
+acc += Math.sin(42320) + Math.cos(42321) * 28;
+acc += Math.sin(42321) + Math.cos(42322) * 29;
+acc += Math.sin(42322) + Math.cos(42323) * 30;
+acc += Math.sin(42323) + Math.cos(42324) * 31;
+acc += Math.sin(42324) + Math.cos(42325) * 32;
+acc += Math.sin(42325) + Math.cos(42326) * 33;
+acc += Math.sin(42326) + Math.cos(42327) * 34;
+acc += Math.sin(42327) + Math.cos(42328) * 35;
+acc += Math.sin(42328) + Math.cos(42329) * 36;
+acc += Math.sin(42329) + Math.cos(42330) * 37;
+acc += Math.sin(42330) + Math.cos(42331) * 38;
+acc += Math.sin(42331) + Math.cos(42332) * 39;
+acc += Math.sin(42332) + Math.cos(42333) * 40;
+acc += Math.sin(42333) + Math.cos(42334) * 41;
+acc += Math.sin(42334) + Math.cos(42335) * 42;
+acc += Math.sin(42335) + Math.cos(42336) * 43;
+acc += Math.sin(42336) + Math.cos(42337) * 44;
+acc += Math.sin(42337) + Math.cos(42338) * 45;
+acc += Math.sin(42338) + Math.cos(42339) * 46;
+acc += Math.sin(42339) + Math.cos(42340) * 47;
+acc += Math.sin(42340) + Math.cos(42341) * 48;
+acc += Math.sin(42341) + Math.cos(42342) * 49;
+acc += Math.sin(42342) + Math.cos(42343) * 50;
+acc += Math.sin(42343) + Math.cos(42344) * 51;
+acc += Math.sin(42344) + Math.cos(42345) * 52;
+acc += Math.sin(42345) + Math.cos(42346) * 53;
+acc += Math.sin(42346) + Math.cos(42347) * 54;
+acc += Math.sin(42347) + Math.cos(42348) * 55;
+acc += Math.sin(42348) + Math.cos(42349) * 56;
+acc += Math.sin(42349) + Math.cos(42350) * 57;
+acc += Math.sin(42350) + Math.cos(42351) * 58;
+acc += Math.sin(42351) + Math.cos(42352) * 59;
+acc += Math.sin(42352) + Math.cos(42353) * 60;
+acc += Math.sin(42353) + Math.cos(42354) * 61;
+acc += Math.sin(42354) + Math.cos(42355) * 62;
+acc += Math.sin(42355) + Math.cos(42356) * 63;
+acc += Math.sin(42356) + Math.cos(42357) * 64;
+acc += Math.sin(42357) + Math.cos(42358) * 65;
+acc += Math.sin(42358) + Math.cos(42359) * 66;
+acc += Math.sin(42359) + Math.cos(42360) * 67;
+acc += Math.sin(42360) + Math.cos(42361) * 68;
+acc += Math.sin(42361) + Math.cos(42362) * 69;
+acc += Math.sin(42362) + Math.cos(42363) * 70;
+acc += Math.sin(42363) + Math.cos(42364) * 71;
+acc += Math.sin(42364) + Math.cos(42365) * 72;
+acc += Math.sin(42365) + Math.cos(42366) * 73;
+acc += Math.sin(42366) + Math.cos(42367) * 74;
+acc += Math.sin(42367) + Math.cos(42368) * 75;
+acc += Math.sin(42368) + Math.cos(42369) * 76;
+acc += Math.sin(42369) + Math.cos(42370) * 77;
+acc += Math.sin(42370) + Math.cos(42371) * 78;
+acc += Math.sin(42371) + Math.cos(42372) * 79;
+acc += Math.sin(42372) + Math.cos(42373) * 80;
+acc += Math.sin(42373) + Math.cos(42374) * 81;
+acc += Math.sin(42374) + Math.cos(42375) * 82;
+acc += Math.sin(42375) + Math.cos(42376) * 83;
+acc += Math.sin(42376) + Math.cos(42377) * 84;
+acc += Math.sin(42377) + Math.cos(42378) * 85;
+acc += Math.sin(42378) + Math.cos(42379) * 86;
+acc += Math.sin(42379) + Math.cos(42380) * 87;
+acc += Math.sin(42380) + Math.cos(42381) * 88;
+acc += Math.sin(42381) + Math.cos(42382) * 89;
+acc += Math.sin(42382) + Math.cos(42383) * 90;
+acc += Math.sin(42383) + Math.cos(42384) * 91;
+acc += Math.sin(42384) + Math.cos(42385) * 92;
+acc += Math.sin(42385) + Math.cos(42386) * 93;
+acc += Math.sin(42386) + Math.cos(42387) * 94;
+acc += Math.sin(42387) + Math.cos(42388) * 95;
+acc += Math.sin(42388) + Math.cos(42389) * 96;
+acc += Math.sin(42389) + Math.cos(42390) * 0;
+acc += Math.sin(42390) + Math.cos(42391) * 1;
+acc += Math.sin(42391) + Math.cos(42392) * 2;
+acc += Math.sin(42392) + Math.cos(42393) * 3;
+acc += Math.sin(42393) + Math.cos(42394) * 4;
+acc += Math.sin(42394) + Math.cos(42395) * 5;
+acc += Math.sin(42395) + Math.cos(42396) * 6;
+acc += Math.sin(42396) + Math.cos(42397) * 7;
+acc += Math.sin(42397) + Math.cos(42398) * 8;
+acc += Math.sin(42398) + Math.cos(42399) * 9;
+acc += Math.sin(42399) + Math.cos(42400) * 10;
+acc += Math.sin(42400) + Math.cos(42401) * 11;
+acc += Math.sin(42401) + Math.cos(42402) * 12;
+acc += Math.sin(42402) + Math.cos(42403) * 13;
+acc += Math.sin(42403) + Math.cos(42404) * 14;
+acc += Math.sin(42404) + Math.cos(42405) * 15;
+acc += Math.sin(42405) + Math.cos(42406) * 16;
+acc += Math.sin(42406) + Math.cos(42407) * 17;
+acc += Math.sin(42407) + Math.cos(42408) * 18;
+acc += Math.sin(42408) + Math.cos(42409) * 19;
+acc += Math.sin(42409) + Math.cos(42410) * 20;
+acc += Math.sin(42410) + Math.cos(42411) * 21;
+acc += Math.sin(42411) + Math.cos(42412) * 22;
+acc += Math.sin(42412) + Math.cos(42413) * 23;
+acc += Math.sin(42413) + Math.cos(42414) * 24;
+acc += Math.sin(42414) + Math.cos(42415) * 25;
+acc += Math.sin(42415) + Math.cos(42416) * 26;
+acc += Math.sin(42416) + Math.cos(42417) * 27;
+acc += Math.sin(42417) + Math.cos(42418) * 28;
+acc += Math.sin(42418) + Math.cos(42419) * 29;
+acc += Math.sin(42419) + Math.cos(42420) * 30;
+acc += Math.sin(42420) + Math.cos(42421) * 31;
+acc += Math.sin(42421) + Math.cos(42422) * 32;
+acc += Math.sin(42422) + Math.cos(42423) * 33;
+acc += Math.sin(42423) + Math.cos(42424) * 34;
+acc += Math.sin(42424) + Math.cos(42425) * 35;
+acc += Math.sin(42425) + Math.cos(42426) * 36;
+acc += Math.sin(42426) + Math.cos(42427) * 37;
+acc += Math.sin(42427) + Math.cos(42428) * 38;
+acc += Math.sin(42428) + Math.cos(42429) * 39;
+acc += Math.sin(42429) + Math.cos(42430) * 40;
+acc += Math.sin(42430) + Math.cos(42431) * 41;
+acc += Math.sin(42431) + Math.cos(42432) * 42;
+acc += Math.sin(42432) + Math.cos(42433) * 43;
+acc += Math.sin(42433) + Math.cos(42434) * 44;
+acc += Math.sin(42434) + Math.cos(42435) * 45;
+acc += Math.sin(42435) + Math.cos(42436) * 46;
+acc += Math.sin(42436) + Math.cos(42437) * 47;
+acc += Math.sin(42437) + Math.cos(42438) * 48;
+acc += Math.sin(42438) + Math.cos(42439) * 49;
+acc += Math.sin(42439) + Math.cos(42440) * 50;
+acc += Math.sin(42440) + Math.cos(42441) * 51;
+acc += Math.sin(42441) + Math.cos(42442) * 52;
+acc += Math.sin(42442) + Math.cos(42443) * 53;
+acc += Math.sin(42443) + Math.cos(42444) * 54;
+acc += Math.sin(42444) + Math.cos(42445) * 55;
+acc += Math.sin(42445) + Math.cos(42446) * 56;
+acc += Math.sin(42446) + Math.cos(42447) * 57;
+acc += Math.sin(42447) + Math.cos(42448) * 58;
+acc += Math.sin(42448) + Math.cos(42449) * 59;
+acc += Math.sin(42449) + Math.cos(42450) * 60;
+acc += Math.sin(42450) + Math.cos(42451) * 61;
+acc += Math.sin(42451) + Math.cos(42452) * 62;
+acc += Math.sin(42452) + Math.cos(42453) * 63;
+acc += Math.sin(42453) + Math.cos(42454) * 64;
+acc += Math.sin(42454) + Math.cos(42455) * 65;
+acc += Math.sin(42455) + Math.cos(42456) * 66;
+acc += Math.sin(42456) + Math.cos(42457) * 67;
+acc += Math.sin(42457) + Math.cos(42458) * 68;
+acc += Math.sin(42458) + Math.cos(42459) * 69;
+acc += Math.sin(42459) + Math.cos(42460) * 70;
+acc += Math.sin(42460) + Math.cos(42461) * 71;
+acc += Math.sin(42461) + Math.cos(42462) * 72;
+acc += Math.sin(42462) + Math.cos(42463) * 73;
+acc += Math.sin(42463) + Math.cos(42464) * 74;
+acc += Math.sin(42464) + Math.cos(42465) * 75;
+acc += Math.sin(42465) + Math.cos(42466) * 76;
+acc += Math.sin(42466) + Math.cos(42467) * 77;
+acc += Math.sin(42467) + Math.cos(42468) * 78;
+acc += Math.sin(42468) + Math.cos(42469) * 79;
+acc += Math.sin(42469) + Math.cos(42470) * 80;
+acc += Math.sin(42470) + Math.cos(42471) * 81;
+acc += Math.sin(42471) + Math.cos(42472) * 82;
+acc += Math.sin(42472) + Math.cos(42473) * 83;
+acc += Math.sin(42473) + Math.cos(42474) * 84;
+acc += Math.sin(42474) + Math.cos(42475) * 85;
+acc += Math.sin(42475) + Math.cos(42476) * 86;
+acc += Math.sin(42476) + Math.cos(42477) * 87;
+acc += Math.sin(42477) + Math.cos(42478) * 88;
+acc += Math.sin(42478) + Math.cos(42479) * 89;
+acc += Math.sin(42479) + Math.cos(42480) * 90;
+acc += Math.sin(42480) + Math.cos(42481) * 91;
+acc += Math.sin(42481) + Math.cos(42482) * 92;
+acc += Math.sin(42482) + Math.cos(42483) * 93;
+acc += Math.sin(42483) + Math.cos(42484) * 94;
+acc += Math.sin(42484) + Math.cos(42485) * 95;
+acc += Math.sin(42485) + Math.cos(42486) * 96;
+acc += Math.sin(42486) + Math.cos(42487) * 0;
+acc += Math.sin(42487) + Math.cos(42488) * 1;
+acc += Math.sin(42488) + Math.cos(42489) * 2;
+acc += Math.sin(42489) + Math.cos(42490) * 3;
+acc += Math.sin(42490) + Math.cos(42491) * 4;
+acc += Math.sin(42491) + Math.cos(42492) * 5;
+acc += Math.sin(42492) + Math.cos(42493) * 6;
+acc += Math.sin(42493) + Math.cos(42494) * 7;
+acc += Math.sin(42494) + Math.cos(42495) * 8;
+acc += Math.sin(42495) + Math.cos(42496) * 9;
+acc += Math.sin(42496) + Math.cos(42497) * 10;
+acc += Math.sin(42497) + Math.cos(42498) * 11;
+acc += Math.sin(42498) + Math.cos(42499) * 12;
+acc += Math.sin(42499) + Math.cos(42500) * 13;
+acc += Math.sin(42500) + Math.cos(42501) * 14;
+acc += Math.sin(42501) + Math.cos(42502) * 15;
+acc += Math.sin(42502) + Math.cos(42503) * 16;
+acc += Math.sin(42503) + Math.cos(42504) * 17;
+acc += Math.sin(42504) + Math.cos(42505) * 18;
+acc += Math.sin(42505) + Math.cos(42506) * 19;
+acc += Math.sin(42506) + Math.cos(42507) * 20;
+acc += Math.sin(42507) + Math.cos(42508) * 21;
+acc += Math.sin(42508) + Math.cos(42509) * 22;
+acc += Math.sin(42509) + Math.cos(42510) * 23;
+acc += Math.sin(42510) + Math.cos(42511) * 24;
+acc += Math.sin(42511) + Math.cos(42512) * 25;
+acc += Math.sin(42512) + Math.cos(42513) * 26;
+acc += Math.sin(42513) + Math.cos(42514) * 27;
+acc += Math.sin(42514) + Math.cos(42515) * 28;
+acc += Math.sin(42515) + Math.cos(42516) * 29;
+acc += Math.sin(42516) + Math.cos(42517) * 30;
+acc += Math.sin(42517) + Math.cos(42518) * 31;
+acc += Math.sin(42518) + Math.cos(42519) * 32;
+acc += Math.sin(42519) + Math.cos(42520) * 33;
+acc += Math.sin(42520) + Math.cos(42521) * 34;
+acc += Math.sin(42521) + Math.cos(42522) * 35;
+acc += Math.sin(42522) + Math.cos(42523) * 36;
+acc += Math.sin(42523) + Math.cos(42524) * 37;
+acc += Math.sin(42524) + Math.cos(42525) * 38;
+acc += Math.sin(42525) + Math.cos(42526) * 39;
+acc += Math.sin(42526) + Math.cos(42527) * 40;
+acc += Math.sin(42527) + Math.cos(42528) * 41;
+acc += Math.sin(42528) + Math.cos(42529) * 42;
+acc += Math.sin(42529) + Math.cos(42530) * 43;
+acc += Math.sin(42530) + Math.cos(42531) * 44;
+acc += Math.sin(42531) + Math.cos(42532) * 45;
+acc += Math.sin(42532) + Math.cos(42533) * 46;
+acc += Math.sin(42533) + Math.cos(42534) * 47;
+acc += Math.sin(42534) + Math.cos(42535) * 48;
+acc += Math.sin(42535) + Math.cos(42536) * 49;
+acc += Math.sin(42536) + Math.cos(42537) * 50;
+acc += Math.sin(42537) + Math.cos(42538) * 51;
+acc += Math.sin(42538) + Math.cos(42539) * 52;
+acc += Math.sin(42539) + Math.cos(42540) * 53;
+acc += Math.sin(42540) + Math.cos(42541) * 54;
+acc += Math.sin(42541) + Math.cos(42542) * 55;
+acc += Math.sin(42542) + Math.cos(42543) * 56;
+acc += Math.sin(42543) + Math.cos(42544) * 57;
+acc += Math.sin(42544) + Math.cos(42545) * 58;
+acc += Math.sin(42545) + Math.cos(42546) * 59;
+acc += Math.sin(42546) + Math.cos(42547) * 60;
+acc += Math.sin(42547) + Math.cos(42548) * 61;
+acc += Math.sin(42548) + Math.cos(42549) * 62;
+acc += Math.sin(42549) + Math.cos(42550) * 63;
+acc += Math.sin(42550) + Math.cos(42551) * 64;
+acc += Math.sin(42551) + Math.cos(42552) * 65;
+acc += Math.sin(42552) + Math.cos(42553) * 66;
+acc += Math.sin(42553) + Math.cos(42554) * 67;
+acc += Math.sin(42554) + Math.cos(42555) * 68;
+acc += Math.sin(42555) + Math.cos(42556) * 69;
+acc += Math.sin(42556) + Math.cos(42557) * 70;
+acc += Math.sin(42557) + Math.cos(42558) * 71;
+acc += Math.sin(42558) + Math.cos(42559) * 72;
+acc += Math.sin(42559) + Math.cos(42560) * 73;
+acc += Math.sin(42560) + Math.cos(42561) * 74;
+acc += Math.sin(42561) + Math.cos(42562) * 75;
+acc += Math.sin(42562) + Math.cos(42563) * 76;
+acc += Math.sin(42563) + Math.cos(42564) * 77;
+acc += Math.sin(42564) + Math.cos(42565) * 78;
+acc += Math.sin(42565) + Math.cos(42566) * 79;
+acc += Math.sin(42566) + Math.cos(42567) * 80;
+acc += Math.sin(42567) + Math.cos(42568) * 81;
+acc += Math.sin(42568) + Math.cos(42569) * 82;
+acc += Math.sin(42569) + Math.cos(42570) * 83;
+acc += Math.sin(42570) + Math.cos(42571) * 84;
+acc += Math.sin(42571) + Math.cos(42572) * 85;
+acc += Math.sin(42572) + Math.cos(42573) * 86;
+acc += Math.sin(42573) + Math.cos(42574) * 87;
+acc += Math.sin(42574) + Math.cos(42575) * 88;
+acc += Math.sin(42575) + Math.cos(42576) * 89;
+acc += Math.sin(42576) + Math.cos(42577) * 90;
+acc += Math.sin(42577) + Math.cos(42578) * 91;
+acc += Math.sin(42578) + Math.cos(42579) * 92;
+acc += Math.sin(42579) + Math.cos(42580) * 93;
+acc += Math.sin(42580) + Math.cos(42581) * 94;
+acc += Math.sin(42581) + Math.cos(42582) * 95;
+acc += Math.sin(42582) + Math.cos(42583) * 96;
+acc += Math.sin(42583) + Math.cos(42584) * 0;
+acc += Math.sin(42584) + Math.cos(42585) * 1;
+acc += Math.sin(42585) + Math.cos(42586) * 2;
+acc += Math.sin(42586) + Math.cos(42587) * 3;
+acc += Math.sin(42587) + Math.cos(42588) * 4;
+acc += Math.sin(42588) + Math.cos(42589) * 5;
+acc += Math.sin(42589) + Math.cos(42590) * 6;
+acc += Math.sin(42590) + Math.cos(42591) * 7;
+acc += Math.sin(42591) + Math.cos(42592) * 8;
+acc += Math.sin(42592) + Math.cos(42593) * 9;
+acc += Math.sin(42593) + Math.cos(42594) * 10;
+acc += Math.sin(42594) + Math.cos(42595) * 11;
+acc += Math.sin(42595) + Math.cos(42596) * 12;
+acc += Math.sin(42596) + Math.cos(42597) * 13;
+acc += Math.sin(42597) + Math.cos(42598) * 14;
+acc += Math.sin(42598) + Math.cos(42599) * 15;
+acc += Math.sin(42599) + Math.cos(42600) * 16;
+acc += Math.sin(42600) + Math.cos(42601) * 17;
+acc += Math.sin(42601) + Math.cos(42602) * 18;
+acc += Math.sin(42602) + Math.cos(42603) * 19;
+acc += Math.sin(42603) + Math.cos(42604) * 20;
+acc += Math.sin(42604) + Math.cos(42605) * 21;
+acc += Math.sin(42605) + Math.cos(42606) * 22;
+acc += Math.sin(42606) + Math.cos(42607) * 23;
+acc += Math.sin(42607) + Math.cos(42608) * 24;
+acc += Math.sin(42608) + Math.cos(42609) * 25;
+acc += Math.sin(42609) + Math.cos(42610) * 26;
+acc += Math.sin(42610) + Math.cos(42611) * 27;
+acc += Math.sin(42611) + Math.cos(42612) * 28;
+acc += Math.sin(42612) + Math.cos(42613) * 29;
+acc += Math.sin(42613) + Math.cos(42614) * 30;
+acc += Math.sin(42614) + Math.cos(42615) * 31;
+acc += Math.sin(42615) + Math.cos(42616) * 32;
+acc += Math.sin(42616) + Math.cos(42617) * 33;
+acc += Math.sin(42617) + Math.cos(42618) * 34;
+acc += Math.sin(42618) + Math.cos(42619) * 35;
+acc += Math.sin(42619) + Math.cos(42620) * 36;
+acc += Math.sin(42620) + Math.cos(42621) * 37;
+acc += Math.sin(42621) + Math.cos(42622) * 38;
+acc += Math.sin(42622) + Math.cos(42623) * 39;
+acc += Math.sin(42623) + Math.cos(42624) * 40;
+acc += Math.sin(42624) + Math.cos(42625) * 41;
+acc += Math.sin(42625) + Math.cos(42626) * 42;
+acc += Math.sin(42626) + Math.cos(42627) * 43;
+acc += Math.sin(42627) + Math.cos(42628) * 44;
+acc += Math.sin(42628) + Math.cos(42629) * 45;
+acc += Math.sin(42629) + Math.cos(42630) * 46;
+acc += Math.sin(42630) + Math.cos(42631) * 47;
+acc += Math.sin(42631) + Math.cos(42632) * 48;
+acc += Math.sin(42632) + Math.cos(42633) * 49;
+acc += Math.sin(42633) + Math.cos(42634) * 50;
+acc += Math.sin(42634) + Math.cos(42635) * 51;
+acc += Math.sin(42635) + Math.cos(42636) * 52;
+acc += Math.sin(42636) + Math.cos(42637) * 53;
+acc += Math.sin(42637) + Math.cos(42638) * 54;
+acc += Math.sin(42638) + Math.cos(42639) * 55;
+acc += Math.sin(42639) + Math.cos(42640) * 56;
+acc += Math.sin(42640) + Math.cos(42641) * 57;
+acc += Math.sin(42641) + Math.cos(42642) * 58;
+acc += Math.sin(42642) + Math.cos(42643) * 59;
+acc += Math.sin(42643) + Math.cos(42644) * 60;
+acc += Math.sin(42644) + Math.cos(42645) * 61;
+acc += Math.sin(42645) + Math.cos(42646) * 62;
+acc += Math.sin(42646) + Math.cos(42647) * 63;
+acc += Math.sin(42647) + Math.cos(42648) * 64;
+acc += Math.sin(42648) + Math.cos(42649) * 65;
+acc += Math.sin(42649) + Math.cos(42650) * 66;
+acc += Math.sin(42650) + Math.cos(42651) * 67;
+acc += Math.sin(42651) + Math.cos(42652) * 68;
+acc += Math.sin(42652) + Math.cos(42653) * 69;
+acc += Math.sin(42653) + Math.cos(42654) * 70;
+acc += Math.sin(42654) + Math.cos(42655) * 71;
+acc += Math.sin(42655) + Math.cos(42656) * 72;
+acc += Math.sin(42656) + Math.cos(42657) * 73;
+acc += Math.sin(42657) + Math.cos(42658) * 74;
+acc += Math.sin(42658) + Math.cos(42659) * 75;
+acc += Math.sin(42659) + Math.cos(42660) * 76;
+acc += Math.sin(42660) + Math.cos(42661) * 77;
+acc += Math.sin(42661) + Math.cos(42662) * 78;
+acc += Math.sin(42662) + Math.cos(42663) * 79;
+acc += Math.sin(42663) + Math.cos(42664) * 80;
+acc += Math.sin(42664) + Math.cos(42665) * 81;
+acc += Math.sin(42665) + Math.cos(42666) * 82;
+acc += Math.sin(42666) + Math.cos(42667) * 83;
+acc += Math.sin(42667) + Math.cos(42668) * 84;
+acc += Math.sin(42668) + Math.cos(42669) * 85;
+acc += Math.sin(42669) + Math.cos(42670) * 86;
+acc += Math.sin(42670) + Math.cos(42671) * 87;
+acc += Math.sin(42671) + Math.cos(42672) * 88;
+acc += Math.sin(42672) + Math.cos(42673) * 89;
+acc += Math.sin(42673) + Math.cos(42674) * 90;
+acc += Math.sin(42674) + Math.cos(42675) * 91;
+acc += Math.sin(42675) + Math.cos(42676) * 92;
+acc += Math.sin(42676) + Math.cos(42677) * 93;
+acc += Math.sin(42677) + Math.cos(42678) * 94;
+acc += Math.sin(42678) + Math.cos(42679) * 95;
+acc += Math.sin(42679) + Math.cos(42680) * 96;
+acc += Math.sin(42680) + Math.cos(42681) * 0;
+acc += Math.sin(42681) + Math.cos(42682) * 1;
+acc += Math.sin(42682) + Math.cos(42683) * 2;
+acc += Math.sin(42683) + Math.cos(42684) * 3;
+acc += Math.sin(42684) + Math.cos(42685) * 4;
+acc += Math.sin(42685) + Math.cos(42686) * 5;
+acc += Math.sin(42686) + Math.cos(42687) * 6;
+acc += Math.sin(42687) + Math.cos(42688) * 7;
+acc += Math.sin(42688) + Math.cos(42689) * 8;
+acc += Math.sin(42689) + Math.cos(42690) * 9;
+acc += Math.sin(42690) + Math.cos(42691) * 10;
+acc += Math.sin(42691) + Math.cos(42692) * 11;
+acc += Math.sin(42692) + Math.cos(42693) * 12;
+acc += Math.sin(42693) + Math.cos(42694) * 13;
+acc += Math.sin(42694) + Math.cos(42695) * 14;
+acc += Math.sin(42695) + Math.cos(42696) * 15;
+acc += Math.sin(42696) + Math.cos(42697) * 16;
+acc += Math.sin(42697) + Math.cos(42698) * 17;
+acc += Math.sin(42698) + Math.cos(42699) * 18;
+acc += Math.sin(42699) + Math.cos(42700) * 19;
+acc += Math.sin(42700) + Math.cos(42701) * 20;
+acc += Math.sin(42701) + Math.cos(42702) * 21;
+acc += Math.sin(42702) + Math.cos(42703) * 22;
+acc += Math.sin(42703) + Math.cos(42704) * 23;
+acc += Math.sin(42704) + Math.cos(42705) * 24;
+acc += Math.sin(42705) + Math.cos(42706) * 25;
+acc += Math.sin(42706) + Math.cos(42707) * 26;
+acc += Math.sin(42707) + Math.cos(42708) * 27;
+acc += Math.sin(42708) + Math.cos(42709) * 28;
+acc += Math.sin(42709) + Math.cos(42710) * 29;
+acc += Math.sin(42710) + Math.cos(42711) * 30;
+acc += Math.sin(42711) + Math.cos(42712) * 31;
+acc += Math.sin(42712) + Math.cos(42713) * 32;
+acc += Math.sin(42713) + Math.cos(42714) * 33;
+acc += Math.sin(42714) + Math.cos(42715) * 34;
+acc += Math.sin(42715) + Math.cos(42716) * 35;
+acc += Math.sin(42716) + Math.cos(42717) * 36;
+acc += Math.sin(42717) + Math.cos(42718) * 37;
+acc += Math.sin(42718) + Math.cos(42719) * 38;
+acc += Math.sin(42719) + Math.cos(42720) * 39;
+acc += Math.sin(42720) + Math.cos(42721) * 40;
+acc += Math.sin(42721) + Math.cos(42722) * 41;
+acc += Math.sin(42722) + Math.cos(42723) * 42;
+acc += Math.sin(42723) + Math.cos(42724) * 43;
+acc += Math.sin(42724) + Math.cos(42725) * 44;
+acc += Math.sin(42725) + Math.cos(42726) * 45;
+acc += Math.sin(42726) + Math.cos(42727) * 46;
+acc += Math.sin(42727) + Math.cos(42728) * 47;
+acc += Math.sin(42728) + Math.cos(42729) * 48;
+acc += Math.sin(42729) + Math.cos(42730) * 49;
+acc += Math.sin(42730) + Math.cos(42731) * 50;
+acc += Math.sin(42731) + Math.cos(42732) * 51;
+acc += Math.sin(42732) + Math.cos(42733) * 52;
+acc += Math.sin(42733) + Math.cos(42734) * 53;
+acc += Math.sin(42734) + Math.cos(42735) * 54;
+acc += Math.sin(42735) + Math.cos(42736) * 55;
+acc += Math.sin(42736) + Math.cos(42737) * 56;
+acc += Math.sin(42737) + Math.cos(42738) * 57;
+acc += Math.sin(42738) + Math.cos(42739) * 58;
+acc += Math.sin(42739) + Math.cos(42740) * 59;
+acc += Math.sin(42740) + Math.cos(42741) * 60;
+acc += Math.sin(42741) + Math.cos(42742) * 61;
+acc += Math.sin(42742) + Math.cos(42743) * 62;
+acc += Math.sin(42743) + Math.cos(42744) * 63;
+acc += Math.sin(42744) + Math.cos(42745) * 64;
+acc += Math.sin(42745) + Math.cos(42746) * 65;
+acc += Math.sin(42746) + Math.cos(42747) * 66;
+acc += Math.sin(42747) + Math.cos(42748) * 67;
+acc += Math.sin(42748) + Math.cos(42749) * 68;
+acc += Math.sin(42749) + Math.cos(42750) * 69;
+acc += Math.sin(42750) + Math.cos(42751) * 70;
+acc += Math.sin(42751) + Math.cos(42752) * 71;
+acc += Math.sin(42752) + Math.cos(42753) * 72;
+acc += Math.sin(42753) + Math.cos(42754) * 73;
+acc += Math.sin(42754) + Math.cos(42755) * 74;
+acc += Math.sin(42755) + Math.cos(42756) * 75;
+acc += Math.sin(42756) + Math.cos(42757) * 76;
+acc += Math.sin(42757) + Math.cos(42758) * 77;
+acc += Math.sin(42758) + Math.cos(42759) * 78;
+acc += Math.sin(42759) + Math.cos(42760) * 79;
+acc += Math.sin(42760) + Math.cos(42761) * 80;
+acc += Math.sin(42761) + Math.cos(42762) * 81;
+acc += Math.sin(42762) + Math.cos(42763) * 82;
+acc += Math.sin(42763) + Math.cos(42764) * 83;
+acc += Math.sin(42764) + Math.cos(42765) * 84;
+acc += Math.sin(42765) + Math.cos(42766) * 85;
+acc += Math.sin(42766) + Math.cos(42767) * 86;
+acc += Math.sin(42767) + Math.cos(42768) * 87;
+acc += Math.sin(42768) + Math.cos(42769) * 88;
+acc += Math.sin(42769) + Math.cos(42770) * 89;
+acc += Math.sin(42770) + Math.cos(42771) * 90;
+acc += Math.sin(42771) + Math.cos(42772) * 91;
+acc += Math.sin(42772) + Math.cos(42773) * 92;
+acc += Math.sin(42773) + Math.cos(42774) * 93;
+acc += Math.sin(42774) + Math.cos(42775) * 94;
+acc += Math.sin(42775) + Math.cos(42776) * 95;
+acc += Math.sin(42776) + Math.cos(42777) * 96;
+acc += Math.sin(42777) + Math.cos(42778) * 0;
+acc += Math.sin(42778) + Math.cos(42779) * 1;
+acc += Math.sin(42779) + Math.cos(42780) * 2;
+acc += Math.sin(42780) + Math.cos(42781) * 3;
+acc += Math.sin(42781) + Math.cos(42782) * 4;
+acc += Math.sin(42782) + Math.cos(42783) * 5;
+acc += Math.sin(42783) + Math.cos(42784) * 6;
+acc += Math.sin(42784) + Math.cos(42785) * 7;
+acc += Math.sin(42785) + Math.cos(42786) * 8;
+acc += Math.sin(42786) + Math.cos(42787) * 9;
+acc += Math.sin(42787) + Math.cos(42788) * 10;
+acc += Math.sin(42788) + Math.cos(42789) * 11;
+acc += Math.sin(42789) + Math.cos(42790) * 12;
+acc += Math.sin(42790) + Math.cos(42791) * 13;
+acc += Math.sin(42791) + Math.cos(42792) * 14;
+acc += Math.sin(42792) + Math.cos(42793) * 15;
+acc += Math.sin(42793) + Math.cos(42794) * 16;
+acc += Math.sin(42794) + Math.cos(42795) * 17;
+acc += Math.sin(42795) + Math.cos(42796) * 18;
+acc += Math.sin(42796) + Math.cos(42797) * 19;
+acc += Math.sin(42797) + Math.cos(42798) * 20;
+acc += Math.sin(42798) + Math.cos(42799) * 21;
+acc += Math.sin(42799) + Math.cos(42800) * 22;
+acc += Math.sin(42800) + Math.cos(42801) * 23;
+acc += Math.sin(42801) + Math.cos(42802) * 24;
+acc += Math.sin(42802) + Math.cos(42803) * 25;
+acc += Math.sin(42803) + Math.cos(42804) * 26;
+acc += Math.sin(42804) + Math.cos(42805) * 27;
+acc += Math.sin(42805) + Math.cos(42806) * 28;
+acc += Math.sin(42806) + Math.cos(42807) * 29;
+acc += Math.sin(42807) + Math.cos(42808) * 30;
+acc += Math.sin(42808) + Math.cos(42809) * 31;
+acc += Math.sin(42809) + Math.cos(42810) * 32;
+acc += Math.sin(42810) + Math.cos(42811) * 33;
+acc += Math.sin(42811) + Math.cos(42812) * 34;
+acc += Math.sin(42812) + Math.cos(42813) * 35;
+acc += Math.sin(42813) + Math.cos(42814) * 36;
+acc += Math.sin(42814) + Math.cos(42815) * 37;
+acc += Math.sin(42815) + Math.cos(42816) * 38;
+acc += Math.sin(42816) + Math.cos(42817) * 39;
+acc += Math.sin(42817) + Math.cos(42818) * 40;
+acc += Math.sin(42818) + Math.cos(42819) * 41;
+acc += Math.sin(42819) + Math.cos(42820) * 42;
+acc += Math.sin(42820) + Math.cos(42821) * 43;
+acc += Math.sin(42821) + Math.cos(42822) * 44;
+acc += Math.sin(42822) + Math.cos(42823) * 45;
+acc += Math.sin(42823) + Math.cos(42824) * 46;
+acc += Math.sin(42824) + Math.cos(42825) * 47;
+acc += Math.sin(42825) + Math.cos(42826) * 48;
+acc += Math.sin(42826) + Math.cos(42827) * 49;
+acc += Math.sin(42827) + Math.cos(42828) * 50;
+acc += Math.sin(42828) + Math.cos(42829) * 51;
+acc += Math.sin(42829) + Math.cos(42830) * 52;
+acc += Math.sin(42830) + Math.cos(42831) * 53;
+acc += Math.sin(42831) + Math.cos(42832) * 54;
+acc += Math.sin(42832) + Math.cos(42833) * 55;
+acc += Math.sin(42833) + Math.cos(42834) * 56;
+acc += Math.sin(42834) + Math.cos(42835) * 57;
+acc += Math.sin(42835) + Math.cos(42836) * 58;
+acc += Math.sin(42836) + Math.cos(42837) * 59;
+acc += Math.sin(42837) + Math.cos(42838) * 60;
+acc += Math.sin(42838) + Math.cos(42839) * 61;
+acc += Math.sin(42839) + Math.cos(42840) * 62;
+acc += Math.sin(42840) + Math.cos(42841) * 63;
+acc += Math.sin(42841) + Math.cos(42842) * 64;
+acc += Math.sin(42842) + Math.cos(42843) * 65;
+acc += Math.sin(42843) + Math.cos(42844) * 66;
+acc += Math.sin(42844) + Math.cos(42845) * 67;
+acc += Math.sin(42845) + Math.cos(42846) * 68;
+acc += Math.sin(42846) + Math.cos(42847) * 69;
+acc += Math.sin(42847) + Math.cos(42848) * 70;
+acc += Math.sin(42848) + Math.cos(42849) * 71;
+acc += Math.sin(42849) + Math.cos(42850) * 72;
+acc += Math.sin(42850) + Math.cos(42851) * 73;
+acc += Math.sin(42851) + Math.cos(42852) * 74;
+acc += Math.sin(42852) + Math.cos(42853) * 75;
+acc += Math.sin(42853) + Math.cos(42854) * 76;
+acc += Math.sin(42854) + Math.cos(42855) * 77;
+acc += Math.sin(42855) + Math.cos(42856) * 78;
+acc += Math.sin(42856) + Math.cos(42857) * 79;
+acc += Math.sin(42857) + Math.cos(42858) * 80;
+acc += Math.sin(42858) + Math.cos(42859) * 81;
+acc += Math.sin(42859) + Math.cos(42860) * 82;
+acc += Math.sin(42860) + Math.cos(42861) * 83;
+acc += Math.sin(42861) + Math.cos(42862) * 84;
+acc += Math.sin(42862) + Math.cos(42863) * 85;
+acc += Math.sin(42863) + Math.cos(42864) * 86;
+acc += Math.sin(42864) + Math.cos(42865) * 87;
+acc += Math.sin(42865) + Math.cos(42866) * 88;
+acc += Math.sin(42866) + Math.cos(42867) * 89;
+acc += Math.sin(42867) + Math.cos(42868) * 90;
+acc += Math.sin(42868) + Math.cos(42869) * 91;
+acc += Math.sin(42869) + Math.cos(42870) * 92;
+acc += Math.sin(42870) + Math.cos(42871) * 93;
+acc += Math.sin(42871) + Math.cos(42872) * 94;
+acc += Math.sin(42872) + Math.cos(42873) * 95;
+acc += Math.sin(42873) + Math.cos(42874) * 96;
+acc += Math.sin(42874) + Math.cos(42875) * 0;
+acc += Math.sin(42875) + Math.cos(42876) * 1;
+acc += Math.sin(42876) + Math.cos(42877) * 2;
+acc += Math.sin(42877) + Math.cos(42878) * 3;
+acc += Math.sin(42878) + Math.cos(42879) * 4;
+acc += Math.sin(42879) + Math.cos(42880) * 5;
+acc += Math.sin(42880) + Math.cos(42881) * 6;
+acc += Math.sin(42881) + Math.cos(42882) * 7;
+acc += Math.sin(42882) + Math.cos(42883) * 8;
+acc += Math.sin(42883) + Math.cos(42884) * 9;
+acc += Math.sin(42884) + Math.cos(42885) * 10;
+acc += Math.sin(42885) + Math.cos(42886) * 11;
+acc += Math.sin(42886) + Math.cos(42887) * 12;
+acc += Math.sin(42887) + Math.cos(42888) * 13;
+acc += Math.sin(42888) + Math.cos(42889) * 14;
+acc += Math.sin(42889) + Math.cos(42890) * 15;
+acc += Math.sin(42890) + Math.cos(42891) * 16;
+acc += Math.sin(42891) + Math.cos(42892) * 17;
+acc += Math.sin(42892) + Math.cos(42893) * 18;
+acc += Math.sin(42893) + Math.cos(42894) * 19;
+acc += Math.sin(42894) + Math.cos(42895) * 20;
+acc += Math.sin(42895) + Math.cos(42896) * 21;
+acc += Math.sin(42896) + Math.cos(42897) * 22;
+acc += Math.sin(42897) + Math.cos(42898) * 23;
+acc += Math.sin(42898) + Math.cos(42899) * 24;
+acc += Math.sin(42899) + Math.cos(42900) * 25;
+acc += Math.sin(42900) + Math.cos(42901) * 26;
+acc += Math.sin(42901) + Math.cos(42902) * 27;
+acc += Math.sin(42902) + Math.cos(42903) * 28;
+acc += Math.sin(42903) + Math.cos(42904) * 29;
+acc += Math.sin(42904) + Math.cos(42905) * 30;
+acc += Math.sin(42905) + Math.cos(42906) * 31;
+acc += Math.sin(42906) + Math.cos(42907) * 32;
+acc += Math.sin(42907) + Math.cos(42908) * 33;
+acc += Math.sin(42908) + Math.cos(42909) * 34;
+acc += Math.sin(42909) + Math.cos(42910) * 35;
+acc += Math.sin(42910) + Math.cos(42911) * 36;
+acc += Math.sin(42911) + Math.cos(42912) * 37;
+acc += Math.sin(42912) + Math.cos(42913) * 38;
+acc += Math.sin(42913) + Math.cos(42914) * 39;
+acc += Math.sin(42914) + Math.cos(42915) * 40;
+acc += Math.sin(42915) + Math.cos(42916) * 41;
+acc += Math.sin(42916) + Math.cos(42917) * 42;
+acc += Math.sin(42917) + Math.cos(42918) * 43;
+acc += Math.sin(42918) + Math.cos(42919) * 44;
+acc += Math.sin(42919) + Math.cos(42920) * 45;
+acc += Math.sin(42920) + Math.cos(42921) * 46;
+acc += Math.sin(42921) + Math.cos(42922) * 47;
+acc += Math.sin(42922) + Math.cos(42923) * 48;
+acc += Math.sin(42923) + Math.cos(42924) * 49;
+acc += Math.sin(42924) + Math.cos(42925) * 50;
+acc += Math.sin(42925) + Math.cos(42926) * 51;
+acc += Math.sin(42926) + Math.cos(42927) * 52;
+acc += Math.sin(42927) + Math.cos(42928) * 53;
+acc += Math.sin(42928) + Math.cos(42929) * 54;
+acc += Math.sin(42929) + Math.cos(42930) * 55;
+acc += Math.sin(42930) + Math.cos(42931) * 56;
+acc += Math.sin(42931) + Math.cos(42932) * 57;
+acc += Math.sin(42932) + Math.cos(42933) * 58;
+acc += Math.sin(42933) + Math.cos(42934) * 59;
+acc += Math.sin(42934) + Math.cos(42935) * 60;
+acc += Math.sin(42935) + Math.cos(42936) * 61;
+acc += Math.sin(42936) + Math.cos(42937) * 62;
+acc += Math.sin(42937) + Math.cos(42938) * 63;
+acc += Math.sin(42938) + Math.cos(42939) * 64;
+acc += Math.sin(42939) + Math.cos(42940) * 65;
+acc += Math.sin(42940) + Math.cos(42941) * 66;
+acc += Math.sin(42941) + Math.cos(42942) * 67;
+acc += Math.sin(42942) + Math.cos(42943) * 68;
+acc += Math.sin(42943) + Math.cos(42944) * 69;
+acc += Math.sin(42944) + Math.cos(42945) * 70;
+acc += Math.sin(42945) + Math.cos(42946) * 71;
+acc += Math.sin(42946) + Math.cos(42947) * 72;
+acc += Math.sin(42947) + Math.cos(42948) * 73;
+acc += Math.sin(42948) + Math.cos(42949) * 74;
+acc += Math.sin(42949) + Math.cos(42950) * 75;
+acc += Math.sin(42950) + Math.cos(42951) * 76;
+acc += Math.sin(42951) + Math.cos(42952) * 77;
+acc += Math.sin(42952) + Math.cos(42953) * 78;
+acc += Math.sin(42953) + Math.cos(42954) * 79;
+acc += Math.sin(42954) + Math.cos(42955) * 80;
+acc += Math.sin(42955) + Math.cos(42956) * 81;
+acc += Math.sin(42956) + Math.cos(42957) * 82;
+acc += Math.sin(42957) + Math.cos(42958) * 83;
+acc += Math.sin(42958) + Math.cos(42959) * 84;
+acc += Math.sin(42959) + Math.cos(42960) * 85;
+acc += Math.sin(42960) + Math.cos(42961) * 86;
+acc += Math.sin(42961) + Math.cos(42962) * 87;
+acc += Math.sin(42962) + Math.cos(42963) * 88;
+acc += Math.sin(42963) + Math.cos(42964) * 89;
+acc += Math.sin(42964) + Math.cos(42965) * 90;
+acc += Math.sin(42965) + Math.cos(42966) * 91;
+acc += Math.sin(42966) + Math.cos(42967) * 92;
+acc += Math.sin(42967) + Math.cos(42968) * 93;
+acc += Math.sin(42968) + Math.cos(42969) * 94;
+acc += Math.sin(42969) + Math.cos(42970) * 95;
+acc += Math.sin(42970) + Math.cos(42971) * 96;
+acc += Math.sin(42971) + Math.cos(42972) * 0;
+acc += Math.sin(42972) + Math.cos(42973) * 1;
+acc += Math.sin(42973) + Math.cos(42974) * 2;
+acc += Math.sin(42974) + Math.cos(42975) * 3;
+acc += Math.sin(42975) + Math.cos(42976) * 4;
+acc += Math.sin(42976) + Math.cos(42977) * 5;
+acc += Math.sin(42977) + Math.cos(42978) * 6;
+acc += Math.sin(42978) + Math.cos(42979) * 7;
+acc += Math.sin(42979) + Math.cos(42980) * 8;
+acc += Math.sin(42980) + Math.cos(42981) * 9;
+acc += Math.sin(42981) + Math.cos(42982) * 10;
+acc += Math.sin(42982) + Math.cos(42983) * 11;
+acc += Math.sin(42983) + Math.cos(42984) * 12;
+acc += Math.sin(42984) + Math.cos(42985) * 13;
+acc += Math.sin(42985) + Math.cos(42986) * 14;
+acc += Math.sin(42986) + Math.cos(42987) * 15;
+acc += Math.sin(42987) + Math.cos(42988) * 16;
+acc += Math.sin(42988) + Math.cos(42989) * 17;
+acc += Math.sin(42989) + Math.cos(42990) * 18;
+acc += Math.sin(42990) + Math.cos(42991) * 19;
+acc += Math.sin(42991) + Math.cos(42992) * 20;
+acc += Math.sin(42992) + Math.cos(42993) * 21;
+acc += Math.sin(42993) + Math.cos(42994) * 22;
+acc += Math.sin(42994) + Math.cos(42995) * 23;
+acc += Math.sin(42995) + Math.cos(42996) * 24;
+acc += Math.sin(42996) + Math.cos(42997) * 25;
+acc += Math.sin(42997) + Math.cos(42998) * 26;
+acc += Math.sin(42998) + Math.cos(42999) * 27;
+acc += Math.sin(42999) + Math.cos(43000) * 28;
+acc += Math.sin(43000) + Math.cos(43001) * 29;
+acc += Math.sin(43001) + Math.cos(43002) * 30;
+acc += Math.sin(43002) + Math.cos(43003) * 31;
+acc += Math.sin(43003) + Math.cos(43004) * 32;
+acc += Math.sin(43004) + Math.cos(43005) * 33;
+acc += Math.sin(43005) + Math.cos(43006) * 34;
+acc += Math.sin(43006) + Math.cos(43007) * 35;
+acc += Math.sin(43007) + Math.cos(43008) * 36;
+acc += Math.sin(43008) + Math.cos(43009) * 37;
+acc += Math.sin(43009) + Math.cos(43010) * 38;
+acc += Math.sin(43010) + Math.cos(43011) * 39;
+acc += Math.sin(43011) + Math.cos(43012) * 40;
+acc += Math.sin(43012) + Math.cos(43013) * 41;
+acc += Math.sin(43013) + Math.cos(43014) * 42;
+acc += Math.sin(43014) + Math.cos(43015) * 43;
+acc += Math.sin(43015) + Math.cos(43016) * 44;
+acc += Math.sin(43016) + Math.cos(43017) * 45;
+acc += Math.sin(43017) + Math.cos(43018) * 46;
+acc += Math.sin(43018) + Math.cos(43019) * 47;
+acc += Math.sin(43019) + Math.cos(43020) * 48;
+acc += Math.sin(43020) + Math.cos(43021) * 49;
+acc += Math.sin(43021) + Math.cos(43022) * 50;
+acc += Math.sin(43022) + Math.cos(43023) * 51;
+acc += Math.sin(43023) + Math.cos(43024) * 52;
+acc += Math.sin(43024) + Math.cos(43025) * 53;
+acc += Math.sin(43025) + Math.cos(43026) * 54;
+acc += Math.sin(43026) + Math.cos(43027) * 55;
+acc += Math.sin(43027) + Math.cos(43028) * 56;
+acc += Math.sin(43028) + Math.cos(43029) * 57;
+acc += Math.sin(43029) + Math.cos(43030) * 58;
+acc += Math.sin(43030) + Math.cos(43031) * 59;
+acc += Math.sin(43031) + Math.cos(43032) * 60;
+acc += Math.sin(43032) + Math.cos(43033) * 61;
+acc += Math.sin(43033) + Math.cos(43034) * 62;
+acc += Math.sin(43034) + Math.cos(43035) * 63;
+acc += Math.sin(43035) + Math.cos(43036) * 64;
+acc += Math.sin(43036) + Math.cos(43037) * 65;
+acc += Math.sin(43037) + Math.cos(43038) * 66;
+acc += Math.sin(43038) + Math.cos(43039) * 67;
+acc += Math.sin(43039) + Math.cos(43040) * 68;
+acc += Math.sin(43040) + Math.cos(43041) * 69;
+acc += Math.sin(43041) + Math.cos(43042) * 70;
+acc += Math.sin(43042) + Math.cos(43043) * 71;
+acc += Math.sin(43043) + Math.cos(43044) * 72;
+acc += Math.sin(43044) + Math.cos(43045) * 73;
+acc += Math.sin(43045) + Math.cos(43046) * 74;
+acc += Math.sin(43046) + Math.cos(43047) * 75;
+acc += Math.sin(43047) + Math.cos(43048) * 76;
+acc += Math.sin(43048) + Math.cos(43049) * 77;
+acc += Math.sin(43049) + Math.cos(43050) * 78;
+acc += Math.sin(43050) + Math.cos(43051) * 79;
+acc += Math.sin(43051) + Math.cos(43052) * 80;
+acc += Math.sin(43052) + Math.cos(43053) * 81;
+acc += Math.sin(43053) + Math.cos(43054) * 82;
+acc += Math.sin(43054) + Math.cos(43055) * 83;
+acc += Math.sin(43055) + Math.cos(43056) * 84;
+acc += Math.sin(43056) + Math.cos(43057) * 85;
+acc += Math.sin(43057) + Math.cos(43058) * 86;
+acc += Math.sin(43058) + Math.cos(43059) * 87;
+acc += Math.sin(43059) + Math.cos(43060) * 88;
+acc += Math.sin(43060) + Math.cos(43061) * 89;
+acc += Math.sin(43061) + Math.cos(43062) * 90;
+acc += Math.sin(43062) + Math.cos(43063) * 91;
+acc += Math.sin(43063) + Math.cos(43064) * 92;
+acc += Math.sin(43064) + Math.cos(43065) * 93;
+acc += Math.sin(43065) + Math.cos(43066) * 94;
+acc += Math.sin(43066) + Math.cos(43067) * 95;
+acc += Math.sin(43067) + Math.cos(43068) * 96;
+acc += Math.sin(43068) + Math.cos(43069) * 0;
+acc += Math.sin(43069) + Math.cos(43070) * 1;
+acc += Math.sin(43070) + Math.cos(43071) * 2;
+acc += Math.sin(43071) + Math.cos(43072) * 3;
+acc += Math.sin(43072) + Math.cos(43073) * 4;
+acc += Math.sin(43073) + Math.cos(43074) * 5;
+acc += Math.sin(43074) + Math.cos(43075) * 6;
+acc += Math.sin(43075) + Math.cos(43076) * 7;
+acc += Math.sin(43076) + Math.cos(43077) * 8;
+acc += Math.sin(43077) + Math.cos(43078) * 9;
+acc += Math.sin(43078) + Math.cos(43079) * 10;
+acc += Math.sin(43079) + Math.cos(43080) * 11;
+acc += Math.sin(43080) + Math.cos(43081) * 12;
+acc += Math.sin(43081) + Math.cos(43082) * 13;
+acc += Math.sin(43082) + Math.cos(43083) * 14;
+acc += Math.sin(43083) + Math.cos(43084) * 15;
+acc += Math.sin(43084) + Math.cos(43085) * 16;
+acc += Math.sin(43085) + Math.cos(43086) * 17;
+acc += Math.sin(43086) + Math.cos(43087) * 18;
+acc += Math.sin(43087) + Math.cos(43088) * 19;
+acc += Math.sin(43088) + Math.cos(43089) * 20;
+acc += Math.sin(43089) + Math.cos(43090) * 21;
+acc += Math.sin(43090) + Math.cos(43091) * 22;
+acc += Math.sin(43091) + Math.cos(43092) * 23;
+acc += Math.sin(43092) + Math.cos(43093) * 24;
+acc += Math.sin(43093) + Math.cos(43094) * 25;
+acc += Math.sin(43094) + Math.cos(43095) * 26;
+acc += Math.sin(43095) + Math.cos(43096) * 27;
+acc += Math.sin(43096) + Math.cos(43097) * 28;
+acc += Math.sin(43097) + Math.cos(43098) * 29;
+acc += Math.sin(43098) + Math.cos(43099) * 30;
+acc += Math.sin(43099) + Math.cos(43100) * 31;
+acc += Math.sin(43100) + Math.cos(43101) * 32;
+acc += Math.sin(43101) + Math.cos(43102) * 33;
+acc += Math.sin(43102) + Math.cos(43103) * 34;
+acc += Math.sin(43103) + Math.cos(43104) * 35;
+acc += Math.sin(43104) + Math.cos(43105) * 36;
+acc += Math.sin(43105) + Math.cos(43106) * 37;
+acc += Math.sin(43106) + Math.cos(43107) * 38;
+acc += Math.sin(43107) + Math.cos(43108) * 39;
+acc += Math.sin(43108) + Math.cos(43109) * 40;
+acc += Math.sin(43109) + Math.cos(43110) * 41;
+acc += Math.sin(43110) + Math.cos(43111) * 42;
+acc += Math.sin(43111) + Math.cos(43112) * 43;
+acc += Math.sin(43112) + Math.cos(43113) * 44;
+acc += Math.sin(43113) + Math.cos(43114) * 45;
+acc += Math.sin(43114) + Math.cos(43115) * 46;
+acc += Math.sin(43115) + Math.cos(43116) * 47;
+acc += Math.sin(43116) + Math.cos(43117) * 48;
+acc += Math.sin(43117) + Math.cos(43118) * 49;
+acc += Math.sin(43118) + Math.cos(43119) * 50;
+acc += Math.sin(43119) + Math.cos(43120) * 51;
+acc += Math.sin(43120) + Math.cos(43121) * 52;
+acc += Math.sin(43121) + Math.cos(43122) * 53;
+acc += Math.sin(43122) + Math.cos(43123) * 54;
+acc += Math.sin(43123) + Math.cos(43124) * 55;
+acc += Math.sin(43124) + Math.cos(43125) * 56;
+acc += Math.sin(43125) + Math.cos(43126) * 57;
+acc += Math.sin(43126) + Math.cos(43127) * 58;
+acc += Math.sin(43127) + Math.cos(43128) * 59;
+acc += Math.sin(43128) + Math.cos(43129) * 60;
+acc += Math.sin(43129) + Math.cos(43130) * 61;
+acc += Math.sin(43130) + Math.cos(43131) * 62;
+acc += Math.sin(43131) + Math.cos(43132) * 63;
+acc += Math.sin(43132) + Math.cos(43133) * 64;
+acc += Math.sin(43133) + Math.cos(43134) * 65;
+acc += Math.sin(43134) + Math.cos(43135) * 66;
+acc += Math.sin(43135) + Math.cos(43136) * 67;
+acc += Math.sin(43136) + Math.cos(43137) * 68;
+acc += Math.sin(43137) + Math.cos(43138) * 69;
+acc += Math.sin(43138) + Math.cos(43139) * 70;
+acc += Math.sin(43139) + Math.cos(43140) * 71;
+acc += Math.sin(43140) + Math.cos(43141) * 72;
+acc += Math.sin(43141) + Math.cos(43142) * 73;
+acc += Math.sin(43142) + Math.cos(43143) * 74;
+acc += Math.sin(43143) + Math.cos(43144) * 75;
+acc += Math.sin(43144) + Math.cos(43145) * 76;
+acc += Math.sin(43145) + Math.cos(43146) * 77;
+acc += Math.sin(43146) + Math.cos(43147) * 78;
+acc += Math.sin(43147) + Math.cos(43148) * 79;
+acc += Math.sin(43148) + Math.cos(43149) * 80;
+acc += Math.sin(43149) + Math.cos(43150) * 81;
+acc += Math.sin(43150) + Math.cos(43151) * 82;
+acc += Math.sin(43151) + Math.cos(43152) * 83;
+acc += Math.sin(43152) + Math.cos(43153) * 84;
+acc += Math.sin(43153) + Math.cos(43154) * 85;
+acc += Math.sin(43154) + Math.cos(43155) * 86;
+acc += Math.sin(43155) + Math.cos(43156) * 87;
+acc += Math.sin(43156) + Math.cos(43157) * 88;
+acc += Math.sin(43157) + Math.cos(43158) * 89;
+acc += Math.sin(43158) + Math.cos(43159) * 90;
+acc += Math.sin(43159) + Math.cos(43160) * 91;
+acc += Math.sin(43160) + Math.cos(43161) * 92;
+acc += Math.sin(43161) + Math.cos(43162) * 93;
+acc += Math.sin(43162) + Math.cos(43163) * 94;
+acc += Math.sin(43163) + Math.cos(43164) * 95;
+acc += Math.sin(43164) + Math.cos(43165) * 96;
+acc += Math.sin(43165) + Math.cos(43166) * 0;
+acc += Math.sin(43166) + Math.cos(43167) * 1;
+acc += Math.sin(43167) + Math.cos(43168) * 2;
+acc += Math.sin(43168) + Math.cos(43169) * 3;
+acc += Math.sin(43169) + Math.cos(43170) * 4;
+acc += Math.sin(43170) + Math.cos(43171) * 5;
+acc += Math.sin(43171) + Math.cos(43172) * 6;
+acc += Math.sin(43172) + Math.cos(43173) * 7;
+acc += Math.sin(43173) + Math.cos(43174) * 8;
+acc += Math.sin(43174) + Math.cos(43175) * 9;
+acc += Math.sin(43175) + Math.cos(43176) * 10;
+acc += Math.sin(43176) + Math.cos(43177) * 11;
+acc += Math.sin(43177) + Math.cos(43178) * 12;
+acc += Math.sin(43178) + Math.cos(43179) * 13;
+acc += Math.sin(43179) + Math.cos(43180) * 14;
+acc += Math.sin(43180) + Math.cos(43181) * 15;
+acc += Math.sin(43181) + Math.cos(43182) * 16;
+acc += Math.sin(43182) + Math.cos(43183) * 17;
+acc += Math.sin(43183) + Math.cos(43184) * 18;
+acc += Math.sin(43184) + Math.cos(43185) * 19;
+acc += Math.sin(43185) + Math.cos(43186) * 20;
+acc += Math.sin(43186) + Math.cos(43187) * 21;
+acc += Math.sin(43187) + Math.cos(43188) * 22;
+acc += Math.sin(43188) + Math.cos(43189) * 23;
+acc += Math.sin(43189) + Math.cos(43190) * 24;
+acc += Math.sin(43190) + Math.cos(43191) * 25;
+acc += Math.sin(43191) + Math.cos(43192) * 26;
+acc += Math.sin(43192) + Math.cos(43193) * 27;
+acc += Math.sin(43193) + Math.cos(43194) * 28;
+acc += Math.sin(43194) + Math.cos(43195) * 29;
+acc += Math.sin(43195) + Math.cos(43196) * 30;
+acc += Math.sin(43196) + Math.cos(43197) * 31;
+acc += Math.sin(43197) + Math.cos(43198) * 32;
+acc += Math.sin(43198) + Math.cos(43199) * 33;
+acc += Math.sin(43199) + Math.cos(43200) * 34;
+acc += Math.sin(43200) + Math.cos(43201) * 35;
+acc += Math.sin(43201) + Math.cos(43202) * 36;
+acc += Math.sin(43202) + Math.cos(43203) * 37;
+acc += Math.sin(43203) + Math.cos(43204) * 38;
+acc += Math.sin(43204) + Math.cos(43205) * 39;
+acc += Math.sin(43205) + Math.cos(43206) * 40;
+acc += Math.sin(43206) + Math.cos(43207) * 41;
+acc += Math.sin(43207) + Math.cos(43208) * 42;
+acc += Math.sin(43208) + Math.cos(43209) * 43;
+acc += Math.sin(43209) + Math.cos(43210) * 44;
+acc += Math.sin(43210) + Math.cos(43211) * 45;
+acc += Math.sin(43211) + Math.cos(43212) * 46;
+acc += Math.sin(43212) + Math.cos(43213) * 47;
+acc += Math.sin(43213) + Math.cos(43214) * 48;
+acc += Math.sin(43214) + Math.cos(43215) * 49;
+acc += Math.sin(43215) + Math.cos(43216) * 50;
+acc += Math.sin(43216) + Math.cos(43217) * 51;
+acc += Math.sin(43217) + Math.cos(43218) * 52;
+acc += Math.sin(43218) + Math.cos(43219) * 53;
+acc += Math.sin(43219) + Math.cos(43220) * 54;
+acc += Math.sin(43220) + Math.cos(43221) * 55;
+acc += Math.sin(43221) + Math.cos(43222) * 56;
+acc += Math.sin(43222) + Math.cos(43223) * 57;
+acc += Math.sin(43223) + Math.cos(43224) * 58;
+acc += Math.sin(43224) + Math.cos(43225) * 59;
+acc += Math.sin(43225) + Math.cos(43226) * 60;
+acc += Math.sin(43226) + Math.cos(43227) * 61;
+acc += Math.sin(43227) + Math.cos(43228) * 62;
+acc += Math.sin(43228) + Math.cos(43229) * 63;
+acc += Math.sin(43229) + Math.cos(43230) * 64;
+acc += Math.sin(43230) + Math.cos(43231) * 65;
+acc += Math.sin(43231) + Math.cos(43232) * 66;
+acc += Math.sin(43232) + Math.cos(43233) * 67;
+acc += Math.sin(43233) + Math.cos(43234) * 68;
+acc += Math.sin(43234) + Math.cos(43235) * 69;
+acc += Math.sin(43235) + Math.cos(43236) * 70;
+acc += Math.sin(43236) + Math.cos(43237) * 71;
+acc += Math.sin(43237) + Math.cos(43238) * 72;
+acc += Math.sin(43238) + Math.cos(43239) * 73;
+acc += Math.sin(43239) + Math.cos(43240) * 74;
+acc += Math.sin(43240) + Math.cos(43241) * 75;
+acc += Math.sin(43241) + Math.cos(43242) * 76;
+acc += Math.sin(43242) + Math.cos(43243) * 77;
+acc += Math.sin(43243) + Math.cos(43244) * 78;
+acc += Math.sin(43244) + Math.cos(43245) * 79;
+acc += Math.sin(43245) + Math.cos(43246) * 80;
+acc += Math.sin(43246) + Math.cos(43247) * 81;
+acc += Math.sin(43247) + Math.cos(43248) * 82;
+acc += Math.sin(43248) + Math.cos(43249) * 83;
+acc += Math.sin(43249) + Math.cos(43250) * 84;
+acc += Math.sin(43250) + Math.cos(43251) * 85;
+acc += Math.sin(43251) + Math.cos(43252) * 86;
+acc += Math.sin(43252) + Math.cos(43253) * 87;
+acc += Math.sin(43253) + Math.cos(43254) * 88;
+acc += Math.sin(43254) + Math.cos(43255) * 89;
+acc += Math.sin(43255) + Math.cos(43256) * 90;
+acc += Math.sin(43256) + Math.cos(43257) * 91;
+acc += Math.sin(43257) + Math.cos(43258) * 92;
+acc += Math.sin(43258) + Math.cos(43259) * 93;
+acc += Math.sin(43259) + Math.cos(43260) * 94;
+acc += Math.sin(43260) + Math.cos(43261) * 95;
+acc += Math.sin(43261) + Math.cos(43262) * 96;
+acc += Math.sin(43262) + Math.cos(43263) * 0;
+acc += Math.sin(43263) + Math.cos(43264) * 1;
+acc += Math.sin(43264) + Math.cos(43265) * 2;
+acc += Math.sin(43265) + Math.cos(43266) * 3;
+acc += Math.sin(43266) + Math.cos(43267) * 4;
+acc += Math.sin(43267) + Math.cos(43268) * 5;
+acc += Math.sin(43268) + Math.cos(43269) * 6;
+acc += Math.sin(43269) + Math.cos(43270) * 7;
+acc += Math.sin(43270) + Math.cos(43271) * 8;
+acc += Math.sin(43271) + Math.cos(43272) * 9;
+acc += Math.sin(43272) + Math.cos(43273) * 10;
+acc += Math.sin(43273) + Math.cos(43274) * 11;
+acc += Math.sin(43274) + Math.cos(43275) * 12;
+acc += Math.sin(43275) + Math.cos(43276) * 13;
+acc += Math.sin(43276) + Math.cos(43277) * 14;
+acc += Math.sin(43277) + Math.cos(43278) * 15;
+acc += Math.sin(43278) + Math.cos(43279) * 16;
+acc += Math.sin(43279) + Math.cos(43280) * 17;
+acc += Math.sin(43280) + Math.cos(43281) * 18;
+acc += Math.sin(43281) + Math.cos(43282) * 19;
+acc += Math.sin(43282) + Math.cos(43283) * 20;
+acc += Math.sin(43283) + Math.cos(43284) * 21;
+acc += Math.sin(43284) + Math.cos(43285) * 22;
+acc += Math.sin(43285) + Math.cos(43286) * 23;
+acc += Math.sin(43286) + Math.cos(43287) * 24;
+acc += Math.sin(43287) + Math.cos(43288) * 25;
+acc += Math.sin(43288) + Math.cos(43289) * 26;
+acc += Math.sin(43289) + Math.cos(43290) * 27;
+acc += Math.sin(43290) + Math.cos(43291) * 28;
+acc += Math.sin(43291) + Math.cos(43292) * 29;
+acc += Math.sin(43292) + Math.cos(43293) * 30;
+acc += Math.sin(43293) + Math.cos(43294) * 31;
+acc += Math.sin(43294) + Math.cos(43295) * 32;
+acc += Math.sin(43295) + Math.cos(43296) * 33;
+acc += Math.sin(43296) + Math.cos(43297) * 34;
+acc += Math.sin(43297) + Math.cos(43298) * 35;
+acc += Math.sin(43298) + Math.cos(43299) * 36;
+acc += Math.sin(43299) + Math.cos(43300) * 37;
+acc += Math.sin(43300) + Math.cos(43301) * 38;
+acc += Math.sin(43301) + Math.cos(43302) * 39;
+acc += Math.sin(43302) + Math.cos(43303) * 40;
+acc += Math.sin(43303) + Math.cos(43304) * 41;
+acc += Math.sin(43304) + Math.cos(43305) * 42;
+acc += Math.sin(43305) + Math.cos(43306) * 43;
+acc += Math.sin(43306) + Math.cos(43307) * 44;
+acc += Math.sin(43307) + Math.cos(43308) * 45;
+acc += Math.sin(43308) + Math.cos(43309) * 46;
+acc += Math.sin(43309) + Math.cos(43310) * 47;
+acc += Math.sin(43310) + Math.cos(43311) * 48;
+acc += Math.sin(43311) + Math.cos(43312) * 49;
+acc += Math.sin(43312) + Math.cos(43313) * 50;
+acc += Math.sin(43313) + Math.cos(43314) * 51;
+acc += Math.sin(43314) + Math.cos(43315) * 52;
+acc += Math.sin(43315) + Math.cos(43316) * 53;
+acc += Math.sin(43316) + Math.cos(43317) * 54;
+acc += Math.sin(43317) + Math.cos(43318) * 55;
+acc += Math.sin(43318) + Math.cos(43319) * 56;
+acc += Math.sin(43319) + Math.cos(43320) * 57;
+acc += Math.sin(43320) + Math.cos(43321) * 58;
+acc += Math.sin(43321) + Math.cos(43322) * 59;
+acc += Math.sin(43322) + Math.cos(43323) * 60;
+acc += Math.sin(43323) + Math.cos(43324) * 61;
+acc += Math.sin(43324) + Math.cos(43325) * 62;
+acc += Math.sin(43325) + Math.cos(43326) * 63;
+acc += Math.sin(43326) + Math.cos(43327) * 64;
+acc += Math.sin(43327) + Math.cos(43328) * 65;
+acc += Math.sin(43328) + Math.cos(43329) * 66;
+acc += Math.sin(43329) + Math.cos(43330) * 67;
+acc += Math.sin(43330) + Math.cos(43331) * 68;
+acc += Math.sin(43331) + Math.cos(43332) * 69;
+acc += Math.sin(43332) + Math.cos(43333) * 70;
+acc += Math.sin(43333) + Math.cos(43334) * 71;
+acc += Math.sin(43334) + Math.cos(43335) * 72;
+acc += Math.sin(43335) + Math.cos(43336) * 73;
+acc += Math.sin(43336) + Math.cos(43337) * 74;
+acc += Math.sin(43337) + Math.cos(43338) * 75;
+acc += Math.sin(43338) + Math.cos(43339) * 76;
+acc += Math.sin(43339) + Math.cos(43340) * 77;
+acc += Math.sin(43340) + Math.cos(43341) * 78;
+acc += Math.sin(43341) + Math.cos(43342) * 79;
+acc += Math.sin(43342) + Math.cos(43343) * 80;
+acc += Math.sin(43343) + Math.cos(43344) * 81;
+acc += Math.sin(43344) + Math.cos(43345) * 82;
+acc += Math.sin(43345) + Math.cos(43346) * 83;
+acc += Math.sin(43346) + Math.cos(43347) * 84;
+acc += Math.sin(43347) + Math.cos(43348) * 85;
+acc += Math.sin(43348) + Math.cos(43349) * 86;
+acc += Math.sin(43349) + Math.cos(43350) * 87;
+acc += Math.sin(43350) + Math.cos(43351) * 88;
+acc += Math.sin(43351) + Math.cos(43352) * 89;
+acc += Math.sin(43352) + Math.cos(43353) * 90;
+acc += Math.sin(43353) + Math.cos(43354) * 91;
+acc += Math.sin(43354) + Math.cos(43355) * 92;
+acc += Math.sin(43355) + Math.cos(43356) * 93;
+acc += Math.sin(43356) + Math.cos(43357) * 94;
+acc += Math.sin(43357) + Math.cos(43358) * 95;
+acc += Math.sin(43358) + Math.cos(43359) * 96;
+acc += Math.sin(43359) + Math.cos(43360) * 0;
+acc += Math.sin(43360) + Math.cos(43361) * 1;
+acc += Math.sin(43361) + Math.cos(43362) * 2;
+acc += Math.sin(43362) + Math.cos(43363) * 3;
+acc += Math.sin(43363) + Math.cos(43364) * 4;
+acc += Math.sin(43364) + Math.cos(43365) * 5;
+acc += Math.sin(43365) + Math.cos(43366) * 6;
+acc += Math.sin(43366) + Math.cos(43367) * 7;
+acc += Math.sin(43367) + Math.cos(43368) * 8;
+acc += Math.sin(43368) + Math.cos(43369) * 9;
+acc += Math.sin(43369) + Math.cos(43370) * 10;
+acc += Math.sin(43370) + Math.cos(43371) * 11;
+acc += Math.sin(43371) + Math.cos(43372) * 12;
+acc += Math.sin(43372) + Math.cos(43373) * 13;
+acc += Math.sin(43373) + Math.cos(43374) * 14;
+acc += Math.sin(43374) + Math.cos(43375) * 15;
+acc += Math.sin(43375) + Math.cos(43376) * 16;
+acc += Math.sin(43376) + Math.cos(43377) * 17;
+acc += Math.sin(43377) + Math.cos(43378) * 18;
+acc += Math.sin(43378) + Math.cos(43379) * 19;
+acc += Math.sin(43379) + Math.cos(43380) * 20;
+acc += Math.sin(43380) + Math.cos(43381) * 21;
+acc += Math.sin(43381) + Math.cos(43382) * 22;
+acc += Math.sin(43382) + Math.cos(43383) * 23;
+acc += Math.sin(43383) + Math.cos(43384) * 24;
+acc += Math.sin(43384) + Math.cos(43385) * 25;
+acc += Math.sin(43385) + Math.cos(43386) * 26;
+acc += Math.sin(43386) + Math.cos(43387) * 27;
+acc += Math.sin(43387) + Math.cos(43388) * 28;
+acc += Math.sin(43388) + Math.cos(43389) * 29;
+acc += Math.sin(43389) + Math.cos(43390) * 30;
+acc += Math.sin(43390) + Math.cos(43391) * 31;
+acc += Math.sin(43391) + Math.cos(43392) * 32;
+acc += Math.sin(43392) + Math.cos(43393) * 33;
+acc += Math.sin(43393) + Math.cos(43394) * 34;
+acc += Math.sin(43394) + Math.cos(43395) * 35;
+acc += Math.sin(43395) + Math.cos(43396) * 36;
+acc += Math.sin(43396) + Math.cos(43397) * 37;
+acc += Math.sin(43397) + Math.cos(43398) * 38;
+acc += Math.sin(43398) + Math.cos(43399) * 39;
+acc += Math.sin(43399) + Math.cos(43400) * 40;
+acc += Math.sin(43400) + Math.cos(43401) * 41;
+acc += Math.sin(43401) + Math.cos(43402) * 42;
+acc += Math.sin(43402) + Math.cos(43403) * 43;
+acc += Math.sin(43403) + Math.cos(43404) * 44;
+acc += Math.sin(43404) + Math.cos(43405) * 45;
+acc += Math.sin(43405) + Math.cos(43406) * 46;
+acc += Math.sin(43406) + Math.cos(43407) * 47;
+acc += Math.sin(43407) + Math.cos(43408) * 48;
+acc += Math.sin(43408) + Math.cos(43409) * 49;
+acc += Math.sin(43409) + Math.cos(43410) * 50;
+acc += Math.sin(43410) + Math.cos(43411) * 51;
+acc += Math.sin(43411) + Math.cos(43412) * 52;
+acc += Math.sin(43412) + Math.cos(43413) * 53;
+acc += Math.sin(43413) + Math.cos(43414) * 54;
+acc += Math.sin(43414) + Math.cos(43415) * 55;
+acc += Math.sin(43415) + Math.cos(43416) * 56;
+acc += Math.sin(43416) + Math.cos(43417) * 57;
+acc += Math.sin(43417) + Math.cos(43418) * 58;
+acc += Math.sin(43418) + Math.cos(43419) * 59;
+acc += Math.sin(43419) + Math.cos(43420) * 60;
+acc += Math.sin(43420) + Math.cos(43421) * 61;
+acc += Math.sin(43421) + Math.cos(43422) * 62;
+acc += Math.sin(43422) + Math.cos(43423) * 63;
+acc += Math.sin(43423) + Math.cos(43424) * 64;
+acc += Math.sin(43424) + Math.cos(43425) * 65;
+acc += Math.sin(43425) + Math.cos(43426) * 66;
+acc += Math.sin(43426) + Math.cos(43427) * 67;
+acc += Math.sin(43427) + Math.cos(43428) * 68;
+acc += Math.sin(43428) + Math.cos(43429) * 69;
+acc += Math.sin(43429) + Math.cos(43430) * 70;
+acc += Math.sin(43430) + Math.cos(43431) * 71;
+acc += Math.sin(43431) + Math.cos(43432) * 72;
+acc += Math.sin(43432) + Math.cos(43433) * 73;
+acc += Math.sin(43433) + Math.cos(43434) * 74;
+acc += Math.sin(43434) + Math.cos(43435) * 75;
+acc += Math.sin(43435) + Math.cos(43436) * 76;
+acc += Math.sin(43436) + Math.cos(43437) * 77;
+acc += Math.sin(43437) + Math.cos(43438) * 78;
+acc += Math.sin(43438) + Math.cos(43439) * 79;
+acc += Math.sin(43439) + Math.cos(43440) * 80;
+acc += Math.sin(43440) + Math.cos(43441) * 81;
+acc += Math.sin(43441) + Math.cos(43442) * 82;
+acc += Math.sin(43442) + Math.cos(43443) * 83;
+acc += Math.sin(43443) + Math.cos(43444) * 84;
+acc += Math.sin(43444) + Math.cos(43445) * 85;
+acc += Math.sin(43445) + Math.cos(43446) * 86;
+acc += Math.sin(43446) + Math.cos(43447) * 87;
+acc += Math.sin(43447) + Math.cos(43448) * 88;
+acc += Math.sin(43448) + Math.cos(43449) * 89;
+acc += Math.sin(43449) + Math.cos(43450) * 90;
+acc += Math.sin(43450) + Math.cos(43451) * 91;
+acc += Math.sin(43451) + Math.cos(43452) * 92;
+acc += Math.sin(43452) + Math.cos(43453) * 93;
+acc += Math.sin(43453) + Math.cos(43454) * 94;
+acc += Math.sin(43454) + Math.cos(43455) * 95;
+acc += Math.sin(43455) + Math.cos(43456) * 96;
+acc += Math.sin(43456) + Math.cos(43457) * 0;
+acc += Math.sin(43457) + Math.cos(43458) * 1;
+acc += Math.sin(43458) + Math.cos(43459) * 2;
+acc += Math.sin(43459) + Math.cos(43460) * 3;
+acc += Math.sin(43460) + Math.cos(43461) * 4;
+acc += Math.sin(43461) + Math.cos(43462) * 5;
+acc += Math.sin(43462) + Math.cos(43463) * 6;
+acc += Math.sin(43463) + Math.cos(43464) * 7;
+acc += Math.sin(43464) + Math.cos(43465) * 8;
+acc += Math.sin(43465) + Math.cos(43466) * 9;
+acc += Math.sin(43466) + Math.cos(43467) * 10;
+acc += Math.sin(43467) + Math.cos(43468) * 11;
+acc += Math.sin(43468) + Math.cos(43469) * 12;
+acc += Math.sin(43469) + Math.cos(43470) * 13;
+acc += Math.sin(43470) + Math.cos(43471) * 14;
+acc += Math.sin(43471) + Math.cos(43472) * 15;
+acc += Math.sin(43472) + Math.cos(43473) * 16;
+acc += Math.sin(43473) + Math.cos(43474) * 17;
+acc += Math.sin(43474) + Math.cos(43475) * 18;
+acc += Math.sin(43475) + Math.cos(43476) * 19;
+acc += Math.sin(43476) + Math.cos(43477) * 20;
+acc += Math.sin(43477) + Math.cos(43478) * 21;
+acc += Math.sin(43478) + Math.cos(43479) * 22;
+acc += Math.sin(43479) + Math.cos(43480) * 23;
+acc += Math.sin(43480) + Math.cos(43481) * 24;
+acc += Math.sin(43481) + Math.cos(43482) * 25;
+acc += Math.sin(43482) + Math.cos(43483) * 26;
+acc += Math.sin(43483) + Math.cos(43484) * 27;
+acc += Math.sin(43484) + Math.cos(43485) * 28;
+acc += Math.sin(43485) + Math.cos(43486) * 29;
+acc += Math.sin(43486) + Math.cos(43487) * 30;
+acc += Math.sin(43487) + Math.cos(43488) * 31;
+acc += Math.sin(43488) + Math.cos(43489) * 32;
+acc += Math.sin(43489) + Math.cos(43490) * 33;
+acc += Math.sin(43490) + Math.cos(43491) * 34;
+acc += Math.sin(43491) + Math.cos(43492) * 35;
+acc += Math.sin(43492) + Math.cos(43493) * 36;
+acc += Math.sin(43493) + Math.cos(43494) * 37;
+acc += Math.sin(43494) + Math.cos(43495) * 38;
+acc += Math.sin(43495) + Math.cos(43496) * 39;
+acc += Math.sin(43496) + Math.cos(43497) * 40;
+acc += Math.sin(43497) + Math.cos(43498) * 41;
+acc += Math.sin(43498) + Math.cos(43499) * 42;
+acc += Math.sin(43499) + Math.cos(43500) * 43;
+acc += Math.sin(43500) + Math.cos(43501) * 44;
+acc += Math.sin(43501) + Math.cos(43502) * 45;
+acc += Math.sin(43502) + Math.cos(43503) * 46;
+acc += Math.sin(43503) + Math.cos(43504) * 47;
+acc += Math.sin(43504) + Math.cos(43505) * 48;
+acc += Math.sin(43505) + Math.cos(43506) * 49;
+acc += Math.sin(43506) + Math.cos(43507) * 50;
+acc += Math.sin(43507) + Math.cos(43508) * 51;
+acc += Math.sin(43508) + Math.cos(43509) * 52;
+acc += Math.sin(43509) + Math.cos(43510) * 53;
+acc += Math.sin(43510) + Math.cos(43511) * 54;
+acc += Math.sin(43511) + Math.cos(43512) * 55;
+acc += Math.sin(43512) + Math.cos(43513) * 56;
+acc += Math.sin(43513) + Math.cos(43514) * 57;
+acc += Math.sin(43514) + Math.cos(43515) * 58;
+acc += Math.sin(43515) + Math.cos(43516) * 59;
+acc += Math.sin(43516) + Math.cos(43517) * 60;
+acc += Math.sin(43517) + Math.cos(43518) * 61;
+acc += Math.sin(43518) + Math.cos(43519) * 62;
+acc += Math.sin(43519) + Math.cos(43520) * 63;
+acc += Math.sin(43520) + Math.cos(43521) * 64;
+acc += Math.sin(43521) + Math.cos(43522) * 65;
+acc += Math.sin(43522) + Math.cos(43523) * 66;
+acc += Math.sin(43523) + Math.cos(43524) * 67;
+acc += Math.sin(43524) + Math.cos(43525) * 68;
+acc += Math.sin(43525) + Math.cos(43526) * 69;
+acc += Math.sin(43526) + Math.cos(43527) * 70;
+acc += Math.sin(43527) + Math.cos(43528) * 71;
+acc += Math.sin(43528) + Math.cos(43529) * 72;
+acc += Math.sin(43529) + Math.cos(43530) * 73;
+acc += Math.sin(43530) + Math.cos(43531) * 74;
+acc += Math.sin(43531) + Math.cos(43532) * 75;
+acc += Math.sin(43532) + Math.cos(43533) * 76;
+acc += Math.sin(43533) + Math.cos(43534) * 77;
+acc += Math.sin(43534) + Math.cos(43535) * 78;
+acc += Math.sin(43535) + Math.cos(43536) * 79;
+acc += Math.sin(43536) + Math.cos(43537) * 80;
+acc += Math.sin(43537) + Math.cos(43538) * 81;
+acc += Math.sin(43538) + Math.cos(43539) * 82;
+acc += Math.sin(43539) + Math.cos(43540) * 83;
+acc += Math.sin(43540) + Math.cos(43541) * 84;
+acc += Math.sin(43541) + Math.cos(43542) * 85;
+acc += Math.sin(43542) + Math.cos(43543) * 86;
+acc += Math.sin(43543) + Math.cos(43544) * 87;
+acc += Math.sin(43544) + Math.cos(43545) * 88;
+acc += Math.sin(43545) + Math.cos(43546) * 89;
+acc += Math.sin(43546) + Math.cos(43547) * 90;
+acc += Math.sin(43547) + Math.cos(43548) * 91;
+acc += Math.sin(43548) + Math.cos(43549) * 92;
+acc += Math.sin(43549) + Math.cos(43550) * 93;
+acc += Math.sin(43550) + Math.cos(43551) * 94;
+acc += Math.sin(43551) + Math.cos(43552) * 95;
+acc += Math.sin(43552) + Math.cos(43553) * 96;
+acc += Math.sin(43553) + Math.cos(43554) * 0;
+acc += Math.sin(43554) + Math.cos(43555) * 1;
+acc += Math.sin(43555) + Math.cos(43556) * 2;
+acc += Math.sin(43556) + Math.cos(43557) * 3;
+acc += Math.sin(43557) + Math.cos(43558) * 4;
+acc += Math.sin(43558) + Math.cos(43559) * 5;
+acc += Math.sin(43559) + Math.cos(43560) * 6;
+acc += Math.sin(43560) + Math.cos(43561) * 7;
+acc += Math.sin(43561) + Math.cos(43562) * 8;
+acc += Math.sin(43562) + Math.cos(43563) * 9;
+acc += Math.sin(43563) + Math.cos(43564) * 10;
+acc += Math.sin(43564) + Math.cos(43565) * 11;
+acc += Math.sin(43565) + Math.cos(43566) * 12;
+acc += Math.sin(43566) + Math.cos(43567) * 13;
+acc += Math.sin(43567) + Math.cos(43568) * 14;
+acc += Math.sin(43568) + Math.cos(43569) * 15;
+acc += Math.sin(43569) + Math.cos(43570) * 16;
+acc += Math.sin(43570) + Math.cos(43571) * 17;
+acc += Math.sin(43571) + Math.cos(43572) * 18;
+acc += Math.sin(43572) + Math.cos(43573) * 19;
+acc += Math.sin(43573) + Math.cos(43574) * 20;
+acc += Math.sin(43574) + Math.cos(43575) * 21;
+acc += Math.sin(43575) + Math.cos(43576) * 22;
+acc += Math.sin(43576) + Math.cos(43577) * 23;
+acc += Math.sin(43577) + Math.cos(43578) * 24;
+acc += Math.sin(43578) + Math.cos(43579) * 25;
+acc += Math.sin(43579) + Math.cos(43580) * 26;
+acc += Math.sin(43580) + Math.cos(43581) * 27;
+acc += Math.sin(43581) + Math.cos(43582) * 28;
+acc += Math.sin(43582) + Math.cos(43583) * 29;
+acc += Math.sin(43583) + Math.cos(43584) * 30;
+acc += Math.sin(43584) + Math.cos(43585) * 31;
+acc += Math.sin(43585) + Math.cos(43586) * 32;
+acc += Math.sin(43586) + Math.cos(43587) * 33;
+acc += Math.sin(43587) + Math.cos(43588) * 34;
+acc += Math.sin(43588) + Math.cos(43589) * 35;
+acc += Math.sin(43589) + Math.cos(43590) * 36;
+acc += Math.sin(43590) + Math.cos(43591) * 37;
+acc += Math.sin(43591) + Math.cos(43592) * 38;
+acc += Math.sin(43592) + Math.cos(43593) * 39;
+acc += Math.sin(43593) + Math.cos(43594) * 40;
+acc += Math.sin(43594) + Math.cos(43595) * 41;
+acc += Math.sin(43595) + Math.cos(43596) * 42;
+acc += Math.sin(43596) + Math.cos(43597) * 43;
+acc += Math.sin(43597) + Math.cos(43598) * 44;
+acc += Math.sin(43598) + Math.cos(43599) * 45;
+acc += Math.sin(43599) + Math.cos(43600) * 46;
+acc += Math.sin(43600) + Math.cos(43601) * 47;
+acc += Math.sin(43601) + Math.cos(43602) * 48;
+acc += Math.sin(43602) + Math.cos(43603) * 49;
+acc += Math.sin(43603) + Math.cos(43604) * 50;
+acc += Math.sin(43604) + Math.cos(43605) * 51;
+acc += Math.sin(43605) + Math.cos(43606) * 52;
+acc += Math.sin(43606) + Math.cos(43607) * 53;
+acc += Math.sin(43607) + Math.cos(43608) * 54;
+acc += Math.sin(43608) + Math.cos(43609) * 55;
+acc += Math.sin(43609) + Math.cos(43610) * 56;
+acc += Math.sin(43610) + Math.cos(43611) * 57;
+acc += Math.sin(43611) + Math.cos(43612) * 58;
+acc += Math.sin(43612) + Math.cos(43613) * 59;
+acc += Math.sin(43613) + Math.cos(43614) * 60;
+acc += Math.sin(43614) + Math.cos(43615) * 61;
+acc += Math.sin(43615) + Math.cos(43616) * 62;
+acc += Math.sin(43616) + Math.cos(43617) * 63;
+acc += Math.sin(43617) + Math.cos(43618) * 64;
+acc += Math.sin(43618) + Math.cos(43619) * 65;
+acc += Math.sin(43619) + Math.cos(43620) * 66;
+acc += Math.sin(43620) + Math.cos(43621) * 67;
+acc += Math.sin(43621) + Math.cos(43622) * 68;
+acc += Math.sin(43622) + Math.cos(43623) * 69;
+acc += Math.sin(43623) + Math.cos(43624) * 70;
+acc += Math.sin(43624) + Math.cos(43625) * 71;
+acc += Math.sin(43625) + Math.cos(43626) * 72;
+acc += Math.sin(43626) + Math.cos(43627) * 73;
+acc += Math.sin(43627) + Math.cos(43628) * 74;
+acc += Math.sin(43628) + Math.cos(43629) * 75;
+acc += Math.sin(43629) + Math.cos(43630) * 76;
+acc += Math.sin(43630) + Math.cos(43631) * 77;
+acc += Math.sin(43631) + Math.cos(43632) * 78;
+acc += Math.sin(43632) + Math.cos(43633) * 79;
+acc += Math.sin(43633) + Math.cos(43634) * 80;
+acc += Math.sin(43634) + Math.cos(43635) * 81;
+acc += Math.sin(43635) + Math.cos(43636) * 82;
+acc += Math.sin(43636) + Math.cos(43637) * 83;
+acc += Math.sin(43637) + Math.cos(43638) * 84;
+acc += Math.sin(43638) + Math.cos(43639) * 85;
+acc += Math.sin(43639) + Math.cos(43640) * 86;
+acc += Math.sin(43640) + Math.cos(43641) * 87;
+acc += Math.sin(43641) + Math.cos(43642) * 88;
+acc += Math.sin(43642) + Math.cos(43643) * 89;
+acc += Math.sin(43643) + Math.cos(43644) * 90;
+acc += Math.sin(43644) + Math.cos(43645) * 91;
+acc += Math.sin(43645) + Math.cos(43646) * 92;
+acc += Math.sin(43646) + Math.cos(43647) * 93;
+acc += Math.sin(43647) + Math.cos(43648) * 94;
+acc += Math.sin(43648) + Math.cos(43649) * 95;
+acc += Math.sin(43649) + Math.cos(43650) * 96;
+acc += Math.sin(43650) + Math.cos(43651) * 0;
+acc += Math.sin(43651) + Math.cos(43652) * 1;
+acc += Math.sin(43652) + Math.cos(43653) * 2;
+acc += Math.sin(43653) + Math.cos(43654) * 3;
+acc += Math.sin(43654) + Math.cos(43655) * 4;
+acc += Math.sin(43655) + Math.cos(43656) * 5;
+acc += Math.sin(43656) + Math.cos(43657) * 6;
+acc += Math.sin(43657) + Math.cos(43658) * 7;
+acc += Math.sin(43658) + Math.cos(43659) * 8;
+acc += Math.sin(43659) + Math.cos(43660) * 9;
+acc += Math.sin(43660) + Math.cos(43661) * 10;
+acc += Math.sin(43661) + Math.cos(43662) * 11;
+acc += Math.sin(43662) + Math.cos(43663) * 12;
+acc += Math.sin(43663) + Math.cos(43664) * 13;
+acc += Math.sin(43664) + Math.cos(43665) * 14;
+acc += Math.sin(43665) + Math.cos(43666) * 15;
+acc += Math.sin(43666) + Math.cos(43667) * 16;
+acc += Math.sin(43667) + Math.cos(43668) * 17;
+acc += Math.sin(43668) + Math.cos(43669) * 18;
+acc += Math.sin(43669) + Math.cos(43670) * 19;
+acc += Math.sin(43670) + Math.cos(43671) * 20;
+acc += Math.sin(43671) + Math.cos(43672) * 21;
+acc += Math.sin(43672) + Math.cos(43673) * 22;
+acc += Math.sin(43673) + Math.cos(43674) * 23;
+acc += Math.sin(43674) + Math.cos(43675) * 24;
+acc += Math.sin(43675) + Math.cos(43676) * 25;
+acc += Math.sin(43676) + Math.cos(43677) * 26;
+acc += Math.sin(43677) + Math.cos(43678) * 27;
+acc += Math.sin(43678) + Math.cos(43679) * 28;
+acc += Math.sin(43679) + Math.cos(43680) * 29;
+acc += Math.sin(43680) + Math.cos(43681) * 30;
+acc += Math.sin(43681) + Math.cos(43682) * 31;
+acc += Math.sin(43682) + Math.cos(43683) * 32;
+acc += Math.sin(43683) + Math.cos(43684) * 33;
+acc += Math.sin(43684) + Math.cos(43685) * 34;
+acc += Math.sin(43685) + Math.cos(43686) * 35;
+acc += Math.sin(43686) + Math.cos(43687) * 36;
+acc += Math.sin(43687) + Math.cos(43688) * 37;
+acc += Math.sin(43688) + Math.cos(43689) * 38;
+acc += Math.sin(43689) + Math.cos(43690) * 39;
+acc += Math.sin(43690) + Math.cos(43691) * 40;
+acc += Math.sin(43691) + Math.cos(43692) * 41;
+acc += Math.sin(43692) + Math.cos(43693) * 42;
+acc += Math.sin(43693) + Math.cos(43694) * 43;
+acc += Math.sin(43694) + Math.cos(43695) * 44;
+acc += Math.sin(43695) + Math.cos(43696) * 45;
+acc += Math.sin(43696) + Math.cos(43697) * 46;
+acc += Math.sin(43697) + Math.cos(43698) * 47;
+acc += Math.sin(43698) + Math.cos(43699) * 48;
+acc += Math.sin(43699) + Math.cos(43700) * 49;
+acc += Math.sin(43700) + Math.cos(43701) * 50;
+acc += Math.sin(43701) + Math.cos(43702) * 51;
+acc += Math.sin(43702) + Math.cos(43703) * 52;
+acc += Math.sin(43703) + Math.cos(43704) * 53;
+acc += Math.sin(43704) + Math.cos(43705) * 54;
+acc += Math.sin(43705) + Math.cos(43706) * 55;
+acc += Math.sin(43706) + Math.cos(43707) * 56;
+acc += Math.sin(43707) + Math.cos(43708) * 57;
+acc += Math.sin(43708) + Math.cos(43709) * 58;
+acc += Math.sin(43709) + Math.cos(43710) * 59;
+acc += Math.sin(43710) + Math.cos(43711) * 60;
+acc += Math.sin(43711) + Math.cos(43712) * 61;
+acc += Math.sin(43712) + Math.cos(43713) * 62;
+acc += Math.sin(43713) + Math.cos(43714) * 63;
+acc += Math.sin(43714) + Math.cos(43715) * 64;
+acc += Math.sin(43715) + Math.cos(43716) * 65;
+acc += Math.sin(43716) + Math.cos(43717) * 66;
+acc += Math.sin(43717) + Math.cos(43718) * 67;
+acc += Math.sin(43718) + Math.cos(43719) * 68;
+acc += Math.sin(43719) + Math.cos(43720) * 69;
+acc += Math.sin(43720) + Math.cos(43721) * 70;
+acc += Math.sin(43721) + Math.cos(43722) * 71;
+acc += Math.sin(43722) + Math.cos(43723) * 72;
+acc += Math.sin(43723) + Math.cos(43724) * 73;
+acc += Math.sin(43724) + Math.cos(43725) * 74;
+acc += Math.sin(43725) + Math.cos(43726) * 75;
+acc += Math.sin(43726) + Math.cos(43727) * 76;
+acc += Math.sin(43727) + Math.cos(43728) * 77;
+acc += Math.sin(43728) + Math.cos(43729) * 78;
+acc += Math.sin(43729) + Math.cos(43730) * 79;
+acc += Math.sin(43730) + Math.cos(43731) * 80;
+acc += Math.sin(43731) + Math.cos(43732) * 81;
+acc += Math.sin(43732) + Math.cos(43733) * 82;
+acc += Math.sin(43733) + Math.cos(43734) * 83;
+acc += Math.sin(43734) + Math.cos(43735) * 84;
+acc += Math.sin(43735) + Math.cos(43736) * 85;
+acc += Math.sin(43736) + Math.cos(43737) * 86;
+acc += Math.sin(43737) + Math.cos(43738) * 87;
+acc += Math.sin(43738) + Math.cos(43739) * 88;
+acc += Math.sin(43739) + Math.cos(43740) * 89;
+acc += Math.sin(43740) + Math.cos(43741) * 90;
+acc += Math.sin(43741) + Math.cos(43742) * 91;
+acc += Math.sin(43742) + Math.cos(43743) * 92;
+acc += Math.sin(43743) + Math.cos(43744) * 93;
+acc += Math.sin(43744) + Math.cos(43745) * 94;
+acc += Math.sin(43745) + Math.cos(43746) * 95;
+acc += Math.sin(43746) + Math.cos(43747) * 96;
+acc += Math.sin(43747) + Math.cos(43748) * 0;
+acc += Math.sin(43748) + Math.cos(43749) * 1;
+acc += Math.sin(43749) + Math.cos(43750) * 2;
+acc += Math.sin(43750) + Math.cos(43751) * 3;
+acc += Math.sin(43751) + Math.cos(43752) * 4;
+acc += Math.sin(43752) + Math.cos(43753) * 5;
+acc += Math.sin(43753) + Math.cos(43754) * 6;
+acc += Math.sin(43754) + Math.cos(43755) * 7;
+acc += Math.sin(43755) + Math.cos(43756) * 8;
+acc += Math.sin(43756) + Math.cos(43757) * 9;
+acc += Math.sin(43757) + Math.cos(43758) * 10;
+acc += Math.sin(43758) + Math.cos(43759) * 11;
+acc += Math.sin(43759) + Math.cos(43760) * 12;
+acc += Math.sin(43760) + Math.cos(43761) * 13;
+acc += Math.sin(43761) + Math.cos(43762) * 14;
+acc += Math.sin(43762) + Math.cos(43763) * 15;
+acc += Math.sin(43763) + Math.cos(43764) * 16;
+acc += Math.sin(43764) + Math.cos(43765) * 17;
+acc += Math.sin(43765) + Math.cos(43766) * 18;
+acc += Math.sin(43766) + Math.cos(43767) * 19;
+acc += Math.sin(43767) + Math.cos(43768) * 20;
+acc += Math.sin(43768) + Math.cos(43769) * 21;
+acc += Math.sin(43769) + Math.cos(43770) * 22;
+acc += Math.sin(43770) + Math.cos(43771) * 23;
+acc += Math.sin(43771) + Math.cos(43772) * 24;
+acc += Math.sin(43772) + Math.cos(43773) * 25;
+acc += Math.sin(43773) + Math.cos(43774) * 26;
+acc += Math.sin(43774) + Math.cos(43775) * 27;
+acc += Math.sin(43775) + Math.cos(43776) * 28;
+acc += Math.sin(43776) + Math.cos(43777) * 29;
+acc += Math.sin(43777) + Math.cos(43778) * 30;
+acc += Math.sin(43778) + Math.cos(43779) * 31;
+acc += Math.sin(43779) + Math.cos(43780) * 32;
+acc += Math.sin(43780) + Math.cos(43781) * 33;
+acc += Math.sin(43781) + Math.cos(43782) * 34;
+acc += Math.sin(43782) + Math.cos(43783) * 35;
+acc += Math.sin(43783) + Math.cos(43784) * 36;
+acc += Math.sin(43784) + Math.cos(43785) * 37;
+acc += Math.sin(43785) + Math.cos(43786) * 38;
+acc += Math.sin(43786) + Math.cos(43787) * 39;
+acc += Math.sin(43787) + Math.cos(43788) * 40;
+acc += Math.sin(43788) + Math.cos(43789) * 41;
+acc += Math.sin(43789) + Math.cos(43790) * 42;
+acc += Math.sin(43790) + Math.cos(43791) * 43;
+acc += Math.sin(43791) + Math.cos(43792) * 44;
+acc += Math.sin(43792) + Math.cos(43793) * 45;
+acc += Math.sin(43793) + Math.cos(43794) * 46;
+acc += Math.sin(43794) + Math.cos(43795) * 47;
+acc += Math.sin(43795) + Math.cos(43796) * 48;
+acc += Math.sin(43796) + Math.cos(43797) * 49;
+acc += Math.sin(43797) + Math.cos(43798) * 50;
+acc += Math.sin(43798) + Math.cos(43799) * 51;
+acc += Math.sin(43799) + Math.cos(43800) * 52;
+acc += Math.sin(43800) + Math.cos(43801) * 53;
+acc += Math.sin(43801) + Math.cos(43802) * 54;
+acc += Math.sin(43802) + Math.cos(43803) * 55;
+acc += Math.sin(43803) + Math.cos(43804) * 56;
+acc += Math.sin(43804) + Math.cos(43805) * 57;
+acc += Math.sin(43805) + Math.cos(43806) * 58;
+acc += Math.sin(43806) + Math.cos(43807) * 59;
+acc += Math.sin(43807) + Math.cos(43808) * 60;
+acc += Math.sin(43808) + Math.cos(43809) * 61;
+acc += Math.sin(43809) + Math.cos(43810) * 62;
+acc += Math.sin(43810) + Math.cos(43811) * 63;
+acc += Math.sin(43811) + Math.cos(43812) * 64;
+acc += Math.sin(43812) + Math.cos(43813) * 65;
+acc += Math.sin(43813) + Math.cos(43814) * 66;
+acc += Math.sin(43814) + Math.cos(43815) * 67;
+acc += Math.sin(43815) + Math.cos(43816) * 68;
+acc += Math.sin(43816) + Math.cos(43817) * 69;
+acc += Math.sin(43817) + Math.cos(43818) * 70;
+acc += Math.sin(43818) + Math.cos(43819) * 71;
+acc += Math.sin(43819) + Math.cos(43820) * 72;
+acc += Math.sin(43820) + Math.cos(43821) * 73;
+acc += Math.sin(43821) + Math.cos(43822) * 74;
+acc += Math.sin(43822) + Math.cos(43823) * 75;
+acc += Math.sin(43823) + Math.cos(43824) * 76;
+acc += Math.sin(43824) + Math.cos(43825) * 77;
+acc += Math.sin(43825) + Math.cos(43826) * 78;
+acc += Math.sin(43826) + Math.cos(43827) * 79;
+acc += Math.sin(43827) + Math.cos(43828) * 80;
+acc += Math.sin(43828) + Math.cos(43829) * 81;
+acc += Math.sin(43829) + Math.cos(43830) * 82;
+acc += Math.sin(43830) + Math.cos(43831) * 83;
+acc += Math.sin(43831) + Math.cos(43832) * 84;
+acc += Math.sin(43832) + Math.cos(43833) * 85;
+acc += Math.sin(43833) + Math.cos(43834) * 86;
+acc += Math.sin(43834) + Math.cos(43835) * 87;
+acc += Math.sin(43835) + Math.cos(43836) * 88;
+acc += Math.sin(43836) + Math.cos(43837) * 89;
+acc += Math.sin(43837) + Math.cos(43838) * 90;
+acc += Math.sin(43838) + Math.cos(43839) * 91;
+acc += Math.sin(43839) + Math.cos(43840) * 92;
+acc += Math.sin(43840) + Math.cos(43841) * 93;
+acc += Math.sin(43841) + Math.cos(43842) * 94;
+acc += Math.sin(43842) + Math.cos(43843) * 95;
+acc += Math.sin(43843) + Math.cos(43844) * 96;
+acc += Math.sin(43844) + Math.cos(43845) * 0;
+acc += Math.sin(43845) + Math.cos(43846) * 1;
+acc += Math.sin(43846) + Math.cos(43847) * 2;
+acc += Math.sin(43847) + Math.cos(43848) * 3;
+acc += Math.sin(43848) + Math.cos(43849) * 4;
+acc += Math.sin(43849) + Math.cos(43850) * 5;
+acc += Math.sin(43850) + Math.cos(43851) * 6;
+acc += Math.sin(43851) + Math.cos(43852) * 7;
+acc += Math.sin(43852) + Math.cos(43853) * 8;
+acc += Math.sin(43853) + Math.cos(43854) * 9;
+acc += Math.sin(43854) + Math.cos(43855) * 10;
+acc += Math.sin(43855) + Math.cos(43856) * 11;
+acc += Math.sin(43856) + Math.cos(43857) * 12;
+acc += Math.sin(43857) + Math.cos(43858) * 13;
+acc += Math.sin(43858) + Math.cos(43859) * 14;
+acc += Math.sin(43859) + Math.cos(43860) * 15;
+acc += Math.sin(43860) + Math.cos(43861) * 16;
+acc += Math.sin(43861) + Math.cos(43862) * 17;
+acc += Math.sin(43862) + Math.cos(43863) * 18;
+acc += Math.sin(43863) + Math.cos(43864) * 19;
+acc += Math.sin(43864) + Math.cos(43865) * 20;
+acc += Math.sin(43865) + Math.cos(43866) * 21;
+acc += Math.sin(43866) + Math.cos(43867) * 22;
+acc += Math.sin(43867) + Math.cos(43868) * 23;
+acc += Math.sin(43868) + Math.cos(43869) * 24;
+acc += Math.sin(43869) + Math.cos(43870) * 25;
+acc += Math.sin(43870) + Math.cos(43871) * 26;
+acc += Math.sin(43871) + Math.cos(43872) * 27;
+acc += Math.sin(43872) + Math.cos(43873) * 28;
+acc += Math.sin(43873) + Math.cos(43874) * 29;
+acc += Math.sin(43874) + Math.cos(43875) * 30;
+acc += Math.sin(43875) + Math.cos(43876) * 31;
+acc += Math.sin(43876) + Math.cos(43877) * 32;
+acc += Math.sin(43877) + Math.cos(43878) * 33;
+acc += Math.sin(43878) + Math.cos(43879) * 34;
+acc += Math.sin(43879) + Math.cos(43880) * 35;
+acc += Math.sin(43880) + Math.cos(43881) * 36;
+acc += Math.sin(43881) + Math.cos(43882) * 37;
+acc += Math.sin(43882) + Math.cos(43883) * 38;
+acc += Math.sin(43883) + Math.cos(43884) * 39;
+acc += Math.sin(43884) + Math.cos(43885) * 40;
+acc += Math.sin(43885) + Math.cos(43886) * 41;
+acc += Math.sin(43886) + Math.cos(43887) * 42;
+acc += Math.sin(43887) + Math.cos(43888) * 43;
+acc += Math.sin(43888) + Math.cos(43889) * 44;
+acc += Math.sin(43889) + Math.cos(43890) * 45;
+acc += Math.sin(43890) + Math.cos(43891) * 46;
+acc += Math.sin(43891) + Math.cos(43892) * 47;
+acc += Math.sin(43892) + Math.cos(43893) * 48;
+acc += Math.sin(43893) + Math.cos(43894) * 49;
+acc += Math.sin(43894) + Math.cos(43895) * 50;
+acc += Math.sin(43895) + Math.cos(43896) * 51;
+acc += Math.sin(43896) + Math.cos(43897) * 52;
+acc += Math.sin(43897) + Math.cos(43898) * 53;
+acc += Math.sin(43898) + Math.cos(43899) * 54;
+acc += Math.sin(43899) + Math.cos(43900) * 55;
+acc += Math.sin(43900) + Math.cos(43901) * 56;
+acc += Math.sin(43901) + Math.cos(43902) * 57;
+acc += Math.sin(43902) + Math.cos(43903) * 58;
+acc += Math.sin(43903) + Math.cos(43904) * 59;
+acc += Math.sin(43904) + Math.cos(43905) * 60;
+acc += Math.sin(43905) + Math.cos(43906) * 61;
+acc += Math.sin(43906) + Math.cos(43907) * 62;
+acc += Math.sin(43907) + Math.cos(43908) * 63;
+acc += Math.sin(43908) + Math.cos(43909) * 64;
+acc += Math.sin(43909) + Math.cos(43910) * 65;
+acc += Math.sin(43910) + Math.cos(43911) * 66;
+acc += Math.sin(43911) + Math.cos(43912) * 67;
+acc += Math.sin(43912) + Math.cos(43913) * 68;
+acc += Math.sin(43913) + Math.cos(43914) * 69;
+acc += Math.sin(43914) + Math.cos(43915) * 70;
+acc += Math.sin(43915) + Math.cos(43916) * 71;
+acc += Math.sin(43916) + Math.cos(43917) * 72;
+acc += Math.sin(43917) + Math.cos(43918) * 73;
+acc += Math.sin(43918) + Math.cos(43919) * 74;
+acc += Math.sin(43919) + Math.cos(43920) * 75;
+acc += Math.sin(43920) + Math.cos(43921) * 76;
+acc += Math.sin(43921) + Math.cos(43922) * 77;
+acc += Math.sin(43922) + Math.cos(43923) * 78;
+acc += Math.sin(43923) + Math.cos(43924) * 79;
+acc += Math.sin(43924) + Math.cos(43925) * 80;
+acc += Math.sin(43925) + Math.cos(43926) * 81;
+acc += Math.sin(43926) + Math.cos(43927) * 82;
+acc += Math.sin(43927) + Math.cos(43928) * 83;
+acc += Math.sin(43928) + Math.cos(43929) * 84;
+acc += Math.sin(43929) + Math.cos(43930) * 85;
+acc += Math.sin(43930) + Math.cos(43931) * 86;
+acc += Math.sin(43931) + Math.cos(43932) * 87;
+acc += Math.sin(43932) + Math.cos(43933) * 88;
+acc += Math.sin(43933) + Math.cos(43934) * 89;
+acc += Math.sin(43934) + Math.cos(43935) * 90;
+acc += Math.sin(43935) + Math.cos(43936) * 91;
+acc += Math.sin(43936) + Math.cos(43937) * 92;
+acc += Math.sin(43937) + Math.cos(43938) * 93;
+acc += Math.sin(43938) + Math.cos(43939) * 94;
+acc += Math.sin(43939) + Math.cos(43940) * 95;
+acc += Math.sin(43940) + Math.cos(43941) * 96;
+acc += Math.sin(43941) + Math.cos(43942) * 0;
+acc += Math.sin(43942) + Math.cos(43943) * 1;
+acc += Math.sin(43943) + Math.cos(43944) * 2;
+acc += Math.sin(43944) + Math.cos(43945) * 3;
+acc += Math.sin(43945) + Math.cos(43946) * 4;
+acc += Math.sin(43946) + Math.cos(43947) * 5;
+acc += Math.sin(43947) + Math.cos(43948) * 6;
+acc += Math.sin(43948) + Math.cos(43949) * 7;
+acc += Math.sin(43949) + Math.cos(43950) * 8;
+acc += Math.sin(43950) + Math.cos(43951) * 9;
+acc += Math.sin(43951) + Math.cos(43952) * 10;
+acc += Math.sin(43952) + Math.cos(43953) * 11;
+acc += Math.sin(43953) + Math.cos(43954) * 12;
+acc += Math.sin(43954) + Math.cos(43955) * 13;
+acc += Math.sin(43955) + Math.cos(43956) * 14;
+acc += Math.sin(43956) + Math.cos(43957) * 15;
+acc += Math.sin(43957) + Math.cos(43958) * 16;
+acc += Math.sin(43958) + Math.cos(43959) * 17;
+acc += Math.sin(43959) + Math.cos(43960) * 18;
+acc += Math.sin(43960) + Math.cos(43961) * 19;
+acc += Math.sin(43961) + Math.cos(43962) * 20;
+acc += Math.sin(43962) + Math.cos(43963) * 21;
+acc += Math.sin(43963) + Math.cos(43964) * 22;
+acc += Math.sin(43964) + Math.cos(43965) * 23;
+acc += Math.sin(43965) + Math.cos(43966) * 24;
+acc += Math.sin(43966) + Math.cos(43967) * 25;
+acc += Math.sin(43967) + Math.cos(43968) * 26;
+acc += Math.sin(43968) + Math.cos(43969) * 27;
+acc += Math.sin(43969) + Math.cos(43970) * 28;
+acc += Math.sin(43970) + Math.cos(43971) * 29;
+acc += Math.sin(43971) + Math.cos(43972) * 30;
+acc += Math.sin(43972) + Math.cos(43973) * 31;
+acc += Math.sin(43973) + Math.cos(43974) * 32;
+acc += Math.sin(43974) + Math.cos(43975) * 33;
+acc += Math.sin(43975) + Math.cos(43976) * 34;
+acc += Math.sin(43976) + Math.cos(43977) * 35;
+acc += Math.sin(43977) + Math.cos(43978) * 36;
+acc += Math.sin(43978) + Math.cos(43979) * 37;
+acc += Math.sin(43979) + Math.cos(43980) * 38;
+acc += Math.sin(43980) + Math.cos(43981) * 39;
+acc += Math.sin(43981) + Math.cos(43982) * 40;
+acc += Math.sin(43982) + Math.cos(43983) * 41;
+acc += Math.sin(43983) + Math.cos(43984) * 42;
+acc += Math.sin(43984) + Math.cos(43985) * 43;
+acc += Math.sin(43985) + Math.cos(43986) * 44;
+acc += Math.sin(43986) + Math.cos(43987) * 45;
+acc += Math.sin(43987) + Math.cos(43988) * 46;
+acc += Math.sin(43988) + Math.cos(43989) * 47;
+acc += Math.sin(43989) + Math.cos(43990) * 48;
+acc += Math.sin(43990) + Math.cos(43991) * 49;
+acc += Math.sin(43991) + Math.cos(43992) * 50;
+acc += Math.sin(43992) + Math.cos(43993) * 51;
+acc += Math.sin(43993) + Math.cos(43994) * 52;
+acc += Math.sin(43994) + Math.cos(43995) * 53;
+acc += Math.sin(43995) + Math.cos(43996) * 54;
+acc += Math.sin(43996) + Math.cos(43997) * 55;
+acc += Math.sin(43997) + Math.cos(43998) * 56;
+acc += Math.sin(43998) + Math.cos(43999) * 57;
+acc += Math.sin(43999) + Math.cos(44000) * 58;
+acc += Math.sin(44000) + Math.cos(44001) * 59;
+acc += Math.sin(44001) + Math.cos(44002) * 60;
+acc += Math.sin(44002) + Math.cos(44003) * 61;
+acc += Math.sin(44003) + Math.cos(44004) * 62;
+acc += Math.sin(44004) + Math.cos(44005) * 63;
+acc += Math.sin(44005) + Math.cos(44006) * 64;
+acc += Math.sin(44006) + Math.cos(44007) * 65;
+acc += Math.sin(44007) + Math.cos(44008) * 66;
+acc += Math.sin(44008) + Math.cos(44009) * 67;
+acc += Math.sin(44009) + Math.cos(44010) * 68;
+acc += Math.sin(44010) + Math.cos(44011) * 69;
+acc += Math.sin(44011) + Math.cos(44012) * 70;
+acc += Math.sin(44012) + Math.cos(44013) * 71;
+acc += Math.sin(44013) + Math.cos(44014) * 72;
+acc += Math.sin(44014) + Math.cos(44015) * 73;
+acc += Math.sin(44015) + Math.cos(44016) * 74;
+acc += Math.sin(44016) + Math.cos(44017) * 75;
+acc += Math.sin(44017) + Math.cos(44018) * 76;
+acc += Math.sin(44018) + Math.cos(44019) * 77;
+acc += Math.sin(44019) + Math.cos(44020) * 78;
+acc += Math.sin(44020) + Math.cos(44021) * 79;
+acc += Math.sin(44021) + Math.cos(44022) * 80;
+acc += Math.sin(44022) + Math.cos(44023) * 81;
+acc += Math.sin(44023) + Math.cos(44024) * 82;
+acc += Math.sin(44024) + Math.cos(44025) * 83;
+acc += Math.sin(44025) + Math.cos(44026) * 84;
+acc += Math.sin(44026) + Math.cos(44027) * 85;
+acc += Math.sin(44027) + Math.cos(44028) * 86;
+acc += Math.sin(44028) + Math.cos(44029) * 87;
+acc += Math.sin(44029) + Math.cos(44030) * 88;
+acc += Math.sin(44030) + Math.cos(44031) * 89;
+acc += Math.sin(44031) + Math.cos(44032) * 90;
+acc += Math.sin(44032) + Math.cos(44033) * 91;
+acc += Math.sin(44033) + Math.cos(44034) * 92;
+acc += Math.sin(44034) + Math.cos(44035) * 93;
+acc += Math.sin(44035) + Math.cos(44036) * 94;
+acc += Math.sin(44036) + Math.cos(44037) * 95;
+acc += Math.sin(44037) + Math.cos(44038) * 96;
+acc += Math.sin(44038) + Math.cos(44039) * 0;
+acc += Math.sin(44039) + Math.cos(44040) * 1;
+acc += Math.sin(44040) + Math.cos(44041) * 2;
+acc += Math.sin(44041) + Math.cos(44042) * 3;
+acc += Math.sin(44042) + Math.cos(44043) * 4;
+acc += Math.sin(44043) + Math.cos(44044) * 5;
+acc += Math.sin(44044) + Math.cos(44045) * 6;
+acc += Math.sin(44045) + Math.cos(44046) * 7;
+acc += Math.sin(44046) + Math.cos(44047) * 8;
+acc += Math.sin(44047) + Math.cos(44048) * 9;
+acc += Math.sin(44048) + Math.cos(44049) * 10;
+acc += Math.sin(44049) + Math.cos(44050) * 11;
+acc += Math.sin(44050) + Math.cos(44051) * 12;
+acc += Math.sin(44051) + Math.cos(44052) * 13;
+acc += Math.sin(44052) + Math.cos(44053) * 14;
+acc += Math.sin(44053) + Math.cos(44054) * 15;
+acc += Math.sin(44054) + Math.cos(44055) * 16;
+acc += Math.sin(44055) + Math.cos(44056) * 17;
+acc += Math.sin(44056) + Math.cos(44057) * 18;
+acc += Math.sin(44057) + Math.cos(44058) * 19;
+acc += Math.sin(44058) + Math.cos(44059) * 20;
+acc += Math.sin(44059) + Math.cos(44060) * 21;
+acc += Math.sin(44060) + Math.cos(44061) * 22;
+acc += Math.sin(44061) + Math.cos(44062) * 23;
+acc += Math.sin(44062) + Math.cos(44063) * 24;
+acc += Math.sin(44063) + Math.cos(44064) * 25;
+acc += Math.sin(44064) + Math.cos(44065) * 26;
+acc += Math.sin(44065) + Math.cos(44066) * 27;
+acc += Math.sin(44066) + Math.cos(44067) * 28;
+acc += Math.sin(44067) + Math.cos(44068) * 29;
+acc += Math.sin(44068) + Math.cos(44069) * 30;
+acc += Math.sin(44069) + Math.cos(44070) * 31;
+acc += Math.sin(44070) + Math.cos(44071) * 32;
+acc += Math.sin(44071) + Math.cos(44072) * 33;
+acc += Math.sin(44072) + Math.cos(44073) * 34;
+acc += Math.sin(44073) + Math.cos(44074) * 35;
+acc += Math.sin(44074) + Math.cos(44075) * 36;
+acc += Math.sin(44075) + Math.cos(44076) * 37;
+acc += Math.sin(44076) + Math.cos(44077) * 38;
+acc += Math.sin(44077) + Math.cos(44078) * 39;
+acc += Math.sin(44078) + Math.cos(44079) * 40;
+acc += Math.sin(44079) + Math.cos(44080) * 41;
+acc += Math.sin(44080) + Math.cos(44081) * 42;
+acc += Math.sin(44081) + Math.cos(44082) * 43;
+acc += Math.sin(44082) + Math.cos(44083) * 44;
+acc += Math.sin(44083) + Math.cos(44084) * 45;
+acc += Math.sin(44084) + Math.cos(44085) * 46;
+acc += Math.sin(44085) + Math.cos(44086) * 47;
+acc += Math.sin(44086) + Math.cos(44087) * 48;
+acc += Math.sin(44087) + Math.cos(44088) * 49;
+acc += Math.sin(44088) + Math.cos(44089) * 50;
+acc += Math.sin(44089) + Math.cos(44090) * 51;
+acc += Math.sin(44090) + Math.cos(44091) * 52;
+acc += Math.sin(44091) + Math.cos(44092) * 53;
+acc += Math.sin(44092) + Math.cos(44093) * 54;
+acc += Math.sin(44093) + Math.cos(44094) * 55;
+acc += Math.sin(44094) + Math.cos(44095) * 56;
+acc += Math.sin(44095) + Math.cos(44096) * 57;
+acc += Math.sin(44096) + Math.cos(44097) * 58;
+acc += Math.sin(44097) + Math.cos(44098) * 59;
+acc += Math.sin(44098) + Math.cos(44099) * 60;
+acc += Math.sin(44099) + Math.cos(44100) * 61;
+acc += Math.sin(44100) + Math.cos(44101) * 62;
+acc += Math.sin(44101) + Math.cos(44102) * 63;
+acc += Math.sin(44102) + Math.cos(44103) * 64;
+acc += Math.sin(44103) + Math.cos(44104) * 65;
+acc += Math.sin(44104) + Math.cos(44105) * 66;
+acc += Math.sin(44105) + Math.cos(44106) * 67;
+acc += Math.sin(44106) + Math.cos(44107) * 68;
+acc += Math.sin(44107) + Math.cos(44108) * 69;
+acc += Math.sin(44108) + Math.cos(44109) * 70;
+acc += Math.sin(44109) + Math.cos(44110) * 71;
+acc += Math.sin(44110) + Math.cos(44111) * 72;
+acc += Math.sin(44111) + Math.cos(44112) * 73;
+acc += Math.sin(44112) + Math.cos(44113) * 74;
+acc += Math.sin(44113) + Math.cos(44114) * 75;
+acc += Math.sin(44114) + Math.cos(44115) * 76;
+acc += Math.sin(44115) + Math.cos(44116) * 77;
+acc += Math.sin(44116) + Math.cos(44117) * 78;
+acc += Math.sin(44117) + Math.cos(44118) * 79;
+acc += Math.sin(44118) + Math.cos(44119) * 80;
+acc += Math.sin(44119) + Math.cos(44120) * 81;
+acc += Math.sin(44120) + Math.cos(44121) * 82;
+acc += Math.sin(44121) + Math.cos(44122) * 83;
+acc += Math.sin(44122) + Math.cos(44123) * 84;
+acc += Math.sin(44123) + Math.cos(44124) * 85;
+acc += Math.sin(44124) + Math.cos(44125) * 86;
+acc += Math.sin(44125) + Math.cos(44126) * 87;
+acc += Math.sin(44126) + Math.cos(44127) * 88;
+acc += Math.sin(44127) + Math.cos(44128) * 89;
+acc += Math.sin(44128) + Math.cos(44129) * 90;
+acc += Math.sin(44129) + Math.cos(44130) * 91;
+acc += Math.sin(44130) + Math.cos(44131) * 92;
+acc += Math.sin(44131) + Math.cos(44132) * 93;
+acc += Math.sin(44132) + Math.cos(44133) * 94;
+acc += Math.sin(44133) + Math.cos(44134) * 95;
+acc += Math.sin(44134) + Math.cos(44135) * 96;
+acc += Math.sin(44135) + Math.cos(44136) * 0;
+acc += Math.sin(44136) + Math.cos(44137) * 1;
+acc += Math.sin(44137) + Math.cos(44138) * 2;
+acc += Math.sin(44138) + Math.cos(44139) * 3;
+acc += Math.sin(44139) + Math.cos(44140) * 4;
+acc += Math.sin(44140) + Math.cos(44141) * 5;
+acc += Math.sin(44141) + Math.cos(44142) * 6;
+acc += Math.sin(44142) + Math.cos(44143) * 7;
+acc += Math.sin(44143) + Math.cos(44144) * 8;
+acc += Math.sin(44144) + Math.cos(44145) * 9;
+acc += Math.sin(44145) + Math.cos(44146) * 10;
+acc += Math.sin(44146) + Math.cos(44147) * 11;
+acc += Math.sin(44147) + Math.cos(44148) * 12;
+acc += Math.sin(44148) + Math.cos(44149) * 13;
+acc += Math.sin(44149) + Math.cos(44150) * 14;
+acc += Math.sin(44150) + Math.cos(44151) * 15;
+acc += Math.sin(44151) + Math.cos(44152) * 16;
+acc += Math.sin(44152) + Math.cos(44153) * 17;
+acc += Math.sin(44153) + Math.cos(44154) * 18;
+acc += Math.sin(44154) + Math.cos(44155) * 19;
+acc += Math.sin(44155) + Math.cos(44156) * 20;
+acc += Math.sin(44156) + Math.cos(44157) * 21;
+acc += Math.sin(44157) + Math.cos(44158) * 22;
+acc += Math.sin(44158) + Math.cos(44159) * 23;
+acc += Math.sin(44159) + Math.cos(44160) * 24;
+acc += Math.sin(44160) + Math.cos(44161) * 25;
+acc += Math.sin(44161) + Math.cos(44162) * 26;
+acc += Math.sin(44162) + Math.cos(44163) * 27;
+acc += Math.sin(44163) + Math.cos(44164) * 28;
+acc += Math.sin(44164) + Math.cos(44165) * 29;
+acc += Math.sin(44165) + Math.cos(44166) * 30;
+acc += Math.sin(44166) + Math.cos(44167) * 31;
+acc += Math.sin(44167) + Math.cos(44168) * 32;
+acc += Math.sin(44168) + Math.cos(44169) * 33;
+acc += Math.sin(44169) + Math.cos(44170) * 34;
+acc += Math.sin(44170) + Math.cos(44171) * 35;
+acc += Math.sin(44171) + Math.cos(44172) * 36;
+acc += Math.sin(44172) + Math.cos(44173) * 37;
+acc += Math.sin(44173) + Math.cos(44174) * 38;
+acc += Math.sin(44174) + Math.cos(44175) * 39;
+acc += Math.sin(44175) + Math.cos(44176) * 40;
+acc += Math.sin(44176) + Math.cos(44177) * 41;
+acc += Math.sin(44177) + Math.cos(44178) * 42;
+acc += Math.sin(44178) + Math.cos(44179) * 43;
+acc += Math.sin(44179) + Math.cos(44180) * 44;
+acc += Math.sin(44180) + Math.cos(44181) * 45;
+acc += Math.sin(44181) + Math.cos(44182) * 46;
+acc += Math.sin(44182) + Math.cos(44183) * 47;
+acc += Math.sin(44183) + Math.cos(44184) * 48;
+acc += Math.sin(44184) + Math.cos(44185) * 49;
+acc += Math.sin(44185) + Math.cos(44186) * 50;
+acc += Math.sin(44186) + Math.cos(44187) * 51;
+acc += Math.sin(44187) + Math.cos(44188) * 52;
+acc += Math.sin(44188) + Math.cos(44189) * 53;
+acc += Math.sin(44189) + Math.cos(44190) * 54;
+acc += Math.sin(44190) + Math.cos(44191) * 55;
+acc += Math.sin(44191) + Math.cos(44192) * 56;
+acc += Math.sin(44192) + Math.cos(44193) * 57;
+acc += Math.sin(44193) + Math.cos(44194) * 58;
+acc += Math.sin(44194) + Math.cos(44195) * 59;
+acc += Math.sin(44195) + Math.cos(44196) * 60;
+acc += Math.sin(44196) + Math.cos(44197) * 61;
+acc += Math.sin(44197) + Math.cos(44198) * 62;
+acc += Math.sin(44198) + Math.cos(44199) * 63;
+acc += Math.sin(44199) + Math.cos(44200) * 64;
+acc += Math.sin(44200) + Math.cos(44201) * 65;
+acc += Math.sin(44201) + Math.cos(44202) * 66;
+acc += Math.sin(44202) + Math.cos(44203) * 67;
+acc += Math.sin(44203) + Math.cos(44204) * 68;
+acc += Math.sin(44204) + Math.cos(44205) * 69;
+acc += Math.sin(44205) + Math.cos(44206) * 70;
+acc += Math.sin(44206) + Math.cos(44207) * 71;
+acc += Math.sin(44207) + Math.cos(44208) * 72;
+acc += Math.sin(44208) + Math.cos(44209) * 73;
+acc += Math.sin(44209) + Math.cos(44210) * 74;
+acc += Math.sin(44210) + Math.cos(44211) * 75;
+acc += Math.sin(44211) + Math.cos(44212) * 76;
+acc += Math.sin(44212) + Math.cos(44213) * 77;
+acc += Math.sin(44213) + Math.cos(44214) * 78;
+acc += Math.sin(44214) + Math.cos(44215) * 79;
+acc += Math.sin(44215) + Math.cos(44216) * 80;
+acc += Math.sin(44216) + Math.cos(44217) * 81;
+acc += Math.sin(44217) + Math.cos(44218) * 82;
+acc += Math.sin(44218) + Math.cos(44219) * 83;
+acc += Math.sin(44219) + Math.cos(44220) * 84;
+acc += Math.sin(44220) + Math.cos(44221) * 85;
+acc += Math.sin(44221) + Math.cos(44222) * 86;
+acc += Math.sin(44222) + Math.cos(44223) * 87;
+acc += Math.sin(44223) + Math.cos(44224) * 88;
+acc += Math.sin(44224) + Math.cos(44225) * 89;
+acc += Math.sin(44225) + Math.cos(44226) * 90;
+acc += Math.sin(44226) + Math.cos(44227) * 91;
+acc += Math.sin(44227) + Math.cos(44228) * 92;
+acc += Math.sin(44228) + Math.cos(44229) * 93;
+acc += Math.sin(44229) + Math.cos(44230) * 94;
+acc += Math.sin(44230) + Math.cos(44231) * 95;
+acc += Math.sin(44231) + Math.cos(44232) * 96;
+acc += Math.sin(44232) + Math.cos(44233) * 0;
+acc += Math.sin(44233) + Math.cos(44234) * 1;
+acc += Math.sin(44234) + Math.cos(44235) * 2;
+acc += Math.sin(44235) + Math.cos(44236) * 3;
+acc += Math.sin(44236) + Math.cos(44237) * 4;
+acc += Math.sin(44237) + Math.cos(44238) * 5;
+acc += Math.sin(44238) + Math.cos(44239) * 6;
+acc += Math.sin(44239) + Math.cos(44240) * 7;
+acc += Math.sin(44240) + Math.cos(44241) * 8;
+acc += Math.sin(44241) + Math.cos(44242) * 9;
+acc += Math.sin(44242) + Math.cos(44243) * 10;
+acc += Math.sin(44243) + Math.cos(44244) * 11;
+acc += Math.sin(44244) + Math.cos(44245) * 12;
+acc += Math.sin(44245) + Math.cos(44246) * 13;
+acc += Math.sin(44246) + Math.cos(44247) * 14;
+acc += Math.sin(44247) + Math.cos(44248) * 15;
+acc += Math.sin(44248) + Math.cos(44249) * 16;
+acc += Math.sin(44249) + Math.cos(44250) * 17;
+acc += Math.sin(44250) + Math.cos(44251) * 18;
+acc += Math.sin(44251) + Math.cos(44252) * 19;
+acc += Math.sin(44252) + Math.cos(44253) * 20;
+acc += Math.sin(44253) + Math.cos(44254) * 21;
+acc += Math.sin(44254) + Math.cos(44255) * 22;
+acc += Math.sin(44255) + Math.cos(44256) * 23;
+acc += Math.sin(44256) + Math.cos(44257) * 24;
+acc += Math.sin(44257) + Math.cos(44258) * 25;
+acc += Math.sin(44258) + Math.cos(44259) * 26;
+acc += Math.sin(44259) + Math.cos(44260) * 27;
+acc += Math.sin(44260) + Math.cos(44261) * 28;
+acc += Math.sin(44261) + Math.cos(44262) * 29;
+acc += Math.sin(44262) + Math.cos(44263) * 30;
+acc += Math.sin(44263) + Math.cos(44264) * 31;
+acc += Math.sin(44264) + Math.cos(44265) * 32;
+acc += Math.sin(44265) + Math.cos(44266) * 33;
+acc += Math.sin(44266) + Math.cos(44267) * 34;
+acc += Math.sin(44267) + Math.cos(44268) * 35;
+acc += Math.sin(44268) + Math.cos(44269) * 36;
+acc += Math.sin(44269) + Math.cos(44270) * 37;
+acc += Math.sin(44270) + Math.cos(44271) * 38;
+acc += Math.sin(44271) + Math.cos(44272) * 39;
+acc += Math.sin(44272) + Math.cos(44273) * 40;
+acc += Math.sin(44273) + Math.cos(44274) * 41;
+acc += Math.sin(44274) + Math.cos(44275) * 42;
+acc += Math.sin(44275) + Math.cos(44276) * 43;
+acc += Math.sin(44276) + Math.cos(44277) * 44;
+acc += Math.sin(44277) + Math.cos(44278) * 45;
+acc += Math.sin(44278) + Math.cos(44279) * 46;
+acc += Math.sin(44279) + Math.cos(44280) * 47;
+acc += Math.sin(44280) + Math.cos(44281) * 48;
+acc += Math.sin(44281) + Math.cos(44282) * 49;
+acc += Math.sin(44282) + Math.cos(44283) * 50;
+acc += Math.sin(44283) + Math.cos(44284) * 51;
+acc += Math.sin(44284) + Math.cos(44285) * 52;
+acc += Math.sin(44285) + Math.cos(44286) * 53;
+acc += Math.sin(44286) + Math.cos(44287) * 54;
+acc += Math.sin(44287) + Math.cos(44288) * 55;
+acc += Math.sin(44288) + Math.cos(44289) * 56;
+acc += Math.sin(44289) + Math.cos(44290) * 57;
+acc += Math.sin(44290) + Math.cos(44291) * 58;
+acc += Math.sin(44291) + Math.cos(44292) * 59;
+acc += Math.sin(44292) + Math.cos(44293) * 60;
+acc += Math.sin(44293) + Math.cos(44294) * 61;
+acc += Math.sin(44294) + Math.cos(44295) * 62;
+acc += Math.sin(44295) + Math.cos(44296) * 63;
+acc += Math.sin(44296) + Math.cos(44297) * 64;
+acc += Math.sin(44297) + Math.cos(44298) * 65;
+acc += Math.sin(44298) + Math.cos(44299) * 66;
+acc += Math.sin(44299) + Math.cos(44300) * 67;
+acc += Math.sin(44300) + Math.cos(44301) * 68;
+acc += Math.sin(44301) + Math.cos(44302) * 69;
+acc += Math.sin(44302) + Math.cos(44303) * 70;
+acc += Math.sin(44303) + Math.cos(44304) * 71;
+acc += Math.sin(44304) + Math.cos(44305) * 72;
+acc += Math.sin(44305) + Math.cos(44306) * 73;
+acc += Math.sin(44306) + Math.cos(44307) * 74;
+acc += Math.sin(44307) + Math.cos(44308) * 75;
+acc += Math.sin(44308) + Math.cos(44309) * 76;
+acc += Math.sin(44309) + Math.cos(44310) * 77;
+acc += Math.sin(44310) + Math.cos(44311) * 78;
+acc += Math.sin(44311) + Math.cos(44312) * 79;
+acc += Math.sin(44312) + Math.cos(44313) * 80;
+acc += Math.sin(44313) + Math.cos(44314) * 81;
+acc += Math.sin(44314) + Math.cos(44315) * 82;
+acc += Math.sin(44315) + Math.cos(44316) * 83;
+acc += Math.sin(44316) + Math.cos(44317) * 84;
+acc += Math.sin(44317) + Math.cos(44318) * 85;
+acc += Math.sin(44318) + Math.cos(44319) * 86;
+acc += Math.sin(44319) + Math.cos(44320) * 87;
+acc += Math.sin(44320) + Math.cos(44321) * 88;
+acc += Math.sin(44321) + Math.cos(44322) * 89;
+acc += Math.sin(44322) + Math.cos(44323) * 90;
+acc += Math.sin(44323) + Math.cos(44324) * 91;
+acc += Math.sin(44324) + Math.cos(44325) * 92;
+acc += Math.sin(44325) + Math.cos(44326) * 93;
+acc += Math.sin(44326) + Math.cos(44327) * 94;
+acc += Math.sin(44327) + Math.cos(44328) * 95;
+acc += Math.sin(44328) + Math.cos(44329) * 96;
+acc += Math.sin(44329) + Math.cos(44330) * 0;
+acc += Math.sin(44330) + Math.cos(44331) * 1;
+acc += Math.sin(44331) + Math.cos(44332) * 2;
+acc += Math.sin(44332) + Math.cos(44333) * 3;
+acc += Math.sin(44333) + Math.cos(44334) * 4;
+acc += Math.sin(44334) + Math.cos(44335) * 5;
+acc += Math.sin(44335) + Math.cos(44336) * 6;
+acc += Math.sin(44336) + Math.cos(44337) * 7;
+acc += Math.sin(44337) + Math.cos(44338) * 8;
+acc += Math.sin(44338) + Math.cos(44339) * 9;
+acc += Math.sin(44339) + Math.cos(44340) * 10;
+acc += Math.sin(44340) + Math.cos(44341) * 11;
+acc += Math.sin(44341) + Math.cos(44342) * 12;
+acc += Math.sin(44342) + Math.cos(44343) * 13;
+acc += Math.sin(44343) + Math.cos(44344) * 14;
+acc += Math.sin(44344) + Math.cos(44345) * 15;
+acc += Math.sin(44345) + Math.cos(44346) * 16;
+acc += Math.sin(44346) + Math.cos(44347) * 17;
+acc += Math.sin(44347) + Math.cos(44348) * 18;
+acc += Math.sin(44348) + Math.cos(44349) * 19;
+acc += Math.sin(44349) + Math.cos(44350) * 20;
+acc += Math.sin(44350) + Math.cos(44351) * 21;
+acc += Math.sin(44351) + Math.cos(44352) * 22;
+acc += Math.sin(44352) + Math.cos(44353) * 23;
+acc += Math.sin(44353) + Math.cos(44354) * 24;
+acc += Math.sin(44354) + Math.cos(44355) * 25;
+acc += Math.sin(44355) + Math.cos(44356) * 26;
+acc += Math.sin(44356) + Math.cos(44357) * 27;
+acc += Math.sin(44357) + Math.cos(44358) * 28;
+acc += Math.sin(44358) + Math.cos(44359) * 29;
+acc += Math.sin(44359) + Math.cos(44360) * 30;
+acc += Math.sin(44360) + Math.cos(44361) * 31;
+acc += Math.sin(44361) + Math.cos(44362) * 32;
+acc += Math.sin(44362) + Math.cos(44363) * 33;
+acc += Math.sin(44363) + Math.cos(44364) * 34;
+acc += Math.sin(44364) + Math.cos(44365) * 35;
+acc += Math.sin(44365) + Math.cos(44366) * 36;
+acc += Math.sin(44366) + Math.cos(44367) * 37;
+acc += Math.sin(44367) + Math.cos(44368) * 38;
+acc += Math.sin(44368) + Math.cos(44369) * 39;
+acc += Math.sin(44369) + Math.cos(44370) * 40;
+acc += Math.sin(44370) + Math.cos(44371) * 41;
+acc += Math.sin(44371) + Math.cos(44372) * 42;
+acc += Math.sin(44372) + Math.cos(44373) * 43;
+acc += Math.sin(44373) + Math.cos(44374) * 44;
+acc += Math.sin(44374) + Math.cos(44375) * 45;
+acc += Math.sin(44375) + Math.cos(44376) * 46;
+acc += Math.sin(44376) + Math.cos(44377) * 47;
+acc += Math.sin(44377) + Math.cos(44378) * 48;
+acc += Math.sin(44378) + Math.cos(44379) * 49;
+acc += Math.sin(44379) + Math.cos(44380) * 50;
+acc += Math.sin(44380) + Math.cos(44381) * 51;
+acc += Math.sin(44381) + Math.cos(44382) * 52;
+acc += Math.sin(44382) + Math.cos(44383) * 53;
+acc += Math.sin(44383) + Math.cos(44384) * 54;
+acc += Math.sin(44384) + Math.cos(44385) * 55;
+acc += Math.sin(44385) + Math.cos(44386) * 56;
+acc += Math.sin(44386) + Math.cos(44387) * 57;
+acc += Math.sin(44387) + Math.cos(44388) * 58;
+acc += Math.sin(44388) + Math.cos(44389) * 59;
+acc += Math.sin(44389) + Math.cos(44390) * 60;
+acc += Math.sin(44390) + Math.cos(44391) * 61;
+acc += Math.sin(44391) + Math.cos(44392) * 62;
+acc += Math.sin(44392) + Math.cos(44393) * 63;
+acc += Math.sin(44393) + Math.cos(44394) * 64;
+acc += Math.sin(44394) + Math.cos(44395) * 65;
+acc += Math.sin(44395) + Math.cos(44396) * 66;
+acc += Math.sin(44396) + Math.cos(44397) * 67;
+acc += Math.sin(44397) + Math.cos(44398) * 68;
+acc += Math.sin(44398) + Math.cos(44399) * 69;
+acc += Math.sin(44399) + Math.cos(44400) * 70;
+acc += Math.sin(44400) + Math.cos(44401) * 71;
+acc += Math.sin(44401) + Math.cos(44402) * 72;
+acc += Math.sin(44402) + Math.cos(44403) * 73;
+acc += Math.sin(44403) + Math.cos(44404) * 74;
+acc += Math.sin(44404) + Math.cos(44405) * 75;
+acc += Math.sin(44405) + Math.cos(44406) * 76;
+acc += Math.sin(44406) + Math.cos(44407) * 77;
+acc += Math.sin(44407) + Math.cos(44408) * 78;
+acc += Math.sin(44408) + Math.cos(44409) * 79;
+acc += Math.sin(44409) + Math.cos(44410) * 80;
+acc += Math.sin(44410) + Math.cos(44411) * 81;
+acc += Math.sin(44411) + Math.cos(44412) * 82;
+acc += Math.sin(44412) + Math.cos(44413) * 83;
+acc += Math.sin(44413) + Math.cos(44414) * 84;
+acc += Math.sin(44414) + Math.cos(44415) * 85;
+acc += Math.sin(44415) + Math.cos(44416) * 86;
+acc += Math.sin(44416) + Math.cos(44417) * 87;
+acc += Math.sin(44417) + Math.cos(44418) * 88;
+acc += Math.sin(44418) + Math.cos(44419) * 89;
+acc += Math.sin(44419) + Math.cos(44420) * 90;
+acc += Math.sin(44420) + Math.cos(44421) * 91;
+acc += Math.sin(44421) + Math.cos(44422) * 92;
+acc += Math.sin(44422) + Math.cos(44423) * 93;
+acc += Math.sin(44423) + Math.cos(44424) * 94;
+acc += Math.sin(44424) + Math.cos(44425) * 95;
+acc += Math.sin(44425) + Math.cos(44426) * 96;
+acc += Math.sin(44426) + Math.cos(44427) * 0;
+acc += Math.sin(44427) + Math.cos(44428) * 1;
+acc += Math.sin(44428) + Math.cos(44429) * 2;
+acc += Math.sin(44429) + Math.cos(44430) * 3;
+acc += Math.sin(44430) + Math.cos(44431) * 4;
+acc += Math.sin(44431) + Math.cos(44432) * 5;
+acc += Math.sin(44432) + Math.cos(44433) * 6;
+acc += Math.sin(44433) + Math.cos(44434) * 7;
+acc += Math.sin(44434) + Math.cos(44435) * 8;
+acc += Math.sin(44435) + Math.cos(44436) * 9;
+acc += Math.sin(44436) + Math.cos(44437) * 10;
+acc += Math.sin(44437) + Math.cos(44438) * 11;
+acc += Math.sin(44438) + Math.cos(44439) * 12;
+acc += Math.sin(44439) + Math.cos(44440) * 13;
+acc += Math.sin(44440) + Math.cos(44441) * 14;
+acc += Math.sin(44441) + Math.cos(44442) * 15;
+acc += Math.sin(44442) + Math.cos(44443) * 16;
+acc += Math.sin(44443) + Math.cos(44444) * 17;
+acc += Math.sin(44444) + Math.cos(44445) * 18;
+acc += Math.sin(44445) + Math.cos(44446) * 19;
+acc += Math.sin(44446) + Math.cos(44447) * 20;
+acc += Math.sin(44447) + Math.cos(44448) * 21;
+acc += Math.sin(44448) + Math.cos(44449) * 22;
+acc += Math.sin(44449) + Math.cos(44450) * 23;
+acc += Math.sin(44450) + Math.cos(44451) * 24;
+acc += Math.sin(44451) + Math.cos(44452) * 25;
+acc += Math.sin(44452) + Math.cos(44453) * 26;
+acc += Math.sin(44453) + Math.cos(44454) * 27;
+acc += Math.sin(44454) + Math.cos(44455) * 28;
+acc += Math.sin(44455) + Math.cos(44456) * 29;
+acc += Math.sin(44456) + Math.cos(44457) * 30;
+acc += Math.sin(44457) + Math.cos(44458) * 31;
+acc += Math.sin(44458) + Math.cos(44459) * 32;
+acc += Math.sin(44459) + Math.cos(44460) * 33;
+acc += Math.sin(44460) + Math.cos(44461) * 34;
+acc += Math.sin(44461) + Math.cos(44462) * 35;
+acc += Math.sin(44462) + Math.cos(44463) * 36;
+acc += Math.sin(44463) + Math.cos(44464) * 37;
+acc += Math.sin(44464) + Math.cos(44465) * 38;
+acc += Math.sin(44465) + Math.cos(44466) * 39;
+acc += Math.sin(44466) + Math.cos(44467) * 40;
+acc += Math.sin(44467) + Math.cos(44468) * 41;
+acc += Math.sin(44468) + Math.cos(44469) * 42;
+acc += Math.sin(44469) + Math.cos(44470) * 43;
+acc += Math.sin(44470) + Math.cos(44471) * 44;
+acc += Math.sin(44471) + Math.cos(44472) * 45;
+acc += Math.sin(44472) + Math.cos(44473) * 46;
+acc += Math.sin(44473) + Math.cos(44474) * 47;
+acc += Math.sin(44474) + Math.cos(44475) * 48;
+acc += Math.sin(44475) + Math.cos(44476) * 49;
+acc += Math.sin(44476) + Math.cos(44477) * 50;
+acc += Math.sin(44477) + Math.cos(44478) * 51;
+acc += Math.sin(44478) + Math.cos(44479) * 52;
+acc += Math.sin(44479) + Math.cos(44480) * 53;
+acc += Math.sin(44480) + Math.cos(44481) * 54;
+acc += Math.sin(44481) + Math.cos(44482) * 55;
+acc += Math.sin(44482) + Math.cos(44483) * 56;
+acc += Math.sin(44483) + Math.cos(44484) * 57;
+acc += Math.sin(44484) + Math.cos(44485) * 58;
+acc += Math.sin(44485) + Math.cos(44486) * 59;
+acc += Math.sin(44486) + Math.cos(44487) * 60;
+acc += Math.sin(44487) + Math.cos(44488) * 61;
+acc += Math.sin(44488) + Math.cos(44489) * 62;
+acc += Math.sin(44489) + Math.cos(44490) * 63;
+acc += Math.sin(44490) + Math.cos(44491) * 64;
+acc += Math.sin(44491) + Math.cos(44492) * 65;
+acc += Math.sin(44492) + Math.cos(44493) * 66;
+acc += Math.sin(44493) + Math.cos(44494) * 67;
+acc += Math.sin(44494) + Math.cos(44495) * 68;
+acc += Math.sin(44495) + Math.cos(44496) * 69;
+acc += Math.sin(44496) + Math.cos(44497) * 70;
+acc += Math.sin(44497) + Math.cos(44498) * 71;
+acc += Math.sin(44498) + Math.cos(44499) * 72;
+acc += Math.sin(44499) + Math.cos(44500) * 73;
+acc += Math.sin(44500) + Math.cos(44501) * 74;
+acc += Math.sin(44501) + Math.cos(44502) * 75;
+acc += Math.sin(44502) + Math.cos(44503) * 76;
+acc += Math.sin(44503) + Math.cos(44504) * 77;
+acc += Math.sin(44504) + Math.cos(44505) * 78;
+acc += Math.sin(44505) + Math.cos(44506) * 79;
+acc += Math.sin(44506) + Math.cos(44507) * 80;
+acc += Math.sin(44507) + Math.cos(44508) * 81;
+acc += Math.sin(44508) + Math.cos(44509) * 82;
+acc += Math.sin(44509) + Math.cos(44510) * 83;
+acc += Math.sin(44510) + Math.cos(44511) * 84;
+acc += Math.sin(44511) + Math.cos(44512) * 85;
+acc += Math.sin(44512) + Math.cos(44513) * 86;
+acc += Math.sin(44513) + Math.cos(44514) * 87;
+acc += Math.sin(44514) + Math.cos(44515) * 88;
+acc += Math.sin(44515) + Math.cos(44516) * 89;
+acc += Math.sin(44516) + Math.cos(44517) * 90;
+acc += Math.sin(44517) + Math.cos(44518) * 91;
+acc += Math.sin(44518) + Math.cos(44519) * 92;
+acc += Math.sin(44519) + Math.cos(44520) * 93;
+acc += Math.sin(44520) + Math.cos(44521) * 94;
+acc += Math.sin(44521) + Math.cos(44522) * 95;
+acc += Math.sin(44522) + Math.cos(44523) * 96;
+acc += Math.sin(44523) + Math.cos(44524) * 0;
+acc += Math.sin(44524) + Math.cos(44525) * 1;
+acc += Math.sin(44525) + Math.cos(44526) * 2;
+acc += Math.sin(44526) + Math.cos(44527) * 3;
+acc += Math.sin(44527) + Math.cos(44528) * 4;
+acc += Math.sin(44528) + Math.cos(44529) * 5;
+acc += Math.sin(44529) + Math.cos(44530) * 6;
+acc += Math.sin(44530) + Math.cos(44531) * 7;
+acc += Math.sin(44531) + Math.cos(44532) * 8;
+acc += Math.sin(44532) + Math.cos(44533) * 9;
+acc += Math.sin(44533) + Math.cos(44534) * 10;
+acc += Math.sin(44534) + Math.cos(44535) * 11;
+acc += Math.sin(44535) + Math.cos(44536) * 12;
+acc += Math.sin(44536) + Math.cos(44537) * 13;
+acc += Math.sin(44537) + Math.cos(44538) * 14;
+acc += Math.sin(44538) + Math.cos(44539) * 15;
+acc += Math.sin(44539) + Math.cos(44540) * 16;
+acc += Math.sin(44540) + Math.cos(44541) * 17;
+acc += Math.sin(44541) + Math.cos(44542) * 18;
+acc += Math.sin(44542) + Math.cos(44543) * 19;
+acc += Math.sin(44543) + Math.cos(44544) * 20;
+acc += Math.sin(44544) + Math.cos(44545) * 21;
+acc += Math.sin(44545) + Math.cos(44546) * 22;
+acc += Math.sin(44546) + Math.cos(44547) * 23;
+acc += Math.sin(44547) + Math.cos(44548) * 24;
+acc += Math.sin(44548) + Math.cos(44549) * 25;
+acc += Math.sin(44549) + Math.cos(44550) * 26;
+acc += Math.sin(44550) + Math.cos(44551) * 27;
+acc += Math.sin(44551) + Math.cos(44552) * 28;
+acc += Math.sin(44552) + Math.cos(44553) * 29;
+acc += Math.sin(44553) + Math.cos(44554) * 30;
+acc += Math.sin(44554) + Math.cos(44555) * 31;
+acc += Math.sin(44555) + Math.cos(44556) * 32;
+acc += Math.sin(44556) + Math.cos(44557) * 33;
+acc += Math.sin(44557) + Math.cos(44558) * 34;
+acc += Math.sin(44558) + Math.cos(44559) * 35;
+acc += Math.sin(44559) + Math.cos(44560) * 36;
+acc += Math.sin(44560) + Math.cos(44561) * 37;
+acc += Math.sin(44561) + Math.cos(44562) * 38;
+acc += Math.sin(44562) + Math.cos(44563) * 39;
+acc += Math.sin(44563) + Math.cos(44564) * 40;
+acc += Math.sin(44564) + Math.cos(44565) * 41;
+acc += Math.sin(44565) + Math.cos(44566) * 42;
+acc += Math.sin(44566) + Math.cos(44567) * 43;
+acc += Math.sin(44567) + Math.cos(44568) * 44;
+acc += Math.sin(44568) + Math.cos(44569) * 45;
+acc += Math.sin(44569) + Math.cos(44570) * 46;
+acc += Math.sin(44570) + Math.cos(44571) * 47;
+acc += Math.sin(44571) + Math.cos(44572) * 48;
+acc += Math.sin(44572) + Math.cos(44573) * 49;
+acc += Math.sin(44573) + Math.cos(44574) * 50;
+acc += Math.sin(44574) + Math.cos(44575) * 51;
+acc += Math.sin(44575) + Math.cos(44576) * 52;
+acc += Math.sin(44576) + Math.cos(44577) * 53;
+acc += Math.sin(44577) + Math.cos(44578) * 54;
+acc += Math.sin(44578) + Math.cos(44579) * 55;
+acc += Math.sin(44579) + Math.cos(44580) * 56;
+acc += Math.sin(44580) + Math.cos(44581) * 57;
+acc += Math.sin(44581) + Math.cos(44582) * 58;
+acc += Math.sin(44582) + Math.cos(44583) * 59;
+acc += Math.sin(44583) + Math.cos(44584) * 60;
+acc += Math.sin(44584) + Math.cos(44585) * 61;
+acc += Math.sin(44585) + Math.cos(44586) * 62;
+acc += Math.sin(44586) + Math.cos(44587) * 63;
+acc += Math.sin(44587) + Math.cos(44588) * 64;
+acc += Math.sin(44588) + Math.cos(44589) * 65;
+acc += Math.sin(44589) + Math.cos(44590) * 66;
+acc += Math.sin(44590) + Math.cos(44591) * 67;
+acc += Math.sin(44591) + Math.cos(44592) * 68;
+acc += Math.sin(44592) + Math.cos(44593) * 69;
+acc += Math.sin(44593) + Math.cos(44594) * 70;
+acc += Math.sin(44594) + Math.cos(44595) * 71;
+acc += Math.sin(44595) + Math.cos(44596) * 72;
+acc += Math.sin(44596) + Math.cos(44597) * 73;
+acc += Math.sin(44597) + Math.cos(44598) * 74;
+acc += Math.sin(44598) + Math.cos(44599) * 75;
+acc += Math.sin(44599) + Math.cos(44600) * 76;
+acc += Math.sin(44600) + Math.cos(44601) * 77;
+acc += Math.sin(44601) + Math.cos(44602) * 78;
+acc += Math.sin(44602) + Math.cos(44603) * 79;
+acc += Math.sin(44603) + Math.cos(44604) * 80;
+acc += Math.sin(44604) + Math.cos(44605) * 81;
+acc += Math.sin(44605) + Math.cos(44606) * 82;
+acc += Math.sin(44606) + Math.cos(44607) * 83;
+acc += Math.sin(44607) + Math.cos(44608) * 84;
+acc += Math.sin(44608) + Math.cos(44609) * 85;
+acc += Math.sin(44609) + Math.cos(44610) * 86;
+acc += Math.sin(44610) + Math.cos(44611) * 87;
+acc += Math.sin(44611) + Math.cos(44612) * 88;
+acc += Math.sin(44612) + Math.cos(44613) * 89;
+acc += Math.sin(44613) + Math.cos(44614) * 90;
+acc += Math.sin(44614) + Math.cos(44615) * 91;
+acc += Math.sin(44615) + Math.cos(44616) * 92;
+acc += Math.sin(44616) + Math.cos(44617) * 93;
+acc += Math.sin(44617) + Math.cos(44618) * 94;
+acc += Math.sin(44618) + Math.cos(44619) * 95;
+acc += Math.sin(44619) + Math.cos(44620) * 96;
+acc += Math.sin(44620) + Math.cos(44621) * 0;
+acc += Math.sin(44621) + Math.cos(44622) * 1;
+acc += Math.sin(44622) + Math.cos(44623) * 2;
+acc += Math.sin(44623) + Math.cos(44624) * 3;
+acc += Math.sin(44624) + Math.cos(44625) * 4;
+acc += Math.sin(44625) + Math.cos(44626) * 5;
+acc += Math.sin(44626) + Math.cos(44627) * 6;
+acc += Math.sin(44627) + Math.cos(44628) * 7;
+acc += Math.sin(44628) + Math.cos(44629) * 8;
+acc += Math.sin(44629) + Math.cos(44630) * 9;
+acc += Math.sin(44630) + Math.cos(44631) * 10;
+acc += Math.sin(44631) + Math.cos(44632) * 11;
+acc += Math.sin(44632) + Math.cos(44633) * 12;
+acc += Math.sin(44633) + Math.cos(44634) * 13;
+acc += Math.sin(44634) + Math.cos(44635) * 14;
+acc += Math.sin(44635) + Math.cos(44636) * 15;
+acc += Math.sin(44636) + Math.cos(44637) * 16;
+acc += Math.sin(44637) + Math.cos(44638) * 17;
+acc += Math.sin(44638) + Math.cos(44639) * 18;
+acc += Math.sin(44639) + Math.cos(44640) * 19;
+acc += Math.sin(44640) + Math.cos(44641) * 20;
+acc += Math.sin(44641) + Math.cos(44642) * 21;
+acc += Math.sin(44642) + Math.cos(44643) * 22;
+acc += Math.sin(44643) + Math.cos(44644) * 23;
+acc += Math.sin(44644) + Math.cos(44645) * 24;
+acc += Math.sin(44645) + Math.cos(44646) * 25;
+acc += Math.sin(44646) + Math.cos(44647) * 26;
+acc += Math.sin(44647) + Math.cos(44648) * 27;
+acc += Math.sin(44648) + Math.cos(44649) * 28;
+acc += Math.sin(44649) + Math.cos(44650) * 29;
+acc += Math.sin(44650) + Math.cos(44651) * 30;
+acc += Math.sin(44651) + Math.cos(44652) * 31;
+acc += Math.sin(44652) + Math.cos(44653) * 32;
+acc += Math.sin(44653) + Math.cos(44654) * 33;
+acc += Math.sin(44654) + Math.cos(44655) * 34;
+acc += Math.sin(44655) + Math.cos(44656) * 35;
+acc += Math.sin(44656) + Math.cos(44657) * 36;
+acc += Math.sin(44657) + Math.cos(44658) * 37;
+acc += Math.sin(44658) + Math.cos(44659) * 38;
+acc += Math.sin(44659) + Math.cos(44660) * 39;
+acc += Math.sin(44660) + Math.cos(44661) * 40;
+acc += Math.sin(44661) + Math.cos(44662) * 41;
+acc += Math.sin(44662) + Math.cos(44663) * 42;
+acc += Math.sin(44663) + Math.cos(44664) * 43;
+acc += Math.sin(44664) + Math.cos(44665) * 44;
+acc += Math.sin(44665) + Math.cos(44666) * 45;
+acc += Math.sin(44666) + Math.cos(44667) * 46;
+acc += Math.sin(44667) + Math.cos(44668) * 47;
+acc += Math.sin(44668) + Math.cos(44669) * 48;
+acc += Math.sin(44669) + Math.cos(44670) * 49;
+acc += Math.sin(44670) + Math.cos(44671) * 50;
+acc += Math.sin(44671) + Math.cos(44672) * 51;
+acc += Math.sin(44672) + Math.cos(44673) * 52;
+acc += Math.sin(44673) + Math.cos(44674) * 53;
+acc += Math.sin(44674) + Math.cos(44675) * 54;
+acc += Math.sin(44675) + Math.cos(44676) * 55;
+acc += Math.sin(44676) + Math.cos(44677) * 56;
+acc += Math.sin(44677) + Math.cos(44678) * 57;
+acc += Math.sin(44678) + Math.cos(44679) * 58;
+acc += Math.sin(44679) + Math.cos(44680) * 59;
+acc += Math.sin(44680) + Math.cos(44681) * 60;
+acc += Math.sin(44681) + Math.cos(44682) * 61;
+acc += Math.sin(44682) + Math.cos(44683) * 62;
+acc += Math.sin(44683) + Math.cos(44684) * 63;
+acc += Math.sin(44684) + Math.cos(44685) * 64;
+acc += Math.sin(44685) + Math.cos(44686) * 65;
+acc += Math.sin(44686) + Math.cos(44687) * 66;
+acc += Math.sin(44687) + Math.cos(44688) * 67;
+acc += Math.sin(44688) + Math.cos(44689) * 68;
+acc += Math.sin(44689) + Math.cos(44690) * 69;
+acc += Math.sin(44690) + Math.cos(44691) * 70;
+acc += Math.sin(44691) + Math.cos(44692) * 71;
+acc += Math.sin(44692) + Math.cos(44693) * 72;
+acc += Math.sin(44693) + Math.cos(44694) * 73;
+acc += Math.sin(44694) + Math.cos(44695) * 74;
+acc += Math.sin(44695) + Math.cos(44696) * 75;
+acc += Math.sin(44696) + Math.cos(44697) * 76;
+acc += Math.sin(44697) + Math.cos(44698) * 77;
+acc += Math.sin(44698) + Math.cos(44699) * 78;
+acc += Math.sin(44699) + Math.cos(44700) * 79;
+acc += Math.sin(44700) + Math.cos(44701) * 80;
+acc += Math.sin(44701) + Math.cos(44702) * 81;
+acc += Math.sin(44702) + Math.cos(44703) * 82;
+acc += Math.sin(44703) + Math.cos(44704) * 83;
+acc += Math.sin(44704) + Math.cos(44705) * 84;
+acc += Math.sin(44705) + Math.cos(44706) * 85;
+acc += Math.sin(44706) + Math.cos(44707) * 86;
+acc += Math.sin(44707) + Math.cos(44708) * 87;
+acc += Math.sin(44708) + Math.cos(44709) * 88;
+acc += Math.sin(44709) + Math.cos(44710) * 89;
+acc += Math.sin(44710) + Math.cos(44711) * 90;
+acc += Math.sin(44711) + Math.cos(44712) * 91;
+acc += Math.sin(44712) + Math.cos(44713) * 92;
+acc += Math.sin(44713) + Math.cos(44714) * 93;
+acc += Math.sin(44714) + Math.cos(44715) * 94;
+acc += Math.sin(44715) + Math.cos(44716) * 95;
+acc += Math.sin(44716) + Math.cos(44717) * 96;
+acc += Math.sin(44717) + Math.cos(44718) * 0;
+acc += Math.sin(44718) + Math.cos(44719) * 1;
+acc += Math.sin(44719) + Math.cos(44720) * 2;
+acc += Math.sin(44720) + Math.cos(44721) * 3;
+acc += Math.sin(44721) + Math.cos(44722) * 4;
+acc += Math.sin(44722) + Math.cos(44723) * 5;
+acc += Math.sin(44723) + Math.cos(44724) * 6;
+acc += Math.sin(44724) + Math.cos(44725) * 7;
+acc += Math.sin(44725) + Math.cos(44726) * 8;
+acc += Math.sin(44726) + Math.cos(44727) * 9;
+acc += Math.sin(44727) + Math.cos(44728) * 10;
+acc += Math.sin(44728) + Math.cos(44729) * 11;
+acc += Math.sin(44729) + Math.cos(44730) * 12;
+acc += Math.sin(44730) + Math.cos(44731) * 13;
+acc += Math.sin(44731) + Math.cos(44732) * 14;
+acc += Math.sin(44732) + Math.cos(44733) * 15;
+acc += Math.sin(44733) + Math.cos(44734) * 16;
+acc += Math.sin(44734) + Math.cos(44735) * 17;
+acc += Math.sin(44735) + Math.cos(44736) * 18;
+acc += Math.sin(44736) + Math.cos(44737) * 19;
+acc += Math.sin(44737) + Math.cos(44738) * 20;
+acc += Math.sin(44738) + Math.cos(44739) * 21;
+acc += Math.sin(44739) + Math.cos(44740) * 22;
+acc += Math.sin(44740) + Math.cos(44741) * 23;
+acc += Math.sin(44741) + Math.cos(44742) * 24;
+acc += Math.sin(44742) + Math.cos(44743) * 25;
+acc += Math.sin(44743) + Math.cos(44744) * 26;
+acc += Math.sin(44744) + Math.cos(44745) * 27;
+acc += Math.sin(44745) + Math.cos(44746) * 28;
+acc += Math.sin(44746) + Math.cos(44747) * 29;
+acc += Math.sin(44747) + Math.cos(44748) * 30;
+acc += Math.sin(44748) + Math.cos(44749) * 31;
+acc += Math.sin(44749) + Math.cos(44750) * 32;
+acc += Math.sin(44750) + Math.cos(44751) * 33;
+acc += Math.sin(44751) + Math.cos(44752) * 34;
+acc += Math.sin(44752) + Math.cos(44753) * 35;
+acc += Math.sin(44753) + Math.cos(44754) * 36;
+acc += Math.sin(44754) + Math.cos(44755) * 37;
+acc += Math.sin(44755) + Math.cos(44756) * 38;
+acc += Math.sin(44756) + Math.cos(44757) * 39;
+acc += Math.sin(44757) + Math.cos(44758) * 40;
+acc += Math.sin(44758) + Math.cos(44759) * 41;
+acc += Math.sin(44759) + Math.cos(44760) * 42;
+acc += Math.sin(44760) + Math.cos(44761) * 43;
+acc += Math.sin(44761) + Math.cos(44762) * 44;
+acc += Math.sin(44762) + Math.cos(44763) * 45;
+acc += Math.sin(44763) + Math.cos(44764) * 46;
+acc += Math.sin(44764) + Math.cos(44765) * 47;
+acc += Math.sin(44765) + Math.cos(44766) * 48;
+acc += Math.sin(44766) + Math.cos(44767) * 49;
+acc += Math.sin(44767) + Math.cos(44768) * 50;
+acc += Math.sin(44768) + Math.cos(44769) * 51;
+acc += Math.sin(44769) + Math.cos(44770) * 52;
+acc += Math.sin(44770) + Math.cos(44771) * 53;
+acc += Math.sin(44771) + Math.cos(44772) * 54;
+acc += Math.sin(44772) + Math.cos(44773) * 55;
+acc += Math.sin(44773) + Math.cos(44774) * 56;
+acc += Math.sin(44774) + Math.cos(44775) * 57;
+acc += Math.sin(44775) + Math.cos(44776) * 58;
+acc += Math.sin(44776) + Math.cos(44777) * 59;
+acc += Math.sin(44777) + Math.cos(44778) * 60;
+acc += Math.sin(44778) + Math.cos(44779) * 61;
+acc += Math.sin(44779) + Math.cos(44780) * 62;
+acc += Math.sin(44780) + Math.cos(44781) * 63;
+acc += Math.sin(44781) + Math.cos(44782) * 64;
+acc += Math.sin(44782) + Math.cos(44783) * 65;
+acc += Math.sin(44783) + Math.cos(44784) * 66;
+acc += Math.sin(44784) + Math.cos(44785) * 67;
+acc += Math.sin(44785) + Math.cos(44786) * 68;
+acc += Math.sin(44786) + Math.cos(44787) * 69;
+acc += Math.sin(44787) + Math.cos(44788) * 70;
+acc += Math.sin(44788) + Math.cos(44789) * 71;
+acc += Math.sin(44789) + Math.cos(44790) * 72;
+acc += Math.sin(44790) + Math.cos(44791) * 73;
+acc += Math.sin(44791) + Math.cos(44792) * 74;
+acc += Math.sin(44792) + Math.cos(44793) * 75;
+acc += Math.sin(44793) + Math.cos(44794) * 76;
+acc += Math.sin(44794) + Math.cos(44795) * 77;
+acc += Math.sin(44795) + Math.cos(44796) * 78;
+acc += Math.sin(44796) + Math.cos(44797) * 79;
+acc += Math.sin(44797) + Math.cos(44798) * 80;
+acc += Math.sin(44798) + Math.cos(44799) * 81;
+acc += Math.sin(44799) + Math.cos(44800) * 82;
+acc += Math.sin(44800) + Math.cos(44801) * 83;
+acc += Math.sin(44801) + Math.cos(44802) * 84;
+acc += Math.sin(44802) + Math.cos(44803) * 85;
+acc += Math.sin(44803) + Math.cos(44804) * 86;
+acc += Math.sin(44804) + Math.cos(44805) * 87;
+acc += Math.sin(44805) + Math.cos(44806) * 88;
+acc += Math.sin(44806) + Math.cos(44807) * 89;
+acc += Math.sin(44807) + Math.cos(44808) * 90;
+acc += Math.sin(44808) + Math.cos(44809) * 91;
+acc += Math.sin(44809) + Math.cos(44810) * 92;
+acc += Math.sin(44810) + Math.cos(44811) * 93;
+acc += Math.sin(44811) + Math.cos(44812) * 94;
+acc += Math.sin(44812) + Math.cos(44813) * 95;
+acc += Math.sin(44813) + Math.cos(44814) * 96;
+acc += Math.sin(44814) + Math.cos(44815) * 0;
+acc += Math.sin(44815) + Math.cos(44816) * 1;
+acc += Math.sin(44816) + Math.cos(44817) * 2;
+acc += Math.sin(44817) + Math.cos(44818) * 3;
+acc += Math.sin(44818) + Math.cos(44819) * 4;
+acc += Math.sin(44819) + Math.cos(44820) * 5;
+acc += Math.sin(44820) + Math.cos(44821) * 6;
+acc += Math.sin(44821) + Math.cos(44822) * 7;
+acc += Math.sin(44822) + Math.cos(44823) * 8;
+acc += Math.sin(44823) + Math.cos(44824) * 9;
+acc += Math.sin(44824) + Math.cos(44825) * 10;
+acc += Math.sin(44825) + Math.cos(44826) * 11;
+acc += Math.sin(44826) + Math.cos(44827) * 12;
+acc += Math.sin(44827) + Math.cos(44828) * 13;
+acc += Math.sin(44828) + Math.cos(44829) * 14;
+acc += Math.sin(44829) + Math.cos(44830) * 15;
+acc += Math.sin(44830) + Math.cos(44831) * 16;
+acc += Math.sin(44831) + Math.cos(44832) * 17;
+acc += Math.sin(44832) + Math.cos(44833) * 18;
+acc += Math.sin(44833) + Math.cos(44834) * 19;
+acc += Math.sin(44834) + Math.cos(44835) * 20;
+acc += Math.sin(44835) + Math.cos(44836) * 21;
+acc += Math.sin(44836) + Math.cos(44837) * 22;
+acc += Math.sin(44837) + Math.cos(44838) * 23;
+acc += Math.sin(44838) + Math.cos(44839) * 24;
+acc += Math.sin(44839) + Math.cos(44840) * 25;
+acc += Math.sin(44840) + Math.cos(44841) * 26;
+acc += Math.sin(44841) + Math.cos(44842) * 27;
+acc += Math.sin(44842) + Math.cos(44843) * 28;
+acc += Math.sin(44843) + Math.cos(44844) * 29;
+acc += Math.sin(44844) + Math.cos(44845) * 30;
+acc += Math.sin(44845) + Math.cos(44846) * 31;
+acc += Math.sin(44846) + Math.cos(44847) * 32;
+acc += Math.sin(44847) + Math.cos(44848) * 33;
+acc += Math.sin(44848) + Math.cos(44849) * 34;
+acc += Math.sin(44849) + Math.cos(44850) * 35;
+acc += Math.sin(44850) + Math.cos(44851) * 36;
+acc += Math.sin(44851) + Math.cos(44852) * 37;
+acc += Math.sin(44852) + Math.cos(44853) * 38;
+acc += Math.sin(44853) + Math.cos(44854) * 39;
+acc += Math.sin(44854) + Math.cos(44855) * 40;
+acc += Math.sin(44855) + Math.cos(44856) * 41;
+acc += Math.sin(44856) + Math.cos(44857) * 42;
+acc += Math.sin(44857) + Math.cos(44858) * 43;
+acc += Math.sin(44858) + Math.cos(44859) * 44;
+acc += Math.sin(44859) + Math.cos(44860) * 45;
+acc += Math.sin(44860) + Math.cos(44861) * 46;
+acc += Math.sin(44861) + Math.cos(44862) * 47;
+acc += Math.sin(44862) + Math.cos(44863) * 48;
+acc += Math.sin(44863) + Math.cos(44864) * 49;
+acc += Math.sin(44864) + Math.cos(44865) * 50;
+acc += Math.sin(44865) + Math.cos(44866) * 51;
+acc += Math.sin(44866) + Math.cos(44867) * 52;
+acc += Math.sin(44867) + Math.cos(44868) * 53;
+acc += Math.sin(44868) + Math.cos(44869) * 54;
+acc += Math.sin(44869) + Math.cos(44870) * 55;
+acc += Math.sin(44870) + Math.cos(44871) * 56;
+acc += Math.sin(44871) + Math.cos(44872) * 57;
+acc += Math.sin(44872) + Math.cos(44873) * 58;
+acc += Math.sin(44873) + Math.cos(44874) * 59;
+acc += Math.sin(44874) + Math.cos(44875) * 60;
+acc += Math.sin(44875) + Math.cos(44876) * 61;
+acc += Math.sin(44876) + Math.cos(44877) * 62;
+acc += Math.sin(44877) + Math.cos(44878) * 63;
+acc += Math.sin(44878) + Math.cos(44879) * 64;
+acc += Math.sin(44879) + Math.cos(44880) * 65;
+acc += Math.sin(44880) + Math.cos(44881) * 66;
+acc += Math.sin(44881) + Math.cos(44882) * 67;
+acc += Math.sin(44882) + Math.cos(44883) * 68;
+acc += Math.sin(44883) + Math.cos(44884) * 69;
+acc += Math.sin(44884) + Math.cos(44885) * 70;
+acc += Math.sin(44885) + Math.cos(44886) * 71;
+acc += Math.sin(44886) + Math.cos(44887) * 72;
+acc += Math.sin(44887) + Math.cos(44888) * 73;
+acc += Math.sin(44888) + Math.cos(44889) * 74;
+acc += Math.sin(44889) + Math.cos(44890) * 75;
+acc += Math.sin(44890) + Math.cos(44891) * 76;
+acc += Math.sin(44891) + Math.cos(44892) * 77;
+acc += Math.sin(44892) + Math.cos(44893) * 78;
+acc += Math.sin(44893) + Math.cos(44894) * 79;
+acc += Math.sin(44894) + Math.cos(44895) * 80;
+acc += Math.sin(44895) + Math.cos(44896) * 81;
+acc += Math.sin(44896) + Math.cos(44897) * 82;
+acc += Math.sin(44897) + Math.cos(44898) * 83;
+acc += Math.sin(44898) + Math.cos(44899) * 84;
+acc += Math.sin(44899) + Math.cos(44900) * 85;
+acc += Math.sin(44900) + Math.cos(44901) * 86;
+acc += Math.sin(44901) + Math.cos(44902) * 87;
+acc += Math.sin(44902) + Math.cos(44903) * 88;
+acc += Math.sin(44903) + Math.cos(44904) * 89;
+acc += Math.sin(44904) + Math.cos(44905) * 90;
+acc += Math.sin(44905) + Math.cos(44906) * 91;
+acc += Math.sin(44906) + Math.cos(44907) * 92;
+acc += Math.sin(44907) + Math.cos(44908) * 93;
+acc += Math.sin(44908) + Math.cos(44909) * 94;
+acc += Math.sin(44909) + Math.cos(44910) * 95;
+acc += Math.sin(44910) + Math.cos(44911) * 96;
+acc += Math.sin(44911) + Math.cos(44912) * 0;
+acc += Math.sin(44912) + Math.cos(44913) * 1;
+acc += Math.sin(44913) + Math.cos(44914) * 2;
+acc += Math.sin(44914) + Math.cos(44915) * 3;
+acc += Math.sin(44915) + Math.cos(44916) * 4;
+acc += Math.sin(44916) + Math.cos(44917) * 5;
+acc += Math.sin(44917) + Math.cos(44918) * 6;
+acc += Math.sin(44918) + Math.cos(44919) * 7;
+acc += Math.sin(44919) + Math.cos(44920) * 8;
+acc += Math.sin(44920) + Math.cos(44921) * 9;
+acc += Math.sin(44921) + Math.cos(44922) * 10;
+acc += Math.sin(44922) + Math.cos(44923) * 11;
+acc += Math.sin(44923) + Math.cos(44924) * 12;
+acc += Math.sin(44924) + Math.cos(44925) * 13;
+acc += Math.sin(44925) + Math.cos(44926) * 14;
+acc += Math.sin(44926) + Math.cos(44927) * 15;
+acc += Math.sin(44927) + Math.cos(44928) * 16;
+acc += Math.sin(44928) + Math.cos(44929) * 17;
+acc += Math.sin(44929) + Math.cos(44930) * 18;
+acc += Math.sin(44930) + Math.cos(44931) * 19;
+acc += Math.sin(44931) + Math.cos(44932) * 20;
+acc += Math.sin(44932) + Math.cos(44933) * 21;
+acc += Math.sin(44933) + Math.cos(44934) * 22;
+acc += Math.sin(44934) + Math.cos(44935) * 23;
+acc += Math.sin(44935) + Math.cos(44936) * 24;
+acc += Math.sin(44936) + Math.cos(44937) * 25;
+acc += Math.sin(44937) + Math.cos(44938) * 26;
+acc += Math.sin(44938) + Math.cos(44939) * 27;
+acc += Math.sin(44939) + Math.cos(44940) * 28;
+acc += Math.sin(44940) + Math.cos(44941) * 29;
+acc += Math.sin(44941) + Math.cos(44942) * 30;
+acc += Math.sin(44942) + Math.cos(44943) * 31;
+acc += Math.sin(44943) + Math.cos(44944) * 32;
+acc += Math.sin(44944) + Math.cos(44945) * 33;
+acc += Math.sin(44945) + Math.cos(44946) * 34;
+acc += Math.sin(44946) + Math.cos(44947) * 35;
+acc += Math.sin(44947) + Math.cos(44948) * 36;
+acc += Math.sin(44948) + Math.cos(44949) * 37;
+acc += Math.sin(44949) + Math.cos(44950) * 38;
+acc += Math.sin(44950) + Math.cos(44951) * 39;
+acc += Math.sin(44951) + Math.cos(44952) * 40;
+acc += Math.sin(44952) + Math.cos(44953) * 41;
+acc += Math.sin(44953) + Math.cos(44954) * 42;
+acc += Math.sin(44954) + Math.cos(44955) * 43;
+acc += Math.sin(44955) + Math.cos(44956) * 44;
+acc += Math.sin(44956) + Math.cos(44957) * 45;
+acc += Math.sin(44957) + Math.cos(44958) * 46;
+acc += Math.sin(44958) + Math.cos(44959) * 47;
+acc += Math.sin(44959) + Math.cos(44960) * 48;
+acc += Math.sin(44960) + Math.cos(44961) * 49;
+acc += Math.sin(44961) + Math.cos(44962) * 50;
+acc += Math.sin(44962) + Math.cos(44963) * 51;
+acc += Math.sin(44963) + Math.cos(44964) * 52;
+acc += Math.sin(44964) + Math.cos(44965) * 53;
+acc += Math.sin(44965) + Math.cos(44966) * 54;
+acc += Math.sin(44966) + Math.cos(44967) * 55;
+acc += Math.sin(44967) + Math.cos(44968) * 56;
+acc += Math.sin(44968) + Math.cos(44969) * 57;
+acc += Math.sin(44969) + Math.cos(44970) * 58;
+acc += Math.sin(44970) + Math.cos(44971) * 59;
+acc += Math.sin(44971) + Math.cos(44972) * 60;
+acc += Math.sin(44972) + Math.cos(44973) * 61;
+acc += Math.sin(44973) + Math.cos(44974) * 62;
+acc += Math.sin(44974) + Math.cos(44975) * 63;
+acc += Math.sin(44975) + Math.cos(44976) * 64;
+acc += Math.sin(44976) + Math.cos(44977) * 65;
+acc += Math.sin(44977) + Math.cos(44978) * 66;
+acc += Math.sin(44978) + Math.cos(44979) * 67;
+acc += Math.sin(44979) + Math.cos(44980) * 68;
+acc += Math.sin(44980) + Math.cos(44981) * 69;
+acc += Math.sin(44981) + Math.cos(44982) * 70;
+acc += Math.sin(44982) + Math.cos(44983) * 71;
+acc += Math.sin(44983) + Math.cos(44984) * 72;
+acc += Math.sin(44984) + Math.cos(44985) * 73;
+acc += Math.sin(44985) + Math.cos(44986) * 74;
+acc += Math.sin(44986) + Math.cos(44987) * 75;
+acc += Math.sin(44987) + Math.cos(44988) * 76;
+acc += Math.sin(44988) + Math.cos(44989) * 77;
+acc += Math.sin(44989) + Math.cos(44990) * 78;
+acc += Math.sin(44990) + Math.cos(44991) * 79;
+acc += Math.sin(44991) + Math.cos(44992) * 80;
+acc += Math.sin(44992) + Math.cos(44993) * 81;
+acc += Math.sin(44993) + Math.cos(44994) * 82;
+acc += Math.sin(44994) + Math.cos(44995) * 83;
+acc += Math.sin(44995) + Math.cos(44996) * 84;
+acc += Math.sin(44996) + Math.cos(44997) * 85;
+acc += Math.sin(44997) + Math.cos(44998) * 86;
+acc += Math.sin(44998) + Math.cos(44999) * 87;
+acc += Math.sin(44999) + Math.cos(45000) * 88;
+acc += Math.sin(45000) + Math.cos(45001) * 89;
+acc += Math.sin(45001) + Math.cos(45002) * 90;
+acc += Math.sin(45002) + Math.cos(45003) * 91;
+acc += Math.sin(45003) + Math.cos(45004) * 92;
+acc += Math.sin(45004) + Math.cos(45005) * 93;
+acc += Math.sin(45005) + Math.cos(45006) * 94;
+acc += Math.sin(45006) + Math.cos(45007) * 95;
+acc += Math.sin(45007) + Math.cos(45008) * 96;
+acc += Math.sin(45008) + Math.cos(45009) * 0;
+acc += Math.sin(45009) + Math.cos(45010) * 1;
+acc += Math.sin(45010) + Math.cos(45011) * 2;
+acc += Math.sin(45011) + Math.cos(45012) * 3;
+acc += Math.sin(45012) + Math.cos(45013) * 4;
+acc += Math.sin(45013) + Math.cos(45014) * 5;
+acc += Math.sin(45014) + Math.cos(45015) * 6;
+acc += Math.sin(45015) + Math.cos(45016) * 7;
+acc += Math.sin(45016) + Math.cos(45017) * 8;
+acc += Math.sin(45017) + Math.cos(45018) * 9;
+acc += Math.sin(45018) + Math.cos(45019) * 10;
+acc += Math.sin(45019) + Math.cos(45020) * 11;
+acc += Math.sin(45020) + Math.cos(45021) * 12;
+acc += Math.sin(45021) + Math.cos(45022) * 13;
+acc += Math.sin(45022) + Math.cos(45023) * 14;
+acc += Math.sin(45023) + Math.cos(45024) * 15;
+acc += Math.sin(45024) + Math.cos(45025) * 16;
+acc += Math.sin(45025) + Math.cos(45026) * 17;
+acc += Math.sin(45026) + Math.cos(45027) * 18;
+acc += Math.sin(45027) + Math.cos(45028) * 19;
+acc += Math.sin(45028) + Math.cos(45029) * 20;
+acc += Math.sin(45029) + Math.cos(45030) * 21;
+acc += Math.sin(45030) + Math.cos(45031) * 22;
+acc += Math.sin(45031) + Math.cos(45032) * 23;
+acc += Math.sin(45032) + Math.cos(45033) * 24;
+acc += Math.sin(45033) + Math.cos(45034) * 25;
+acc += Math.sin(45034) + Math.cos(45035) * 26;
+acc += Math.sin(45035) + Math.cos(45036) * 27;
+acc += Math.sin(45036) + Math.cos(45037) * 28;
+acc += Math.sin(45037) + Math.cos(45038) * 29;
+acc += Math.sin(45038) + Math.cos(45039) * 30;
+acc += Math.sin(45039) + Math.cos(45040) * 31;
+acc += Math.sin(45040) + Math.cos(45041) * 32;
+acc += Math.sin(45041) + Math.cos(45042) * 33;
+acc += Math.sin(45042) + Math.cos(45043) * 34;
+acc += Math.sin(45043) + Math.cos(45044) * 35;
+acc += Math.sin(45044) + Math.cos(45045) * 36;
+acc += Math.sin(45045) + Math.cos(45046) * 37;
+acc += Math.sin(45046) + Math.cos(45047) * 38;
+acc += Math.sin(45047) + Math.cos(45048) * 39;
+acc += Math.sin(45048) + Math.cos(45049) * 40;
+acc += Math.sin(45049) + Math.cos(45050) * 41;
+acc += Math.sin(45050) + Math.cos(45051) * 42;
+acc += Math.sin(45051) + Math.cos(45052) * 43;
+acc += Math.sin(45052) + Math.cos(45053) * 44;
+acc += Math.sin(45053) + Math.cos(45054) * 45;
+acc += Math.sin(45054) + Math.cos(45055) * 46;
+acc += Math.sin(45055) + Math.cos(45056) * 47;
+acc += Math.sin(45056) + Math.cos(45057) * 48;
+acc += Math.sin(45057) + Math.cos(45058) * 49;
+acc += Math.sin(45058) + Math.cos(45059) * 50;
+acc += Math.sin(45059) + Math.cos(45060) * 51;
+acc += Math.sin(45060) + Math.cos(45061) * 52;
+acc += Math.sin(45061) + Math.cos(45062) * 53;
+acc += Math.sin(45062) + Math.cos(45063) * 54;
+acc += Math.sin(45063) + Math.cos(45064) * 55;
+acc += Math.sin(45064) + Math.cos(45065) * 56;
+acc += Math.sin(45065) + Math.cos(45066) * 57;
+acc += Math.sin(45066) + Math.cos(45067) * 58;
+acc += Math.sin(45067) + Math.cos(45068) * 59;
+acc += Math.sin(45068) + Math.cos(45069) * 60;
+acc += Math.sin(45069) + Math.cos(45070) * 61;
+acc += Math.sin(45070) + Math.cos(45071) * 62;
+acc += Math.sin(45071) + Math.cos(45072) * 63;
+acc += Math.sin(45072) + Math.cos(45073) * 64;
+acc += Math.sin(45073) + Math.cos(45074) * 65;
+acc += Math.sin(45074) + Math.cos(45075) * 66;
+acc += Math.sin(45075) + Math.cos(45076) * 67;
+acc += Math.sin(45076) + Math.cos(45077) * 68;
+acc += Math.sin(45077) + Math.cos(45078) * 69;
+acc += Math.sin(45078) + Math.cos(45079) * 70;
+acc += Math.sin(45079) + Math.cos(45080) * 71;
+acc += Math.sin(45080) + Math.cos(45081) * 72;
+acc += Math.sin(45081) + Math.cos(45082) * 73;
+acc += Math.sin(45082) + Math.cos(45083) * 74;
+acc += Math.sin(45083) + Math.cos(45084) * 75;
+acc += Math.sin(45084) + Math.cos(45085) * 76;
+acc += Math.sin(45085) + Math.cos(45086) * 77;
+acc += Math.sin(45086) + Math.cos(45087) * 78;
+acc += Math.sin(45087) + Math.cos(45088) * 79;
+acc += Math.sin(45088) + Math.cos(45089) * 80;
+acc += Math.sin(45089) + Math.cos(45090) * 81;
+acc += Math.sin(45090) + Math.cos(45091) * 82;
+acc += Math.sin(45091) + Math.cos(45092) * 83;
+acc += Math.sin(45092) + Math.cos(45093) * 84;
+acc += Math.sin(45093) + Math.cos(45094) * 85;
+acc += Math.sin(45094) + Math.cos(45095) * 86;
+acc += Math.sin(45095) + Math.cos(45096) * 87;
+acc += Math.sin(45096) + Math.cos(45097) * 88;
+acc += Math.sin(45097) + Math.cos(45098) * 89;
+acc += Math.sin(45098) + Math.cos(45099) * 90;
+acc += Math.sin(45099) + Math.cos(45100) * 91;
+acc += Math.sin(45100) + Math.cos(45101) * 92;
+acc += Math.sin(45101) + Math.cos(45102) * 93;
+acc += Math.sin(45102) + Math.cos(45103) * 94;
+acc += Math.sin(45103) + Math.cos(45104) * 95;
+acc += Math.sin(45104) + Math.cos(45105) * 96;
+acc += Math.sin(45105) + Math.cos(45106) * 0;
+acc += Math.sin(45106) + Math.cos(45107) * 1;
+acc += Math.sin(45107) + Math.cos(45108) * 2;
+acc += Math.sin(45108) + Math.cos(45109) * 3;
+acc += Math.sin(45109) + Math.cos(45110) * 4;
+acc += Math.sin(45110) + Math.cos(45111) * 5;
+acc += Math.sin(45111) + Math.cos(45112) * 6;
+acc += Math.sin(45112) + Math.cos(45113) * 7;
+acc += Math.sin(45113) + Math.cos(45114) * 8;
+acc += Math.sin(45114) + Math.cos(45115) * 9;
+acc += Math.sin(45115) + Math.cos(45116) * 10;
+acc += Math.sin(45116) + Math.cos(45117) * 11;
+acc += Math.sin(45117) + Math.cos(45118) * 12;
+acc += Math.sin(45118) + Math.cos(45119) * 13;
+acc += Math.sin(45119) + Math.cos(45120) * 14;
+acc += Math.sin(45120) + Math.cos(45121) * 15;
+acc += Math.sin(45121) + Math.cos(45122) * 16;
+acc += Math.sin(45122) + Math.cos(45123) * 17;
+acc += Math.sin(45123) + Math.cos(45124) * 18;
+acc += Math.sin(45124) + Math.cos(45125) * 19;
+acc += Math.sin(45125) + Math.cos(45126) * 20;
+acc += Math.sin(45126) + Math.cos(45127) * 21;
+acc += Math.sin(45127) + Math.cos(45128) * 22;
+acc += Math.sin(45128) + Math.cos(45129) * 23;
+acc += Math.sin(45129) + Math.cos(45130) * 24;
+acc += Math.sin(45130) + Math.cos(45131) * 25;
+acc += Math.sin(45131) + Math.cos(45132) * 26;
+acc += Math.sin(45132) + Math.cos(45133) * 27;
+acc += Math.sin(45133) + Math.cos(45134) * 28;
+acc += Math.sin(45134) + Math.cos(45135) * 29;
+acc += Math.sin(45135) + Math.cos(45136) * 30;
+acc += Math.sin(45136) + Math.cos(45137) * 31;
+acc += Math.sin(45137) + Math.cos(45138) * 32;
+acc += Math.sin(45138) + Math.cos(45139) * 33;
+acc += Math.sin(45139) + Math.cos(45140) * 34;
+acc += Math.sin(45140) + Math.cos(45141) * 35;
+acc += Math.sin(45141) + Math.cos(45142) * 36;
+acc += Math.sin(45142) + Math.cos(45143) * 37;
+acc += Math.sin(45143) + Math.cos(45144) * 38;
+acc += Math.sin(45144) + Math.cos(45145) * 39;
+acc += Math.sin(45145) + Math.cos(45146) * 40;
+acc += Math.sin(45146) + Math.cos(45147) * 41;
+acc += Math.sin(45147) + Math.cos(45148) * 42;
+acc += Math.sin(45148) + Math.cos(45149) * 43;
+acc += Math.sin(45149) + Math.cos(45150) * 44;
+acc += Math.sin(45150) + Math.cos(45151) * 45;
+acc += Math.sin(45151) + Math.cos(45152) * 46;
+acc += Math.sin(45152) + Math.cos(45153) * 47;
+acc += Math.sin(45153) + Math.cos(45154) * 48;
+acc += Math.sin(45154) + Math.cos(45155) * 49;
+acc += Math.sin(45155) + Math.cos(45156) * 50;
+acc += Math.sin(45156) + Math.cos(45157) * 51;
+acc += Math.sin(45157) + Math.cos(45158) * 52;
+acc += Math.sin(45158) + Math.cos(45159) * 53;
+acc += Math.sin(45159) + Math.cos(45160) * 54;
+acc += Math.sin(45160) + Math.cos(45161) * 55;
+acc += Math.sin(45161) + Math.cos(45162) * 56;
+acc += Math.sin(45162) + Math.cos(45163) * 57;
+acc += Math.sin(45163) + Math.cos(45164) * 58;
+acc += Math.sin(45164) + Math.cos(45165) * 59;
+acc += Math.sin(45165) + Math.cos(45166) * 60;
+acc += Math.sin(45166) + Math.cos(45167) * 61;
+acc += Math.sin(45167) + Math.cos(45168) * 62;
+acc += Math.sin(45168) + Math.cos(45169) * 63;
+acc += Math.sin(45169) + Math.cos(45170) * 64;
+acc += Math.sin(45170) + Math.cos(45171) * 65;
+acc += Math.sin(45171) + Math.cos(45172) * 66;
+acc += Math.sin(45172) + Math.cos(45173) * 67;
+acc += Math.sin(45173) + Math.cos(45174) * 68;
+acc += Math.sin(45174) + Math.cos(45175) * 69;
+acc += Math.sin(45175) + Math.cos(45176) * 70;
+acc += Math.sin(45176) + Math.cos(45177) * 71;
+acc += Math.sin(45177) + Math.cos(45178) * 72;
+acc += Math.sin(45178) + Math.cos(45179) * 73;
+acc += Math.sin(45179) + Math.cos(45180) * 74;
+acc += Math.sin(45180) + Math.cos(45181) * 75;
+acc += Math.sin(45181) + Math.cos(45182) * 76;
+acc += Math.sin(45182) + Math.cos(45183) * 77;
+acc += Math.sin(45183) + Math.cos(45184) * 78;
+acc += Math.sin(45184) + Math.cos(45185) * 79;
+acc += Math.sin(45185) + Math.cos(45186) * 80;
+acc += Math.sin(45186) + Math.cos(45187) * 81;
+acc += Math.sin(45187) + Math.cos(45188) * 82;
+acc += Math.sin(45188) + Math.cos(45189) * 83;
+acc += Math.sin(45189) + Math.cos(45190) * 84;
+acc += Math.sin(45190) + Math.cos(45191) * 85;
+acc += Math.sin(45191) + Math.cos(45192) * 86;
+acc += Math.sin(45192) + Math.cos(45193) * 87;
+acc += Math.sin(45193) + Math.cos(45194) * 88;
+acc += Math.sin(45194) + Math.cos(45195) * 89;
+acc += Math.sin(45195) + Math.cos(45196) * 90;
+acc += Math.sin(45196) + Math.cos(45197) * 91;
+acc += Math.sin(45197) + Math.cos(45198) * 92;
+acc += Math.sin(45198) + Math.cos(45199) * 93;
+acc += Math.sin(45199) + Math.cos(45200) * 94;
+acc += Math.sin(45200) + Math.cos(45201) * 95;
+acc += Math.sin(45201) + Math.cos(45202) * 96;
+acc += Math.sin(45202) + Math.cos(45203) * 0;
+acc += Math.sin(45203) + Math.cos(45204) * 1;
+acc += Math.sin(45204) + Math.cos(45205) * 2;
+acc += Math.sin(45205) + Math.cos(45206) * 3;
+acc += Math.sin(45206) + Math.cos(45207) * 4;
+acc += Math.sin(45207) + Math.cos(45208) * 5;
+acc += Math.sin(45208) + Math.cos(45209) * 6;
+acc += Math.sin(45209) + Math.cos(45210) * 7;
+acc += Math.sin(45210) + Math.cos(45211) * 8;
+acc += Math.sin(45211) + Math.cos(45212) * 9;
+acc += Math.sin(45212) + Math.cos(45213) * 10;
+acc += Math.sin(45213) + Math.cos(45214) * 11;
+acc += Math.sin(45214) + Math.cos(45215) * 12;
+acc += Math.sin(45215) + Math.cos(45216) * 13;
+acc += Math.sin(45216) + Math.cos(45217) * 14;
+acc += Math.sin(45217) + Math.cos(45218) * 15;
+acc += Math.sin(45218) + Math.cos(45219) * 16;
+acc += Math.sin(45219) + Math.cos(45220) * 17;
+acc += Math.sin(45220) + Math.cos(45221) * 18;
+acc += Math.sin(45221) + Math.cos(45222) * 19;
+acc += Math.sin(45222) + Math.cos(45223) * 20;
+acc += Math.sin(45223) + Math.cos(45224) * 21;
+acc += Math.sin(45224) + Math.cos(45225) * 22;
+acc += Math.sin(45225) + Math.cos(45226) * 23;
+acc += Math.sin(45226) + Math.cos(45227) * 24;
+acc += Math.sin(45227) + Math.cos(45228) * 25;
+acc += Math.sin(45228) + Math.cos(45229) * 26;
+acc += Math.sin(45229) + Math.cos(45230) * 27;
+acc += Math.sin(45230) + Math.cos(45231) * 28;
+acc += Math.sin(45231) + Math.cos(45232) * 29;
+acc += Math.sin(45232) + Math.cos(45233) * 30;
+acc += Math.sin(45233) + Math.cos(45234) * 31;
+acc += Math.sin(45234) + Math.cos(45235) * 32;
+acc += Math.sin(45235) + Math.cos(45236) * 33;
+acc += Math.sin(45236) + Math.cos(45237) * 34;
+acc += Math.sin(45237) + Math.cos(45238) * 35;
+acc += Math.sin(45238) + Math.cos(45239) * 36;
+acc += Math.sin(45239) + Math.cos(45240) * 37;
+acc += Math.sin(45240) + Math.cos(45241) * 38;
+acc += Math.sin(45241) + Math.cos(45242) * 39;
+acc += Math.sin(45242) + Math.cos(45243) * 40;
+acc += Math.sin(45243) + Math.cos(45244) * 41;
+acc += Math.sin(45244) + Math.cos(45245) * 42;
+acc += Math.sin(45245) + Math.cos(45246) * 43;
+acc += Math.sin(45246) + Math.cos(45247) * 44;
+acc += Math.sin(45247) + Math.cos(45248) * 45;
+acc += Math.sin(45248) + Math.cos(45249) * 46;
+acc += Math.sin(45249) + Math.cos(45250) * 47;
+acc += Math.sin(45250) + Math.cos(45251) * 48;
+acc += Math.sin(45251) + Math.cos(45252) * 49;
+acc += Math.sin(45252) + Math.cos(45253) * 50;
+acc += Math.sin(45253) + Math.cos(45254) * 51;
+acc += Math.sin(45254) + Math.cos(45255) * 52;
+acc += Math.sin(45255) + Math.cos(45256) * 53;
+acc += Math.sin(45256) + Math.cos(45257) * 54;
+acc += Math.sin(45257) + Math.cos(45258) * 55;
+acc += Math.sin(45258) + Math.cos(45259) * 56;
+acc += Math.sin(45259) + Math.cos(45260) * 57;
+acc += Math.sin(45260) + Math.cos(45261) * 58;
+acc += Math.sin(45261) + Math.cos(45262) * 59;
+acc += Math.sin(45262) + Math.cos(45263) * 60;
+acc += Math.sin(45263) + Math.cos(45264) * 61;
+acc += Math.sin(45264) + Math.cos(45265) * 62;
+acc += Math.sin(45265) + Math.cos(45266) * 63;
+acc += Math.sin(45266) + Math.cos(45267) * 64;
+acc += Math.sin(45267) + Math.cos(45268) * 65;
+acc += Math.sin(45268) + Math.cos(45269) * 66;
+acc += Math.sin(45269) + Math.cos(45270) * 67;
+acc += Math.sin(45270) + Math.cos(45271) * 68;
+acc += Math.sin(45271) + Math.cos(45272) * 69;
+acc += Math.sin(45272) + Math.cos(45273) * 70;
+acc += Math.sin(45273) + Math.cos(45274) * 71;
+acc += Math.sin(45274) + Math.cos(45275) * 72;
+acc += Math.sin(45275) + Math.cos(45276) * 73;
+acc += Math.sin(45276) + Math.cos(45277) * 74;
+acc += Math.sin(45277) + Math.cos(45278) * 75;
+acc += Math.sin(45278) + Math.cos(45279) * 76;
+acc += Math.sin(45279) + Math.cos(45280) * 77;
+acc += Math.sin(45280) + Math.cos(45281) * 78;
+acc += Math.sin(45281) + Math.cos(45282) * 79;
+acc += Math.sin(45282) + Math.cos(45283) * 80;
+acc += Math.sin(45283) + Math.cos(45284) * 81;
+acc += Math.sin(45284) + Math.cos(45285) * 82;
+acc += Math.sin(45285) + Math.cos(45286) * 83;
+acc += Math.sin(45286) + Math.cos(45287) * 84;
+acc += Math.sin(45287) + Math.cos(45288) * 85;
+acc += Math.sin(45288) + Math.cos(45289) * 86;
+acc += Math.sin(45289) + Math.cos(45290) * 87;
+acc += Math.sin(45290) + Math.cos(45291) * 88;
+acc += Math.sin(45291) + Math.cos(45292) * 89;
+acc += Math.sin(45292) + Math.cos(45293) * 90;
+acc += Math.sin(45293) + Math.cos(45294) * 91;
+acc += Math.sin(45294) + Math.cos(45295) * 92;
+acc += Math.sin(45295) + Math.cos(45296) * 93;
+acc += Math.sin(45296) + Math.cos(45297) * 94;
+acc += Math.sin(45297) + Math.cos(45298) * 95;
+acc += Math.sin(45298) + Math.cos(45299) * 96;
+acc += Math.sin(45299) + Math.cos(45300) * 0;
+acc += Math.sin(45300) + Math.cos(45301) * 1;
+acc += Math.sin(45301) + Math.cos(45302) * 2;
+acc += Math.sin(45302) + Math.cos(45303) * 3;
+acc += Math.sin(45303) + Math.cos(45304) * 4;
+acc += Math.sin(45304) + Math.cos(45305) * 5;
+acc += Math.sin(45305) + Math.cos(45306) * 6;
+acc += Math.sin(45306) + Math.cos(45307) * 7;
+acc += Math.sin(45307) + Math.cos(45308) * 8;
+acc += Math.sin(45308) + Math.cos(45309) * 9;
+acc += Math.sin(45309) + Math.cos(45310) * 10;
+acc += Math.sin(45310) + Math.cos(45311) * 11;
+acc += Math.sin(45311) + Math.cos(45312) * 12;
+acc += Math.sin(45312) + Math.cos(45313) * 13;
+acc += Math.sin(45313) + Math.cos(45314) * 14;
+acc += Math.sin(45314) + Math.cos(45315) * 15;
+acc += Math.sin(45315) + Math.cos(45316) * 16;
+acc += Math.sin(45316) + Math.cos(45317) * 17;
+acc += Math.sin(45317) + Math.cos(45318) * 18;
+acc += Math.sin(45318) + Math.cos(45319) * 19;
+acc += Math.sin(45319) + Math.cos(45320) * 20;
+acc += Math.sin(45320) + Math.cos(45321) * 21;
+acc += Math.sin(45321) + Math.cos(45322) * 22;
+acc += Math.sin(45322) + Math.cos(45323) * 23;
+acc += Math.sin(45323) + Math.cos(45324) * 24;
+acc += Math.sin(45324) + Math.cos(45325) * 25;
+acc += Math.sin(45325) + Math.cos(45326) * 26;
+acc += Math.sin(45326) + Math.cos(45327) * 27;
+acc += Math.sin(45327) + Math.cos(45328) * 28;
+acc += Math.sin(45328) + Math.cos(45329) * 29;
+acc += Math.sin(45329) + Math.cos(45330) * 30;
+acc += Math.sin(45330) + Math.cos(45331) * 31;
+acc += Math.sin(45331) + Math.cos(45332) * 32;
+acc += Math.sin(45332) + Math.cos(45333) * 33;
+acc += Math.sin(45333) + Math.cos(45334) * 34;
+acc += Math.sin(45334) + Math.cos(45335) * 35;
+acc += Math.sin(45335) + Math.cos(45336) * 36;
+acc += Math.sin(45336) + Math.cos(45337) * 37;
+acc += Math.sin(45337) + Math.cos(45338) * 38;
+acc += Math.sin(45338) + Math.cos(45339) * 39;
+acc += Math.sin(45339) + Math.cos(45340) * 40;
+acc += Math.sin(45340) + Math.cos(45341) * 41;
+acc += Math.sin(45341) + Math.cos(45342) * 42;
+acc += Math.sin(45342) + Math.cos(45343) * 43;
+acc += Math.sin(45343) + Math.cos(45344) * 44;
+acc += Math.sin(45344) + Math.cos(45345) * 45;
+acc += Math.sin(45345) + Math.cos(45346) * 46;
+acc += Math.sin(45346) + Math.cos(45347) * 47;
+acc += Math.sin(45347) + Math.cos(45348) * 48;
+acc += Math.sin(45348) + Math.cos(45349) * 49;
+acc += Math.sin(45349) + Math.cos(45350) * 50;
+acc += Math.sin(45350) + Math.cos(45351) * 51;
+acc += Math.sin(45351) + Math.cos(45352) * 52;
+acc += Math.sin(45352) + Math.cos(45353) * 53;
+acc += Math.sin(45353) + Math.cos(45354) * 54;
+acc += Math.sin(45354) + Math.cos(45355) * 55;
+acc += Math.sin(45355) + Math.cos(45356) * 56;
+acc += Math.sin(45356) + Math.cos(45357) * 57;
+acc += Math.sin(45357) + Math.cos(45358) * 58;
+acc += Math.sin(45358) + Math.cos(45359) * 59;
+acc += Math.sin(45359) + Math.cos(45360) * 60;
+acc += Math.sin(45360) + Math.cos(45361) * 61;
+acc += Math.sin(45361) + Math.cos(45362) * 62;
+acc += Math.sin(45362) + Math.cos(45363) * 63;
+acc += Math.sin(45363) + Math.cos(45364) * 64;
+acc += Math.sin(45364) + Math.cos(45365) * 65;
+acc += Math.sin(45365) + Math.cos(45366) * 66;
+acc += Math.sin(45366) + Math.cos(45367) * 67;
+acc += Math.sin(45367) + Math.cos(45368) * 68;
+acc += Math.sin(45368) + Math.cos(45369) * 69;
+acc += Math.sin(45369) + Math.cos(45370) * 70;
+acc += Math.sin(45370) + Math.cos(45371) * 71;
+acc += Math.sin(45371) + Math.cos(45372) * 72;
+acc += Math.sin(45372) + Math.cos(45373) * 73;
+acc += Math.sin(45373) + Math.cos(45374) * 74;
+acc += Math.sin(45374) + Math.cos(45375) * 75;
+acc += Math.sin(45375) + Math.cos(45376) * 76;
+acc += Math.sin(45376) + Math.cos(45377) * 77;
+acc += Math.sin(45377) + Math.cos(45378) * 78;
+acc += Math.sin(45378) + Math.cos(45379) * 79;
+acc += Math.sin(45379) + Math.cos(45380) * 80;
+acc += Math.sin(45380) + Math.cos(45381) * 81;
+acc += Math.sin(45381) + Math.cos(45382) * 82;
+acc += Math.sin(45382) + Math.cos(45383) * 83;
+acc += Math.sin(45383) + Math.cos(45384) * 84;
+acc += Math.sin(45384) + Math.cos(45385) * 85;
+acc += Math.sin(45385) + Math.cos(45386) * 86;
+acc += Math.sin(45386) + Math.cos(45387) * 87;
+acc += Math.sin(45387) + Math.cos(45388) * 88;
+acc += Math.sin(45388) + Math.cos(45389) * 89;
+acc += Math.sin(45389) + Math.cos(45390) * 90;
+acc += Math.sin(45390) + Math.cos(45391) * 91;
+acc += Math.sin(45391) + Math.cos(45392) * 92;
+acc += Math.sin(45392) + Math.cos(45393) * 93;
+acc += Math.sin(45393) + Math.cos(45394) * 94;
+acc += Math.sin(45394) + Math.cos(45395) * 95;
+acc += Math.sin(45395) + Math.cos(45396) * 96;
+acc += Math.sin(45396) + Math.cos(45397) * 0;
+acc += Math.sin(45397) + Math.cos(45398) * 1;
+acc += Math.sin(45398) + Math.cos(45399) * 2;
+acc += Math.sin(45399) + Math.cos(45400) * 3;
+acc += Math.sin(45400) + Math.cos(45401) * 4;
+acc += Math.sin(45401) + Math.cos(45402) * 5;
+acc += Math.sin(45402) + Math.cos(45403) * 6;
+acc += Math.sin(45403) + Math.cos(45404) * 7;
+acc += Math.sin(45404) + Math.cos(45405) * 8;
+acc += Math.sin(45405) + Math.cos(45406) * 9;
+acc += Math.sin(45406) + Math.cos(45407) * 10;
+acc += Math.sin(45407) + Math.cos(45408) * 11;
+acc += Math.sin(45408) + Math.cos(45409) * 12;
+acc += Math.sin(45409) + Math.cos(45410) * 13;
+acc += Math.sin(45410) + Math.cos(45411) * 14;
+acc += Math.sin(45411) + Math.cos(45412) * 15;
+acc += Math.sin(45412) + Math.cos(45413) * 16;
+acc += Math.sin(45413) + Math.cos(45414) * 17;
+acc += Math.sin(45414) + Math.cos(45415) * 18;
+acc += Math.sin(45415) + Math.cos(45416) * 19;
+acc += Math.sin(45416) + Math.cos(45417) * 20;
+acc += Math.sin(45417) + Math.cos(45418) * 21;
+acc += Math.sin(45418) + Math.cos(45419) * 22;
+acc += Math.sin(45419) + Math.cos(45420) * 23;
+acc += Math.sin(45420) + Math.cos(45421) * 24;
+acc += Math.sin(45421) + Math.cos(45422) * 25;
+acc += Math.sin(45422) + Math.cos(45423) * 26;
+acc += Math.sin(45423) + Math.cos(45424) * 27;
+acc += Math.sin(45424) + Math.cos(45425) * 28;
+acc += Math.sin(45425) + Math.cos(45426) * 29;
+acc += Math.sin(45426) + Math.cos(45427) * 30;
+acc += Math.sin(45427) + Math.cos(45428) * 31;
+acc += Math.sin(45428) + Math.cos(45429) * 32;
+acc += Math.sin(45429) + Math.cos(45430) * 33;
+acc += Math.sin(45430) + Math.cos(45431) * 34;
+acc += Math.sin(45431) + Math.cos(45432) * 35;
+acc += Math.sin(45432) + Math.cos(45433) * 36;
+acc += Math.sin(45433) + Math.cos(45434) * 37;
+acc += Math.sin(45434) + Math.cos(45435) * 38;
+acc += Math.sin(45435) + Math.cos(45436) * 39;
+acc += Math.sin(45436) + Math.cos(45437) * 40;
+acc += Math.sin(45437) + Math.cos(45438) * 41;
+acc += Math.sin(45438) + Math.cos(45439) * 42;
+acc += Math.sin(45439) + Math.cos(45440) * 43;
+acc += Math.sin(45440) + Math.cos(45441) * 44;
+acc += Math.sin(45441) + Math.cos(45442) * 45;
+acc += Math.sin(45442) + Math.cos(45443) * 46;
+acc += Math.sin(45443) + Math.cos(45444) * 47;
+acc += Math.sin(45444) + Math.cos(45445) * 48;
+acc += Math.sin(45445) + Math.cos(45446) * 49;
+acc += Math.sin(45446) + Math.cos(45447) * 50;
+acc += Math.sin(45447) + Math.cos(45448) * 51;
+acc += Math.sin(45448) + Math.cos(45449) * 52;
+acc += Math.sin(45449) + Math.cos(45450) * 53;
+acc += Math.sin(45450) + Math.cos(45451) * 54;
+acc += Math.sin(45451) + Math.cos(45452) * 55;
+acc += Math.sin(45452) + Math.cos(45453) * 56;
+acc += Math.sin(45453) + Math.cos(45454) * 57;
+acc += Math.sin(45454) + Math.cos(45455) * 58;
+acc += Math.sin(45455) + Math.cos(45456) * 59;
+acc += Math.sin(45456) + Math.cos(45457) * 60;
+acc += Math.sin(45457) + Math.cos(45458) * 61;
+acc += Math.sin(45458) + Math.cos(45459) * 62;
+acc += Math.sin(45459) + Math.cos(45460) * 63;
+acc += Math.sin(45460) + Math.cos(45461) * 64;
+acc += Math.sin(45461) + Math.cos(45462) * 65;
+acc += Math.sin(45462) + Math.cos(45463) * 66;
+acc += Math.sin(45463) + Math.cos(45464) * 67;
+acc += Math.sin(45464) + Math.cos(45465) * 68;
+acc += Math.sin(45465) + Math.cos(45466) * 69;
+acc += Math.sin(45466) + Math.cos(45467) * 70;
+acc += Math.sin(45467) + Math.cos(45468) * 71;
+acc += Math.sin(45468) + Math.cos(45469) * 72;
+acc += Math.sin(45469) + Math.cos(45470) * 73;
+acc += Math.sin(45470) + Math.cos(45471) * 74;
+acc += Math.sin(45471) + Math.cos(45472) * 75;
+acc += Math.sin(45472) + Math.cos(45473) * 76;
+acc += Math.sin(45473) + Math.cos(45474) * 77;
+acc += Math.sin(45474) + Math.cos(45475) * 78;
+acc += Math.sin(45475) + Math.cos(45476) * 79;
+acc += Math.sin(45476) + Math.cos(45477) * 80;
+acc += Math.sin(45477) + Math.cos(45478) * 81;
+acc += Math.sin(45478) + Math.cos(45479) * 82;
+acc += Math.sin(45479) + Math.cos(45480) * 83;
+acc += Math.sin(45480) + Math.cos(45481) * 84;
+acc += Math.sin(45481) + Math.cos(45482) * 85;
+acc += Math.sin(45482) + Math.cos(45483) * 86;
+acc += Math.sin(45483) + Math.cos(45484) * 87;
+acc += Math.sin(45484) + Math.cos(45485) * 88;
+acc += Math.sin(45485) + Math.cos(45486) * 89;
+acc += Math.sin(45486) + Math.cos(45487) * 90;
+acc += Math.sin(45487) + Math.cos(45488) * 91;
+acc += Math.sin(45488) + Math.cos(45489) * 92;
+acc += Math.sin(45489) + Math.cos(45490) * 93;
+acc += Math.sin(45490) + Math.cos(45491) * 94;
+acc += Math.sin(45491) + Math.cos(45492) * 95;
+acc += Math.sin(45492) + Math.cos(45493) * 96;
+acc += Math.sin(45493) + Math.cos(45494) * 0;
+acc += Math.sin(45494) + Math.cos(45495) * 1;
+acc += Math.sin(45495) + Math.cos(45496) * 2;
+acc += Math.sin(45496) + Math.cos(45497) * 3;
+acc += Math.sin(45497) + Math.cos(45498) * 4;
+acc += Math.sin(45498) + Math.cos(45499) * 5;
+acc += Math.sin(45499) + Math.cos(45500) * 6;
+acc += Math.sin(45500) + Math.cos(45501) * 7;
+acc += Math.sin(45501) + Math.cos(45502) * 8;
+acc += Math.sin(45502) + Math.cos(45503) * 9;
+acc += Math.sin(45503) + Math.cos(45504) * 10;
+acc += Math.sin(45504) + Math.cos(45505) * 11;
+acc += Math.sin(45505) + Math.cos(45506) * 12;
+acc += Math.sin(45506) + Math.cos(45507) * 13;
+acc += Math.sin(45507) + Math.cos(45508) * 14;
+acc += Math.sin(45508) + Math.cos(45509) * 15;
+acc += Math.sin(45509) + Math.cos(45510) * 16;
+acc += Math.sin(45510) + Math.cos(45511) * 17;
+acc += Math.sin(45511) + Math.cos(45512) * 18;
+acc += Math.sin(45512) + Math.cos(45513) * 19;
+acc += Math.sin(45513) + Math.cos(45514) * 20;
+acc += Math.sin(45514) + Math.cos(45515) * 21;
+acc += Math.sin(45515) + Math.cos(45516) * 22;
+acc += Math.sin(45516) + Math.cos(45517) * 23;
+acc += Math.sin(45517) + Math.cos(45518) * 24;
+acc += Math.sin(45518) + Math.cos(45519) * 25;
+acc += Math.sin(45519) + Math.cos(45520) * 26;
+acc += Math.sin(45520) + Math.cos(45521) * 27;
+acc += Math.sin(45521) + Math.cos(45522) * 28;
+acc += Math.sin(45522) + Math.cos(45523) * 29;
+acc += Math.sin(45523) + Math.cos(45524) * 30;
+acc += Math.sin(45524) + Math.cos(45525) * 31;
+acc += Math.sin(45525) + Math.cos(45526) * 32;
+acc += Math.sin(45526) + Math.cos(45527) * 33;
+acc += Math.sin(45527) + Math.cos(45528) * 34;
+acc += Math.sin(45528) + Math.cos(45529) * 35;
+acc += Math.sin(45529) + Math.cos(45530) * 36;
+acc += Math.sin(45530) + Math.cos(45531) * 37;
+acc += Math.sin(45531) + Math.cos(45532) * 38;
+acc += Math.sin(45532) + Math.cos(45533) * 39;
+acc += Math.sin(45533) + Math.cos(45534) * 40;
+acc += Math.sin(45534) + Math.cos(45535) * 41;
+acc += Math.sin(45535) + Math.cos(45536) * 42;
+acc += Math.sin(45536) + Math.cos(45537) * 43;
+acc += Math.sin(45537) + Math.cos(45538) * 44;
+acc += Math.sin(45538) + Math.cos(45539) * 45;
+acc += Math.sin(45539) + Math.cos(45540) * 46;
+acc += Math.sin(45540) + Math.cos(45541) * 47;
+acc += Math.sin(45541) + Math.cos(45542) * 48;
+acc += Math.sin(45542) + Math.cos(45543) * 49;
+acc += Math.sin(45543) + Math.cos(45544) * 50;
+acc += Math.sin(45544) + Math.cos(45545) * 51;
+acc += Math.sin(45545) + Math.cos(45546) * 52;
+acc += Math.sin(45546) + Math.cos(45547) * 53;
+acc += Math.sin(45547) + Math.cos(45548) * 54;
+acc += Math.sin(45548) + Math.cos(45549) * 55;
+acc += Math.sin(45549) + Math.cos(45550) * 56;
+acc += Math.sin(45550) + Math.cos(45551) * 57;
+acc += Math.sin(45551) + Math.cos(45552) * 58;
+acc += Math.sin(45552) + Math.cos(45553) * 59;
+acc += Math.sin(45553) + Math.cos(45554) * 60;
+acc += Math.sin(45554) + Math.cos(45555) * 61;
+acc += Math.sin(45555) + Math.cos(45556) * 62;
+acc += Math.sin(45556) + Math.cos(45557) * 63;
+acc += Math.sin(45557) + Math.cos(45558) * 64;
+acc += Math.sin(45558) + Math.cos(45559) * 65;
+acc += Math.sin(45559) + Math.cos(45560) * 66;
+acc += Math.sin(45560) + Math.cos(45561) * 67;
+acc += Math.sin(45561) + Math.cos(45562) * 68;
+acc += Math.sin(45562) + Math.cos(45563) * 69;
+acc += Math.sin(45563) + Math.cos(45564) * 70;
+acc += Math.sin(45564) + Math.cos(45565) * 71;
+acc += Math.sin(45565) + Math.cos(45566) * 72;
+acc += Math.sin(45566) + Math.cos(45567) * 73;
+acc += Math.sin(45567) + Math.cos(45568) * 74;
+acc += Math.sin(45568) + Math.cos(45569) * 75;
+acc += Math.sin(45569) + Math.cos(45570) * 76;
+acc += Math.sin(45570) + Math.cos(45571) * 77;
+acc += Math.sin(45571) + Math.cos(45572) * 78;
+acc += Math.sin(45572) + Math.cos(45573) * 79;
+acc += Math.sin(45573) + Math.cos(45574) * 80;
+acc += Math.sin(45574) + Math.cos(45575) * 81;
+acc += Math.sin(45575) + Math.cos(45576) * 82;
+acc += Math.sin(45576) + Math.cos(45577) * 83;
+acc += Math.sin(45577) + Math.cos(45578) * 84;
+acc += Math.sin(45578) + Math.cos(45579) * 85;
+acc += Math.sin(45579) + Math.cos(45580) * 86;
+acc += Math.sin(45580) + Math.cos(45581) * 87;
+acc += Math.sin(45581) + Math.cos(45582) * 88;
+acc += Math.sin(45582) + Math.cos(45583) * 89;
+acc += Math.sin(45583) + Math.cos(45584) * 90;
+acc += Math.sin(45584) + Math.cos(45585) * 91;
+acc += Math.sin(45585) + Math.cos(45586) * 92;
+acc += Math.sin(45586) + Math.cos(45587) * 93;
+acc += Math.sin(45587) + Math.cos(45588) * 94;
+acc += Math.sin(45588) + Math.cos(45589) * 95;
+acc += Math.sin(45589) + Math.cos(45590) * 96;
+acc += Math.sin(45590) + Math.cos(45591) * 0;
+acc += Math.sin(45591) + Math.cos(45592) * 1;
+acc += Math.sin(45592) + Math.cos(45593) * 2;
+acc += Math.sin(45593) + Math.cos(45594) * 3;
+acc += Math.sin(45594) + Math.cos(45595) * 4;
+acc += Math.sin(45595) + Math.cos(45596) * 5;
+acc += Math.sin(45596) + Math.cos(45597) * 6;
+acc += Math.sin(45597) + Math.cos(45598) * 7;
+acc += Math.sin(45598) + Math.cos(45599) * 8;
+acc += Math.sin(45599) + Math.cos(45600) * 9;
+acc += Math.sin(45600) + Math.cos(45601) * 10;
+acc += Math.sin(45601) + Math.cos(45602) * 11;
+acc += Math.sin(45602) + Math.cos(45603) * 12;
+acc += Math.sin(45603) + Math.cos(45604) * 13;
+acc += Math.sin(45604) + Math.cos(45605) * 14;
+acc += Math.sin(45605) + Math.cos(45606) * 15;
+acc += Math.sin(45606) + Math.cos(45607) * 16;
+acc += Math.sin(45607) + Math.cos(45608) * 17;
+acc += Math.sin(45608) + Math.cos(45609) * 18;
+acc += Math.sin(45609) + Math.cos(45610) * 19;
+acc += Math.sin(45610) + Math.cos(45611) * 20;
+acc += Math.sin(45611) + Math.cos(45612) * 21;
+acc += Math.sin(45612) + Math.cos(45613) * 22;
+acc += Math.sin(45613) + Math.cos(45614) * 23;
+acc += Math.sin(45614) + Math.cos(45615) * 24;
+acc += Math.sin(45615) + Math.cos(45616) * 25;
+acc += Math.sin(45616) + Math.cos(45617) * 26;
+acc += Math.sin(45617) + Math.cos(45618) * 27;
+acc += Math.sin(45618) + Math.cos(45619) * 28;
+acc += Math.sin(45619) + Math.cos(45620) * 29;
+acc += Math.sin(45620) + Math.cos(45621) * 30;
+acc += Math.sin(45621) + Math.cos(45622) * 31;
+acc += Math.sin(45622) + Math.cos(45623) * 32;
+acc += Math.sin(45623) + Math.cos(45624) * 33;
+acc += Math.sin(45624) + Math.cos(45625) * 34;
+acc += Math.sin(45625) + Math.cos(45626) * 35;
+acc += Math.sin(45626) + Math.cos(45627) * 36;
+acc += Math.sin(45627) + Math.cos(45628) * 37;
+acc += Math.sin(45628) + Math.cos(45629) * 38;
+acc += Math.sin(45629) + Math.cos(45630) * 39;
+acc += Math.sin(45630) + Math.cos(45631) * 40;
+acc += Math.sin(45631) + Math.cos(45632) * 41;
+acc += Math.sin(45632) + Math.cos(45633) * 42;
+acc += Math.sin(45633) + Math.cos(45634) * 43;
+acc += Math.sin(45634) + Math.cos(45635) * 44;
+acc += Math.sin(45635) + Math.cos(45636) * 45;
+acc += Math.sin(45636) + Math.cos(45637) * 46;
+acc += Math.sin(45637) + Math.cos(45638) * 47;
+acc += Math.sin(45638) + Math.cos(45639) * 48;
+acc += Math.sin(45639) + Math.cos(45640) * 49;
+acc += Math.sin(45640) + Math.cos(45641) * 50;
+acc += Math.sin(45641) + Math.cos(45642) * 51;
+acc += Math.sin(45642) + Math.cos(45643) * 52;
+acc += Math.sin(45643) + Math.cos(45644) * 53;
+acc += Math.sin(45644) + Math.cos(45645) * 54;
+acc += Math.sin(45645) + Math.cos(45646) * 55;
+acc += Math.sin(45646) + Math.cos(45647) * 56;
+acc += Math.sin(45647) + Math.cos(45648) * 57;
+acc += Math.sin(45648) + Math.cos(45649) * 58;
+acc += Math.sin(45649) + Math.cos(45650) * 59;
+acc += Math.sin(45650) + Math.cos(45651) * 60;
+acc += Math.sin(45651) + Math.cos(45652) * 61;
+acc += Math.sin(45652) + Math.cos(45653) * 62;
+acc += Math.sin(45653) + Math.cos(45654) * 63;
+acc += Math.sin(45654) + Math.cos(45655) * 64;
+acc += Math.sin(45655) + Math.cos(45656) * 65;
+acc += Math.sin(45656) + Math.cos(45657) * 66;
+acc += Math.sin(45657) + Math.cos(45658) * 67;
+acc += Math.sin(45658) + Math.cos(45659) * 68;
+acc += Math.sin(45659) + Math.cos(45660) * 69;
+acc += Math.sin(45660) + Math.cos(45661) * 70;
+acc += Math.sin(45661) + Math.cos(45662) * 71;
+acc += Math.sin(45662) + Math.cos(45663) * 72;
+acc += Math.sin(45663) + Math.cos(45664) * 73;
+acc += Math.sin(45664) + Math.cos(45665) * 74;
+acc += Math.sin(45665) + Math.cos(45666) * 75;
+acc += Math.sin(45666) + Math.cos(45667) * 76;
+acc += Math.sin(45667) + Math.cos(45668) * 77;
+acc += Math.sin(45668) + Math.cos(45669) * 78;
+acc += Math.sin(45669) + Math.cos(45670) * 79;
+acc += Math.sin(45670) + Math.cos(45671) * 80;
+acc += Math.sin(45671) + Math.cos(45672) * 81;
+acc += Math.sin(45672) + Math.cos(45673) * 82;
+acc += Math.sin(45673) + Math.cos(45674) * 83;
+acc += Math.sin(45674) + Math.cos(45675) * 84;
+acc += Math.sin(45675) + Math.cos(45676) * 85;
+acc += Math.sin(45676) + Math.cos(45677) * 86;
+acc += Math.sin(45677) + Math.cos(45678) * 87;
+acc += Math.sin(45678) + Math.cos(45679) * 88;
+acc += Math.sin(45679) + Math.cos(45680) * 89;
+acc += Math.sin(45680) + Math.cos(45681) * 90;
+acc += Math.sin(45681) + Math.cos(45682) * 91;
+acc += Math.sin(45682) + Math.cos(45683) * 92;
+acc += Math.sin(45683) + Math.cos(45684) * 93;
+acc += Math.sin(45684) + Math.cos(45685) * 94;
+acc += Math.sin(45685) + Math.cos(45686) * 95;
+acc += Math.sin(45686) + Math.cos(45687) * 96;
+acc += Math.sin(45687) + Math.cos(45688) * 0;
+acc += Math.sin(45688) + Math.cos(45689) * 1;
+acc += Math.sin(45689) + Math.cos(45690) * 2;
+acc += Math.sin(45690) + Math.cos(45691) * 3;
+acc += Math.sin(45691) + Math.cos(45692) * 4;
+acc += Math.sin(45692) + Math.cos(45693) * 5;
+acc += Math.sin(45693) + Math.cos(45694) * 6;
+acc += Math.sin(45694) + Math.cos(45695) * 7;
+acc += Math.sin(45695) + Math.cos(45696) * 8;
+acc += Math.sin(45696) + Math.cos(45697) * 9;
+acc += Math.sin(45697) + Math.cos(45698) * 10;
+acc += Math.sin(45698) + Math.cos(45699) * 11;
+acc += Math.sin(45699) + Math.cos(45700) * 12;
+acc += Math.sin(45700) + Math.cos(45701) * 13;
+acc += Math.sin(45701) + Math.cos(45702) * 14;
+acc += Math.sin(45702) + Math.cos(45703) * 15;
+acc += Math.sin(45703) + Math.cos(45704) * 16;
+acc += Math.sin(45704) + Math.cos(45705) * 17;
+acc += Math.sin(45705) + Math.cos(45706) * 18;
+acc += Math.sin(45706) + Math.cos(45707) * 19;
+acc += Math.sin(45707) + Math.cos(45708) * 20;
+acc += Math.sin(45708) + Math.cos(45709) * 21;
+acc += Math.sin(45709) + Math.cos(45710) * 22;
+acc += Math.sin(45710) + Math.cos(45711) * 23;
+acc += Math.sin(45711) + Math.cos(45712) * 24;
+acc += Math.sin(45712) + Math.cos(45713) * 25;
+acc += Math.sin(45713) + Math.cos(45714) * 26;
+acc += Math.sin(45714) + Math.cos(45715) * 27;
+acc += Math.sin(45715) + Math.cos(45716) * 28;
+acc += Math.sin(45716) + Math.cos(45717) * 29;
+acc += Math.sin(45717) + Math.cos(45718) * 30;
+acc += Math.sin(45718) + Math.cos(45719) * 31;
+acc += Math.sin(45719) + Math.cos(45720) * 32;
+acc += Math.sin(45720) + Math.cos(45721) * 33;
+acc += Math.sin(45721) + Math.cos(45722) * 34;
+acc += Math.sin(45722) + Math.cos(45723) * 35;
+acc += Math.sin(45723) + Math.cos(45724) * 36;
+acc += Math.sin(45724) + Math.cos(45725) * 37;
+acc += Math.sin(45725) + Math.cos(45726) * 38;
+acc += Math.sin(45726) + Math.cos(45727) * 39;
+acc += Math.sin(45727) + Math.cos(45728) * 40;
+acc += Math.sin(45728) + Math.cos(45729) * 41;
+acc += Math.sin(45729) + Math.cos(45730) * 42;
+acc += Math.sin(45730) + Math.cos(45731) * 43;
+acc += Math.sin(45731) + Math.cos(45732) * 44;
+acc += Math.sin(45732) + Math.cos(45733) * 45;
+acc += Math.sin(45733) + Math.cos(45734) * 46;
+acc += Math.sin(45734) + Math.cos(45735) * 47;
+acc += Math.sin(45735) + Math.cos(45736) * 48;
+acc += Math.sin(45736) + Math.cos(45737) * 49;
+acc += Math.sin(45737) + Math.cos(45738) * 50;
+acc += Math.sin(45738) + Math.cos(45739) * 51;
+acc += Math.sin(45739) + Math.cos(45740) * 52;
+acc += Math.sin(45740) + Math.cos(45741) * 53;
+acc += Math.sin(45741) + Math.cos(45742) * 54;
+acc += Math.sin(45742) + Math.cos(45743) * 55;
+acc += Math.sin(45743) + Math.cos(45744) * 56;
+acc += Math.sin(45744) + Math.cos(45745) * 57;
+acc += Math.sin(45745) + Math.cos(45746) * 58;
+acc += Math.sin(45746) + Math.cos(45747) * 59;
+acc += Math.sin(45747) + Math.cos(45748) * 60;
+acc += Math.sin(45748) + Math.cos(45749) * 61;
+acc += Math.sin(45749) + Math.cos(45750) * 62;
+acc += Math.sin(45750) + Math.cos(45751) * 63;
+acc += Math.sin(45751) + Math.cos(45752) * 64;
+acc += Math.sin(45752) + Math.cos(45753) * 65;
+acc += Math.sin(45753) + Math.cos(45754) * 66;
+acc += Math.sin(45754) + Math.cos(45755) * 67;
+acc += Math.sin(45755) + Math.cos(45756) * 68;
+acc += Math.sin(45756) + Math.cos(45757) * 69;
+acc += Math.sin(45757) + Math.cos(45758) * 70;
+acc += Math.sin(45758) + Math.cos(45759) * 71;
+acc += Math.sin(45759) + Math.cos(45760) * 72;
+acc += Math.sin(45760) + Math.cos(45761) * 73;
+acc += Math.sin(45761) + Math.cos(45762) * 74;
+acc += Math.sin(45762) + Math.cos(45763) * 75;
+acc += Math.sin(45763) + Math.cos(45764) * 76;
+acc += Math.sin(45764) + Math.cos(45765) * 77;
+acc += Math.sin(45765) + Math.cos(45766) * 78;
+acc += Math.sin(45766) + Math.cos(45767) * 79;
+acc += Math.sin(45767) + Math.cos(45768) * 80;
+acc += Math.sin(45768) + Math.cos(45769) * 81;
+acc += Math.sin(45769) + Math.cos(45770) * 82;
+acc += Math.sin(45770) + Math.cos(45771) * 83;
+acc += Math.sin(45771) + Math.cos(45772) * 84;
+acc += Math.sin(45772) + Math.cos(45773) * 85;
+acc += Math.sin(45773) + Math.cos(45774) * 86;
+acc += Math.sin(45774) + Math.cos(45775) * 87;
+acc += Math.sin(45775) + Math.cos(45776) * 88;
+acc += Math.sin(45776) + Math.cos(45777) * 89;
+acc += Math.sin(45777) + Math.cos(45778) * 90;
+acc += Math.sin(45778) + Math.cos(45779) * 91;
+acc += Math.sin(45779) + Math.cos(45780) * 92;
+acc += Math.sin(45780) + Math.cos(45781) * 93;
+acc += Math.sin(45781) + Math.cos(45782) * 94;
+acc += Math.sin(45782) + Math.cos(45783) * 95;
+acc += Math.sin(45783) + Math.cos(45784) * 96;
+acc += Math.sin(45784) + Math.cos(45785) * 0;
+acc += Math.sin(45785) + Math.cos(45786) * 1;
+acc += Math.sin(45786) + Math.cos(45787) * 2;
+acc += Math.sin(45787) + Math.cos(45788) * 3;
+acc += Math.sin(45788) + Math.cos(45789) * 4;
+acc += Math.sin(45789) + Math.cos(45790) * 5;
+acc += Math.sin(45790) + Math.cos(45791) * 6;
+acc += Math.sin(45791) + Math.cos(45792) * 7;
+acc += Math.sin(45792) + Math.cos(45793) * 8;
+acc += Math.sin(45793) + Math.cos(45794) * 9;
+acc += Math.sin(45794) + Math.cos(45795) * 10;
+acc += Math.sin(45795) + Math.cos(45796) * 11;
+acc += Math.sin(45796) + Math.cos(45797) * 12;
+acc += Math.sin(45797) + Math.cos(45798) * 13;
+acc += Math.sin(45798) + Math.cos(45799) * 14;
+acc += Math.sin(45799) + Math.cos(45800) * 15;
+acc += Math.sin(45800) + Math.cos(45801) * 16;
+acc += Math.sin(45801) + Math.cos(45802) * 17;
+acc += Math.sin(45802) + Math.cos(45803) * 18;
+acc += Math.sin(45803) + Math.cos(45804) * 19;
+acc += Math.sin(45804) + Math.cos(45805) * 20;
+acc += Math.sin(45805) + Math.cos(45806) * 21;
+acc += Math.sin(45806) + Math.cos(45807) * 22;
+acc += Math.sin(45807) + Math.cos(45808) * 23;
+acc += Math.sin(45808) + Math.cos(45809) * 24;
+acc += Math.sin(45809) + Math.cos(45810) * 25;
+acc += Math.sin(45810) + Math.cos(45811) * 26;
+acc += Math.sin(45811) + Math.cos(45812) * 27;
+acc += Math.sin(45812) + Math.cos(45813) * 28;
+acc += Math.sin(45813) + Math.cos(45814) * 29;
+acc += Math.sin(45814) + Math.cos(45815) * 30;
+acc += Math.sin(45815) + Math.cos(45816) * 31;
+acc += Math.sin(45816) + Math.cos(45817) * 32;
+acc += Math.sin(45817) + Math.cos(45818) * 33;
+acc += Math.sin(45818) + Math.cos(45819) * 34;
+acc += Math.sin(45819) + Math.cos(45820) * 35;
+acc += Math.sin(45820) + Math.cos(45821) * 36;
+acc += Math.sin(45821) + Math.cos(45822) * 37;
+acc += Math.sin(45822) + Math.cos(45823) * 38;
+acc += Math.sin(45823) + Math.cos(45824) * 39;
+acc += Math.sin(45824) + Math.cos(45825) * 40;
+acc += Math.sin(45825) + Math.cos(45826) * 41;
+acc += Math.sin(45826) + Math.cos(45827) * 42;
+acc += Math.sin(45827) + Math.cos(45828) * 43;
+acc += Math.sin(45828) + Math.cos(45829) * 44;
+acc += Math.sin(45829) + Math.cos(45830) * 45;
+acc += Math.sin(45830) + Math.cos(45831) * 46;
+acc += Math.sin(45831) + Math.cos(45832) * 47;
+acc += Math.sin(45832) + Math.cos(45833) * 48;
+acc += Math.sin(45833) + Math.cos(45834) * 49;
+acc += Math.sin(45834) + Math.cos(45835) * 50;
+acc += Math.sin(45835) + Math.cos(45836) * 51;
+acc += Math.sin(45836) + Math.cos(45837) * 52;
+acc += Math.sin(45837) + Math.cos(45838) * 53;
+acc += Math.sin(45838) + Math.cos(45839) * 54;
+acc += Math.sin(45839) + Math.cos(45840) * 55;
+acc += Math.sin(45840) + Math.cos(45841) * 56;
+acc += Math.sin(45841) + Math.cos(45842) * 57;
+acc += Math.sin(45842) + Math.cos(45843) * 58;
+acc += Math.sin(45843) + Math.cos(45844) * 59;
+acc += Math.sin(45844) + Math.cos(45845) * 60;
+acc += Math.sin(45845) + Math.cos(45846) * 61;
+acc += Math.sin(45846) + Math.cos(45847) * 62;
+acc += Math.sin(45847) + Math.cos(45848) * 63;
+acc += Math.sin(45848) + Math.cos(45849) * 64;
+acc += Math.sin(45849) + Math.cos(45850) * 65;
+acc += Math.sin(45850) + Math.cos(45851) * 66;
+acc += Math.sin(45851) + Math.cos(45852) * 67;
+acc += Math.sin(45852) + Math.cos(45853) * 68;
+acc += Math.sin(45853) + Math.cos(45854) * 69;
+acc += Math.sin(45854) + Math.cos(45855) * 70;
+acc += Math.sin(45855) + Math.cos(45856) * 71;
+acc += Math.sin(45856) + Math.cos(45857) * 72;
+acc += Math.sin(45857) + Math.cos(45858) * 73;
+acc += Math.sin(45858) + Math.cos(45859) * 74;
+acc += Math.sin(45859) + Math.cos(45860) * 75;
+acc += Math.sin(45860) + Math.cos(45861) * 76;
+acc += Math.sin(45861) + Math.cos(45862) * 77;
+acc += Math.sin(45862) + Math.cos(45863) * 78;
+acc += Math.sin(45863) + Math.cos(45864) * 79;
+acc += Math.sin(45864) + Math.cos(45865) * 80;
+acc += Math.sin(45865) + Math.cos(45866) * 81;
+acc += Math.sin(45866) + Math.cos(45867) * 82;
+acc += Math.sin(45867) + Math.cos(45868) * 83;
+acc += Math.sin(45868) + Math.cos(45869) * 84;
+acc += Math.sin(45869) + Math.cos(45870) * 85;
+acc += Math.sin(45870) + Math.cos(45871) * 86;
+acc += Math.sin(45871) + Math.cos(45872) * 87;
+acc += Math.sin(45872) + Math.cos(45873) * 88;
+acc += Math.sin(45873) + Math.cos(45874) * 89;
+acc += Math.sin(45874) + Math.cos(45875) * 90;
+acc += Math.sin(45875) + Math.cos(45876) * 91;
+acc += Math.sin(45876) + Math.cos(45877) * 92;
+acc += Math.sin(45877) + Math.cos(45878) * 93;
+acc += Math.sin(45878) + Math.cos(45879) * 94;
+acc += Math.sin(45879) + Math.cos(45880) * 95;
+acc += Math.sin(45880) + Math.cos(45881) * 96;
+acc += Math.sin(45881) + Math.cos(45882) * 0;
+acc += Math.sin(45882) + Math.cos(45883) * 1;
+acc += Math.sin(45883) + Math.cos(45884) * 2;
+acc += Math.sin(45884) + Math.cos(45885) * 3;
+acc += Math.sin(45885) + Math.cos(45886) * 4;
+acc += Math.sin(45886) + Math.cos(45887) * 5;
+acc += Math.sin(45887) + Math.cos(45888) * 6;
+acc += Math.sin(45888) + Math.cos(45889) * 7;
+acc += Math.sin(45889) + Math.cos(45890) * 8;
+acc += Math.sin(45890) + Math.cos(45891) * 9;
+acc += Math.sin(45891) + Math.cos(45892) * 10;
+acc += Math.sin(45892) + Math.cos(45893) * 11;
+acc += Math.sin(45893) + Math.cos(45894) * 12;
+acc += Math.sin(45894) + Math.cos(45895) * 13;
+acc += Math.sin(45895) + Math.cos(45896) * 14;
+acc += Math.sin(45896) + Math.cos(45897) * 15;
+acc += Math.sin(45897) + Math.cos(45898) * 16;
+acc += Math.sin(45898) + Math.cos(45899) * 17;
+acc += Math.sin(45899) + Math.cos(45900) * 18;
+acc += Math.sin(45900) + Math.cos(45901) * 19;
+acc += Math.sin(45901) + Math.cos(45902) * 20;
+acc += Math.sin(45902) + Math.cos(45903) * 21;
+acc += Math.sin(45903) + Math.cos(45904) * 22;
+acc += Math.sin(45904) + Math.cos(45905) * 23;
+acc += Math.sin(45905) + Math.cos(45906) * 24;
+acc += Math.sin(45906) + Math.cos(45907) * 25;
+acc += Math.sin(45907) + Math.cos(45908) * 26;
+acc += Math.sin(45908) + Math.cos(45909) * 27;
+acc += Math.sin(45909) + Math.cos(45910) * 28;
+acc += Math.sin(45910) + Math.cos(45911) * 29;
+acc += Math.sin(45911) + Math.cos(45912) * 30;
+acc += Math.sin(45912) + Math.cos(45913) * 31;
+acc += Math.sin(45913) + Math.cos(45914) * 32;
+acc += Math.sin(45914) + Math.cos(45915) * 33;
+acc += Math.sin(45915) + Math.cos(45916) * 34;
+acc += Math.sin(45916) + Math.cos(45917) * 35;
+acc += Math.sin(45917) + Math.cos(45918) * 36;
+acc += Math.sin(45918) + Math.cos(45919) * 37;
+acc += Math.sin(45919) + Math.cos(45920) * 38;
+acc += Math.sin(45920) + Math.cos(45921) * 39;
+acc += Math.sin(45921) + Math.cos(45922) * 40;
+acc += Math.sin(45922) + Math.cos(45923) * 41;
+acc += Math.sin(45923) + Math.cos(45924) * 42;
+acc += Math.sin(45924) + Math.cos(45925) * 43;
+acc += Math.sin(45925) + Math.cos(45926) * 44;
+acc += Math.sin(45926) + Math.cos(45927) * 45;
+acc += Math.sin(45927) + Math.cos(45928) * 46;
+acc += Math.sin(45928) + Math.cos(45929) * 47;
+acc += Math.sin(45929) + Math.cos(45930) * 48;
+acc += Math.sin(45930) + Math.cos(45931) * 49;
+acc += Math.sin(45931) + Math.cos(45932) * 50;
+acc += Math.sin(45932) + Math.cos(45933) * 51;
+acc += Math.sin(45933) + Math.cos(45934) * 52;
+acc += Math.sin(45934) + Math.cos(45935) * 53;
+acc += Math.sin(45935) + Math.cos(45936) * 54;
+acc += Math.sin(45936) + Math.cos(45937) * 55;
+acc += Math.sin(45937) + Math.cos(45938) * 56;
+acc += Math.sin(45938) + Math.cos(45939) * 57;
+acc += Math.sin(45939) + Math.cos(45940) * 58;
+acc += Math.sin(45940) + Math.cos(45941) * 59;
+acc += Math.sin(45941) + Math.cos(45942) * 60;
+acc += Math.sin(45942) + Math.cos(45943) * 61;
+acc += Math.sin(45943) + Math.cos(45944) * 62;
+acc += Math.sin(45944) + Math.cos(45945) * 63;
+acc += Math.sin(45945) + Math.cos(45946) * 64;
+acc += Math.sin(45946) + Math.cos(45947) * 65;
+acc += Math.sin(45947) + Math.cos(45948) * 66;
+acc += Math.sin(45948) + Math.cos(45949) * 67;
+acc += Math.sin(45949) + Math.cos(45950) * 68;
+acc += Math.sin(45950) + Math.cos(45951) * 69;
+acc += Math.sin(45951) + Math.cos(45952) * 70;
+acc += Math.sin(45952) + Math.cos(45953) * 71;
+acc += Math.sin(45953) + Math.cos(45954) * 72;
+acc += Math.sin(45954) + Math.cos(45955) * 73;
+acc += Math.sin(45955) + Math.cos(45956) * 74;
+acc += Math.sin(45956) + Math.cos(45957) * 75;
+acc += Math.sin(45957) + Math.cos(45958) * 76;
+acc += Math.sin(45958) + Math.cos(45959) * 77;
+acc += Math.sin(45959) + Math.cos(45960) * 78;
+acc += Math.sin(45960) + Math.cos(45961) * 79;
+acc += Math.sin(45961) + Math.cos(45962) * 80;
+acc += Math.sin(45962) + Math.cos(45963) * 81;
+acc += Math.sin(45963) + Math.cos(45964) * 82;
+acc += Math.sin(45964) + Math.cos(45965) * 83;
+acc += Math.sin(45965) + Math.cos(45966) * 84;
+acc += Math.sin(45966) + Math.cos(45967) * 85;
+acc += Math.sin(45967) + Math.cos(45968) * 86;
+acc += Math.sin(45968) + Math.cos(45969) * 87;
+acc += Math.sin(45969) + Math.cos(45970) * 88;
+acc += Math.sin(45970) + Math.cos(45971) * 89;
+acc += Math.sin(45971) + Math.cos(45972) * 90;
+acc += Math.sin(45972) + Math.cos(45973) * 91;
+acc += Math.sin(45973) + Math.cos(45974) * 92;
+acc += Math.sin(45974) + Math.cos(45975) * 93;
+acc += Math.sin(45975) + Math.cos(45976) * 94;
+acc += Math.sin(45976) + Math.cos(45977) * 95;
+acc += Math.sin(45977) + Math.cos(45978) * 96;
+acc += Math.sin(45978) + Math.cos(45979) * 0;
+acc += Math.sin(45979) + Math.cos(45980) * 1;
+acc += Math.sin(45980) + Math.cos(45981) * 2;
+acc += Math.sin(45981) + Math.cos(45982) * 3;
+acc += Math.sin(45982) + Math.cos(45983) * 4;
+acc += Math.sin(45983) + Math.cos(45984) * 5;
+acc += Math.sin(45984) + Math.cos(45985) * 6;
+acc += Math.sin(45985) + Math.cos(45986) * 7;
+acc += Math.sin(45986) + Math.cos(45987) * 8;
+acc += Math.sin(45987) + Math.cos(45988) * 9;
+acc += Math.sin(45988) + Math.cos(45989) * 10;
+acc += Math.sin(45989) + Math.cos(45990) * 11;
+acc += Math.sin(45990) + Math.cos(45991) * 12;
+acc += Math.sin(45991) + Math.cos(45992) * 13;
+acc += Math.sin(45992) + Math.cos(45993) * 14;
+acc += Math.sin(45993) + Math.cos(45994) * 15;
+acc += Math.sin(45994) + Math.cos(45995) * 16;
+acc += Math.sin(45995) + Math.cos(45996) * 17;
+acc += Math.sin(45996) + Math.cos(45997) * 18;
+acc += Math.sin(45997) + Math.cos(45998) * 19;
+acc += Math.sin(45998) + Math.cos(45999) * 20;
+acc += Math.sin(45999) + Math.cos(46000) * 21;
+acc += Math.sin(46000) + Math.cos(46001) * 22;
+acc += Math.sin(46001) + Math.cos(46002) * 23;
+acc += Math.sin(46002) + Math.cos(46003) * 24;
+acc += Math.sin(46003) + Math.cos(46004) * 25;
+acc += Math.sin(46004) + Math.cos(46005) * 26;
+acc += Math.sin(46005) + Math.cos(46006) * 27;
+acc += Math.sin(46006) + Math.cos(46007) * 28;
+acc += Math.sin(46007) + Math.cos(46008) * 29;
+acc += Math.sin(46008) + Math.cos(46009) * 30;
+acc += Math.sin(46009) + Math.cos(46010) * 31;
+acc += Math.sin(46010) + Math.cos(46011) * 32;
+acc += Math.sin(46011) + Math.cos(46012) * 33;
+acc += Math.sin(46012) + Math.cos(46013) * 34;
+acc += Math.sin(46013) + Math.cos(46014) * 35;
+acc += Math.sin(46014) + Math.cos(46015) * 36;
+acc += Math.sin(46015) + Math.cos(46016) * 37;
+acc += Math.sin(46016) + Math.cos(46017) * 38;
+acc += Math.sin(46017) + Math.cos(46018) * 39;
+acc += Math.sin(46018) + Math.cos(46019) * 40;
+acc += Math.sin(46019) + Math.cos(46020) * 41;
+acc += Math.sin(46020) + Math.cos(46021) * 42;
+acc += Math.sin(46021) + Math.cos(46022) * 43;
+acc += Math.sin(46022) + Math.cos(46023) * 44;
+acc += Math.sin(46023) + Math.cos(46024) * 45;
+acc += Math.sin(46024) + Math.cos(46025) * 46;
+acc += Math.sin(46025) + Math.cos(46026) * 47;
+acc += Math.sin(46026) + Math.cos(46027) * 48;
+acc += Math.sin(46027) + Math.cos(46028) * 49;
+acc += Math.sin(46028) + Math.cos(46029) * 50;
+acc += Math.sin(46029) + Math.cos(46030) * 51;
+acc += Math.sin(46030) + Math.cos(46031) * 52;
+acc += Math.sin(46031) + Math.cos(46032) * 53;
+acc += Math.sin(46032) + Math.cos(46033) * 54;
+acc += Math.sin(46033) + Math.cos(46034) * 55;
+acc += Math.sin(46034) + Math.cos(46035) * 56;
+acc += Math.sin(46035) + Math.cos(46036) * 57;
+acc += Math.sin(46036) + Math.cos(46037) * 58;
+acc += Math.sin(46037) + Math.cos(46038) * 59;
+acc += Math.sin(46038) + Math.cos(46039) * 60;
+acc += Math.sin(46039) + Math.cos(46040) * 61;
+acc += Math.sin(46040) + Math.cos(46041) * 62;
+acc += Math.sin(46041) + Math.cos(46042) * 63;
+acc += Math.sin(46042) + Math.cos(46043) * 64;
+acc += Math.sin(46043) + Math.cos(46044) * 65;
+acc += Math.sin(46044) + Math.cos(46045) * 66;
+acc += Math.sin(46045) + Math.cos(46046) * 67;
+acc += Math.sin(46046) + Math.cos(46047) * 68;
+acc += Math.sin(46047) + Math.cos(46048) * 69;
+acc += Math.sin(46048) + Math.cos(46049) * 70;
+acc += Math.sin(46049) + Math.cos(46050) * 71;
+acc += Math.sin(46050) + Math.cos(46051) * 72;
+acc += Math.sin(46051) + Math.cos(46052) * 73;
+acc += Math.sin(46052) + Math.cos(46053) * 74;
+acc += Math.sin(46053) + Math.cos(46054) * 75;
+acc += Math.sin(46054) + Math.cos(46055) * 76;
+acc += Math.sin(46055) + Math.cos(46056) * 77;
+acc += Math.sin(46056) + Math.cos(46057) * 78;
+acc += Math.sin(46057) + Math.cos(46058) * 79;
+acc += Math.sin(46058) + Math.cos(46059) * 80;
+acc += Math.sin(46059) + Math.cos(46060) * 81;
+acc += Math.sin(46060) + Math.cos(46061) * 82;
+acc += Math.sin(46061) + Math.cos(46062) * 83;
+acc += Math.sin(46062) + Math.cos(46063) * 84;
+acc += Math.sin(46063) + Math.cos(46064) * 85;
+acc += Math.sin(46064) + Math.cos(46065) * 86;
+acc += Math.sin(46065) + Math.cos(46066) * 87;
+acc += Math.sin(46066) + Math.cos(46067) * 88;
+acc += Math.sin(46067) + Math.cos(46068) * 89;
+acc += Math.sin(46068) + Math.cos(46069) * 90;
+acc += Math.sin(46069) + Math.cos(46070) * 91;
+acc += Math.sin(46070) + Math.cos(46071) * 92;
+acc += Math.sin(46071) + Math.cos(46072) * 93;
+acc += Math.sin(46072) + Math.cos(46073) * 94;
+acc += Math.sin(46073) + Math.cos(46074) * 95;
+acc += Math.sin(46074) + Math.cos(46075) * 96;
+acc += Math.sin(46075) + Math.cos(46076) * 0;
+acc += Math.sin(46076) + Math.cos(46077) * 1;
+acc += Math.sin(46077) + Math.cos(46078) * 2;
+acc += Math.sin(46078) + Math.cos(46079) * 3;
+acc += Math.sin(46079) + Math.cos(46080) * 4;
+acc += Math.sin(46080) + Math.cos(46081) * 5;
+acc += Math.sin(46081) + Math.cos(46082) * 6;
+acc += Math.sin(46082) + Math.cos(46083) * 7;
+acc += Math.sin(46083) + Math.cos(46084) * 8;
+acc += Math.sin(46084) + Math.cos(46085) * 9;
+acc += Math.sin(46085) + Math.cos(46086) * 10;
+acc += Math.sin(46086) + Math.cos(46087) * 11;
+acc += Math.sin(46087) + Math.cos(46088) * 12;
+acc += Math.sin(46088) + Math.cos(46089) * 13;
+acc += Math.sin(46089) + Math.cos(46090) * 14;
+acc += Math.sin(46090) + Math.cos(46091) * 15;
+acc += Math.sin(46091) + Math.cos(46092) * 16;
+acc += Math.sin(46092) + Math.cos(46093) * 17;
+acc += Math.sin(46093) + Math.cos(46094) * 18;
+acc += Math.sin(46094) + Math.cos(46095) * 19;
+acc += Math.sin(46095) + Math.cos(46096) * 20;
+acc += Math.sin(46096) + Math.cos(46097) * 21;
+acc += Math.sin(46097) + Math.cos(46098) * 22;
+acc += Math.sin(46098) + Math.cos(46099) * 23;
+acc += Math.sin(46099) + Math.cos(46100) * 24;
+acc += Math.sin(46100) + Math.cos(46101) * 25;
+acc += Math.sin(46101) + Math.cos(46102) * 26;
+acc += Math.sin(46102) + Math.cos(46103) * 27;
+acc += Math.sin(46103) + Math.cos(46104) * 28;
+acc += Math.sin(46104) + Math.cos(46105) * 29;
+acc += Math.sin(46105) + Math.cos(46106) * 30;
+acc += Math.sin(46106) + Math.cos(46107) * 31;
+acc += Math.sin(46107) + Math.cos(46108) * 32;
+acc += Math.sin(46108) + Math.cos(46109) * 33;
+acc += Math.sin(46109) + Math.cos(46110) * 34;
+acc += Math.sin(46110) + Math.cos(46111) * 35;
+acc += Math.sin(46111) + Math.cos(46112) * 36;
+acc += Math.sin(46112) + Math.cos(46113) * 37;
+acc += Math.sin(46113) + Math.cos(46114) * 38;
+acc += Math.sin(46114) + Math.cos(46115) * 39;
+acc += Math.sin(46115) + Math.cos(46116) * 40;
+acc += Math.sin(46116) + Math.cos(46117) * 41;
+acc += Math.sin(46117) + Math.cos(46118) * 42;
+acc += Math.sin(46118) + Math.cos(46119) * 43;
+acc += Math.sin(46119) + Math.cos(46120) * 44;
+acc += Math.sin(46120) + Math.cos(46121) * 45;
+acc += Math.sin(46121) + Math.cos(46122) * 46;
+acc += Math.sin(46122) + Math.cos(46123) * 47;
+acc += Math.sin(46123) + Math.cos(46124) * 48;
+acc += Math.sin(46124) + Math.cos(46125) * 49;
+acc += Math.sin(46125) + Math.cos(46126) * 50;
+acc += Math.sin(46126) + Math.cos(46127) * 51;
+acc += Math.sin(46127) + Math.cos(46128) * 52;
+acc += Math.sin(46128) + Math.cos(46129) * 53;
+acc += Math.sin(46129) + Math.cos(46130) * 54;
+acc += Math.sin(46130) + Math.cos(46131) * 55;
+acc += Math.sin(46131) + Math.cos(46132) * 56;
+acc += Math.sin(46132) + Math.cos(46133) * 57;
+acc += Math.sin(46133) + Math.cos(46134) * 58;
+acc += Math.sin(46134) + Math.cos(46135) * 59;
+acc += Math.sin(46135) + Math.cos(46136) * 60;
+acc += Math.sin(46136) + Math.cos(46137) * 61;
+acc += Math.sin(46137) + Math.cos(46138) * 62;
+acc += Math.sin(46138) + Math.cos(46139) * 63;
+acc += Math.sin(46139) + Math.cos(46140) * 64;
+acc += Math.sin(46140) + Math.cos(46141) * 65;
+acc += Math.sin(46141) + Math.cos(46142) * 66;
+acc += Math.sin(46142) + Math.cos(46143) * 67;
+acc += Math.sin(46143) + Math.cos(46144) * 68;
+acc += Math.sin(46144) + Math.cos(46145) * 69;
+acc += Math.sin(46145) + Math.cos(46146) * 70;
+acc += Math.sin(46146) + Math.cos(46147) * 71;
+acc += Math.sin(46147) + Math.cos(46148) * 72;
+acc += Math.sin(46148) + Math.cos(46149) * 73;
+acc += Math.sin(46149) + Math.cos(46150) * 74;
+acc += Math.sin(46150) + Math.cos(46151) * 75;
+acc += Math.sin(46151) + Math.cos(46152) * 76;
+acc += Math.sin(46152) + Math.cos(46153) * 77;
+acc += Math.sin(46153) + Math.cos(46154) * 78;
+acc += Math.sin(46154) + Math.cos(46155) * 79;
+acc += Math.sin(46155) + Math.cos(46156) * 80;
+acc += Math.sin(46156) + Math.cos(46157) * 81;
+acc += Math.sin(46157) + Math.cos(46158) * 82;
+acc += Math.sin(46158) + Math.cos(46159) * 83;
+acc += Math.sin(46159) + Math.cos(46160) * 84;
+acc += Math.sin(46160) + Math.cos(46161) * 85;
+acc += Math.sin(46161) + Math.cos(46162) * 86;
+acc += Math.sin(46162) + Math.cos(46163) * 87;
+acc += Math.sin(46163) + Math.cos(46164) * 88;
+acc += Math.sin(46164) + Math.cos(46165) * 89;
+acc += Math.sin(46165) + Math.cos(46166) * 90;
+acc += Math.sin(46166) + Math.cos(46167) * 91;
+acc += Math.sin(46167) + Math.cos(46168) * 92;
+acc += Math.sin(46168) + Math.cos(46169) * 93;
+acc += Math.sin(46169) + Math.cos(46170) * 94;
+acc += Math.sin(46170) + Math.cos(46171) * 95;
+acc += Math.sin(46171) + Math.cos(46172) * 96;
+acc += Math.sin(46172) + Math.cos(46173) * 0;
+acc += Math.sin(46173) + Math.cos(46174) * 1;
+acc += Math.sin(46174) + Math.cos(46175) * 2;
+acc += Math.sin(46175) + Math.cos(46176) * 3;
+acc += Math.sin(46176) + Math.cos(46177) * 4;
+acc += Math.sin(46177) + Math.cos(46178) * 5;
+acc += Math.sin(46178) + Math.cos(46179) * 6;
+acc += Math.sin(46179) + Math.cos(46180) * 7;
+acc += Math.sin(46180) + Math.cos(46181) * 8;
+acc += Math.sin(46181) + Math.cos(46182) * 9;
+acc += Math.sin(46182) + Math.cos(46183) * 10;
+acc += Math.sin(46183) + Math.cos(46184) * 11;
+acc += Math.sin(46184) + Math.cos(46185) * 12;
+acc += Math.sin(46185) + Math.cos(46186) * 13;
+acc += Math.sin(46186) + Math.cos(46187) * 14;
+acc += Math.sin(46187) + Math.cos(46188) * 15;
+acc += Math.sin(46188) + Math.cos(46189) * 16;
+acc += Math.sin(46189) + Math.cos(46190) * 17;
+acc += Math.sin(46190) + Math.cos(46191) * 18;
+acc += Math.sin(46191) + Math.cos(46192) * 19;
+acc += Math.sin(46192) + Math.cos(46193) * 20;
+acc += Math.sin(46193) + Math.cos(46194) * 21;
+acc += Math.sin(46194) + Math.cos(46195) * 22;
+acc += Math.sin(46195) + Math.cos(46196) * 23;
+acc += Math.sin(46196) + Math.cos(46197) * 24;
+acc += Math.sin(46197) + Math.cos(46198) * 25;
+acc += Math.sin(46198) + Math.cos(46199) * 26;
+acc += Math.sin(46199) + Math.cos(46200) * 27;
+acc += Math.sin(46200) + Math.cos(46201) * 28;
+acc += Math.sin(46201) + Math.cos(46202) * 29;
+acc += Math.sin(46202) + Math.cos(46203) * 30;
+acc += Math.sin(46203) + Math.cos(46204) * 31;
+acc += Math.sin(46204) + Math.cos(46205) * 32;
+acc += Math.sin(46205) + Math.cos(46206) * 33;
+acc += Math.sin(46206) + Math.cos(46207) * 34;
+acc += Math.sin(46207) + Math.cos(46208) * 35;
+acc += Math.sin(46208) + Math.cos(46209) * 36;
+acc += Math.sin(46209) + Math.cos(46210) * 37;
+acc += Math.sin(46210) + Math.cos(46211) * 38;
+acc += Math.sin(46211) + Math.cos(46212) * 39;
+acc += Math.sin(46212) + Math.cos(46213) * 40;
+acc += Math.sin(46213) + Math.cos(46214) * 41;
+acc += Math.sin(46214) + Math.cos(46215) * 42;
+acc += Math.sin(46215) + Math.cos(46216) * 43;
+acc += Math.sin(46216) + Math.cos(46217) * 44;
+acc += Math.sin(46217) + Math.cos(46218) * 45;
+acc += Math.sin(46218) + Math.cos(46219) * 46;
+acc += Math.sin(46219) + Math.cos(46220) * 47;
+acc += Math.sin(46220) + Math.cos(46221) * 48;
+acc += Math.sin(46221) + Math.cos(46222) * 49;
+acc += Math.sin(46222) + Math.cos(46223) * 50;
+acc += Math.sin(46223) + Math.cos(46224) * 51;
+acc += Math.sin(46224) + Math.cos(46225) * 52;
+acc += Math.sin(46225) + Math.cos(46226) * 53;
+acc += Math.sin(46226) + Math.cos(46227) * 54;
+acc += Math.sin(46227) + Math.cos(46228) * 55;
+acc += Math.sin(46228) + Math.cos(46229) * 56;
+acc += Math.sin(46229) + Math.cos(46230) * 57;
+acc += Math.sin(46230) + Math.cos(46231) * 58;
+acc += Math.sin(46231) + Math.cos(46232) * 59;
+acc += Math.sin(46232) + Math.cos(46233) * 60;
+acc += Math.sin(46233) + Math.cos(46234) * 61;
+acc += Math.sin(46234) + Math.cos(46235) * 62;
+acc += Math.sin(46235) + Math.cos(46236) * 63;
+acc += Math.sin(46236) + Math.cos(46237) * 64;
+acc += Math.sin(46237) + Math.cos(46238) * 65;
+acc += Math.sin(46238) + Math.cos(46239) * 66;
+acc += Math.sin(46239) + Math.cos(46240) * 67;
+acc += Math.sin(46240) + Math.cos(46241) * 68;
+acc += Math.sin(46241) + Math.cos(46242) * 69;
+acc += Math.sin(46242) + Math.cos(46243) * 70;
+acc += Math.sin(46243) + Math.cos(46244) * 71;
+acc += Math.sin(46244) + Math.cos(46245) * 72;
+acc += Math.sin(46245) + Math.cos(46246) * 73;
+acc += Math.sin(46246) + Math.cos(46247) * 74;
+acc += Math.sin(46247) + Math.cos(46248) * 75;
+acc += Math.sin(46248) + Math.cos(46249) * 76;
+acc += Math.sin(46249) + Math.cos(46250) * 77;
+acc += Math.sin(46250) + Math.cos(46251) * 78;
+acc += Math.sin(46251) + Math.cos(46252) * 79;
+acc += Math.sin(46252) + Math.cos(46253) * 80;
+acc += Math.sin(46253) + Math.cos(46254) * 81;
+acc += Math.sin(46254) + Math.cos(46255) * 82;
+acc += Math.sin(46255) + Math.cos(46256) * 83;
+acc += Math.sin(46256) + Math.cos(46257) * 84;
+acc += Math.sin(46257) + Math.cos(46258) * 85;
+acc += Math.sin(46258) + Math.cos(46259) * 86;
+acc += Math.sin(46259) + Math.cos(46260) * 87;
+acc += Math.sin(46260) + Math.cos(46261) * 88;
+acc += Math.sin(46261) + Math.cos(46262) * 89;
+acc += Math.sin(46262) + Math.cos(46263) * 90;
+acc += Math.sin(46263) + Math.cos(46264) * 91;
+acc += Math.sin(46264) + Math.cos(46265) * 92;
+acc += Math.sin(46265) + Math.cos(46266) * 93;
+acc += Math.sin(46266) + Math.cos(46267) * 94;
+acc += Math.sin(46267) + Math.cos(46268) * 95;
+acc += Math.sin(46268) + Math.cos(46269) * 96;
+acc += Math.sin(46269) + Math.cos(46270) * 0;
+acc += Math.sin(46270) + Math.cos(46271) * 1;
+acc += Math.sin(46271) + Math.cos(46272) * 2;
+acc += Math.sin(46272) + Math.cos(46273) * 3;
+acc += Math.sin(46273) + Math.cos(46274) * 4;
+acc += Math.sin(46274) + Math.cos(46275) * 5;
+acc += Math.sin(46275) + Math.cos(46276) * 6;
+acc += Math.sin(46276) + Math.cos(46277) * 7;
+acc += Math.sin(46277) + Math.cos(46278) * 8;
+acc += Math.sin(46278) + Math.cos(46279) * 9;
+acc += Math.sin(46279) + Math.cos(46280) * 10;
+acc += Math.sin(46280) + Math.cos(46281) * 11;
+acc += Math.sin(46281) + Math.cos(46282) * 12;
+acc += Math.sin(46282) + Math.cos(46283) * 13;
+acc += Math.sin(46283) + Math.cos(46284) * 14;
+acc += Math.sin(46284) + Math.cos(46285) * 15;
+acc += Math.sin(46285) + Math.cos(46286) * 16;
+acc += Math.sin(46286) + Math.cos(46287) * 17;
+acc += Math.sin(46287) + Math.cos(46288) * 18;
+acc += Math.sin(46288) + Math.cos(46289) * 19;
+acc += Math.sin(46289) + Math.cos(46290) * 20;
+acc += Math.sin(46290) + Math.cos(46291) * 21;
+acc += Math.sin(46291) + Math.cos(46292) * 22;
+acc += Math.sin(46292) + Math.cos(46293) * 23;
+acc += Math.sin(46293) + Math.cos(46294) * 24;
+acc += Math.sin(46294) + Math.cos(46295) * 25;
+acc += Math.sin(46295) + Math.cos(46296) * 26;
+acc += Math.sin(46296) + Math.cos(46297) * 27;
+acc += Math.sin(46297) + Math.cos(46298) * 28;
+acc += Math.sin(46298) + Math.cos(46299) * 29;
+acc += Math.sin(46299) + Math.cos(46300) * 30;
+acc += Math.sin(46300) + Math.cos(46301) * 31;
+acc += Math.sin(46301) + Math.cos(46302) * 32;
+acc += Math.sin(46302) + Math.cos(46303) * 33;
+acc += Math.sin(46303) + Math.cos(46304) * 34;
+acc += Math.sin(46304) + Math.cos(46305) * 35;
+acc += Math.sin(46305) + Math.cos(46306) * 36;
+acc += Math.sin(46306) + Math.cos(46307) * 37;
+acc += Math.sin(46307) + Math.cos(46308) * 38;
+acc += Math.sin(46308) + Math.cos(46309) * 39;
+acc += Math.sin(46309) + Math.cos(46310) * 40;
+acc += Math.sin(46310) + Math.cos(46311) * 41;
+acc += Math.sin(46311) + Math.cos(46312) * 42;
+acc += Math.sin(46312) + Math.cos(46313) * 43;
+acc += Math.sin(46313) + Math.cos(46314) * 44;
+acc += Math.sin(46314) + Math.cos(46315) * 45;
+acc += Math.sin(46315) + Math.cos(46316) * 46;
+acc += Math.sin(46316) + Math.cos(46317) * 47;
+acc += Math.sin(46317) + Math.cos(46318) * 48;
+acc += Math.sin(46318) + Math.cos(46319) * 49;
+acc += Math.sin(46319) + Math.cos(46320) * 50;
+acc += Math.sin(46320) + Math.cos(46321) * 51;
+acc += Math.sin(46321) + Math.cos(46322) * 52;
+acc += Math.sin(46322) + Math.cos(46323) * 53;
+acc += Math.sin(46323) + Math.cos(46324) * 54;
+acc += Math.sin(46324) + Math.cos(46325) * 55;
+acc += Math.sin(46325) + Math.cos(46326) * 56;
+acc += Math.sin(46326) + Math.cos(46327) * 57;
+acc += Math.sin(46327) + Math.cos(46328) * 58;
+acc += Math.sin(46328) + Math.cos(46329) * 59;
+acc += Math.sin(46329) + Math.cos(46330) * 60;
+acc += Math.sin(46330) + Math.cos(46331) * 61;
+acc += Math.sin(46331) + Math.cos(46332) * 62;
+acc += Math.sin(46332) + Math.cos(46333) * 63;
+acc += Math.sin(46333) + Math.cos(46334) * 64;
+acc += Math.sin(46334) + Math.cos(46335) * 65;
+acc += Math.sin(46335) + Math.cos(46336) * 66;
+acc += Math.sin(46336) + Math.cos(46337) * 67;
+acc += Math.sin(46337) + Math.cos(46338) * 68;
+acc += Math.sin(46338) + Math.cos(46339) * 69;
+acc += Math.sin(46339) + Math.cos(46340) * 70;
+acc += Math.sin(46340) + Math.cos(46341) * 71;
+acc += Math.sin(46341) + Math.cos(46342) * 72;
+acc += Math.sin(46342) + Math.cos(46343) * 73;
+acc += Math.sin(46343) + Math.cos(46344) * 74;
+acc += Math.sin(46344) + Math.cos(46345) * 75;
+acc += Math.sin(46345) + Math.cos(46346) * 76;
+acc += Math.sin(46346) + Math.cos(46347) * 77;
+acc += Math.sin(46347) + Math.cos(46348) * 78;
+acc += Math.sin(46348) + Math.cos(46349) * 79;
+acc += Math.sin(46349) + Math.cos(46350) * 80;
+acc += Math.sin(46350) + Math.cos(46351) * 81;
+acc += Math.sin(46351) + Math.cos(46352) * 82;
+acc += Math.sin(46352) + Math.cos(46353) * 83;
+acc += Math.sin(46353) + Math.cos(46354) * 84;
+acc += Math.sin(46354) + Math.cos(46355) * 85;
+acc += Math.sin(46355) + Math.cos(46356) * 86;
+acc += Math.sin(46356) + Math.cos(46357) * 87;
+acc += Math.sin(46357) + Math.cos(46358) * 88;
+acc += Math.sin(46358) + Math.cos(46359) * 89;
+acc += Math.sin(46359) + Math.cos(46360) * 90;
+acc += Math.sin(46360) + Math.cos(46361) * 91;
+acc += Math.sin(46361) + Math.cos(46362) * 92;
+acc += Math.sin(46362) + Math.cos(46363) * 93;
+acc += Math.sin(46363) + Math.cos(46364) * 94;
+acc += Math.sin(46364) + Math.cos(46365) * 95;
+acc += Math.sin(46365) + Math.cos(46366) * 96;
+acc += Math.sin(46366) + Math.cos(46367) * 0;
+acc += Math.sin(46367) + Math.cos(46368) * 1;
+acc += Math.sin(46368) + Math.cos(46369) * 2;
+acc += Math.sin(46369) + Math.cos(46370) * 3;
+acc += Math.sin(46370) + Math.cos(46371) * 4;
+acc += Math.sin(46371) + Math.cos(46372) * 5;
+acc += Math.sin(46372) + Math.cos(46373) * 6;
+acc += Math.sin(46373) + Math.cos(46374) * 7;
+acc += Math.sin(46374) + Math.cos(46375) * 8;
+acc += Math.sin(46375) + Math.cos(46376) * 9;
+acc += Math.sin(46376) + Math.cos(46377) * 10;
+acc += Math.sin(46377) + Math.cos(46378) * 11;
+acc += Math.sin(46378) + Math.cos(46379) * 12;
+acc += Math.sin(46379) + Math.cos(46380) * 13;
+acc += Math.sin(46380) + Math.cos(46381) * 14;
+acc += Math.sin(46381) + Math.cos(46382) * 15;
+acc += Math.sin(46382) + Math.cos(46383) * 16;
+acc += Math.sin(46383) + Math.cos(46384) * 17;
+acc += Math.sin(46384) + Math.cos(46385) * 18;
+acc += Math.sin(46385) + Math.cos(46386) * 19;
+acc += Math.sin(46386) + Math.cos(46387) * 20;
+acc += Math.sin(46387) + Math.cos(46388) * 21;
+acc += Math.sin(46388) + Math.cos(46389) * 22;
+acc += Math.sin(46389) + Math.cos(46390) * 23;
+acc += Math.sin(46390) + Math.cos(46391) * 24;
+acc += Math.sin(46391) + Math.cos(46392) * 25;
+acc += Math.sin(46392) + Math.cos(46393) * 26;
+acc += Math.sin(46393) + Math.cos(46394) * 27;
+acc += Math.sin(46394) + Math.cos(46395) * 28;
+acc += Math.sin(46395) + Math.cos(46396) * 29;
+acc += Math.sin(46396) + Math.cos(46397) * 30;
+acc += Math.sin(46397) + Math.cos(46398) * 31;
+acc += Math.sin(46398) + Math.cos(46399) * 32;
+acc += Math.sin(46399) + Math.cos(46400) * 33;
+acc += Math.sin(46400) + Math.cos(46401) * 34;
+acc += Math.sin(46401) + Math.cos(46402) * 35;
+acc += Math.sin(46402) + Math.cos(46403) * 36;
+acc += Math.sin(46403) + Math.cos(46404) * 37;
+acc += Math.sin(46404) + Math.cos(46405) * 38;
+acc += Math.sin(46405) + Math.cos(46406) * 39;
+acc += Math.sin(46406) + Math.cos(46407) * 40;
+acc += Math.sin(46407) + Math.cos(46408) * 41;
+acc += Math.sin(46408) + Math.cos(46409) * 42;
+acc += Math.sin(46409) + Math.cos(46410) * 43;
+acc += Math.sin(46410) + Math.cos(46411) * 44;
+acc += Math.sin(46411) + Math.cos(46412) * 45;
+acc += Math.sin(46412) + Math.cos(46413) * 46;
+acc += Math.sin(46413) + Math.cos(46414) * 47;
+acc += Math.sin(46414) + Math.cos(46415) * 48;
+acc += Math.sin(46415) + Math.cos(46416) * 49;
+acc += Math.sin(46416) + Math.cos(46417) * 50;
+acc += Math.sin(46417) + Math.cos(46418) * 51;
+acc += Math.sin(46418) + Math.cos(46419) * 52;
+acc += Math.sin(46419) + Math.cos(46420) * 53;
+acc += Math.sin(46420) + Math.cos(46421) * 54;
+acc += Math.sin(46421) + Math.cos(46422) * 55;
+acc += Math.sin(46422) + Math.cos(46423) * 56;
+acc += Math.sin(46423) + Math.cos(46424) * 57;
+acc += Math.sin(46424) + Math.cos(46425) * 58;
+acc += Math.sin(46425) + Math.cos(46426) * 59;
+acc += Math.sin(46426) + Math.cos(46427) * 60;
+acc += Math.sin(46427) + Math.cos(46428) * 61;
+acc += Math.sin(46428) + Math.cos(46429) * 62;
+acc += Math.sin(46429) + Math.cos(46430) * 63;
+acc += Math.sin(46430) + Math.cos(46431) * 64;
+acc += Math.sin(46431) + Math.cos(46432) * 65;
+acc += Math.sin(46432) + Math.cos(46433) * 66;
+acc += Math.sin(46433) + Math.cos(46434) * 67;
+acc += Math.sin(46434) + Math.cos(46435) * 68;
+acc += Math.sin(46435) + Math.cos(46436) * 69;
+acc += Math.sin(46436) + Math.cos(46437) * 70;
+acc += Math.sin(46437) + Math.cos(46438) * 71;
+acc += Math.sin(46438) + Math.cos(46439) * 72;
+acc += Math.sin(46439) + Math.cos(46440) * 73;
+acc += Math.sin(46440) + Math.cos(46441) * 74;
+acc += Math.sin(46441) + Math.cos(46442) * 75;
+acc += Math.sin(46442) + Math.cos(46443) * 76;
+acc += Math.sin(46443) + Math.cos(46444) * 77;
+acc += Math.sin(46444) + Math.cos(46445) * 78;
+acc += Math.sin(46445) + Math.cos(46446) * 79;
+acc += Math.sin(46446) + Math.cos(46447) * 80;
+acc += Math.sin(46447) + Math.cos(46448) * 81;
+acc += Math.sin(46448) + Math.cos(46449) * 82;
+acc += Math.sin(46449) + Math.cos(46450) * 83;
+acc += Math.sin(46450) + Math.cos(46451) * 84;
+acc += Math.sin(46451) + Math.cos(46452) * 85;
+acc += Math.sin(46452) + Math.cos(46453) * 86;
+acc += Math.sin(46453) + Math.cos(46454) * 87;
+acc += Math.sin(46454) + Math.cos(46455) * 88;
+acc += Math.sin(46455) + Math.cos(46456) * 89;
+acc += Math.sin(46456) + Math.cos(46457) * 90;
+acc += Math.sin(46457) + Math.cos(46458) * 91;
+acc += Math.sin(46458) + Math.cos(46459) * 92;
+acc += Math.sin(46459) + Math.cos(46460) * 93;
+acc += Math.sin(46460) + Math.cos(46461) * 94;
+acc += Math.sin(46461) + Math.cos(46462) * 95;
+acc += Math.sin(46462) + Math.cos(46463) * 96;
+acc += Math.sin(46463) + Math.cos(46464) * 0;
+acc += Math.sin(46464) + Math.cos(46465) * 1;
+acc += Math.sin(46465) + Math.cos(46466) * 2;
+acc += Math.sin(46466) + Math.cos(46467) * 3;
+acc += Math.sin(46467) + Math.cos(46468) * 4;
+acc += Math.sin(46468) + Math.cos(46469) * 5;
+acc += Math.sin(46469) + Math.cos(46470) * 6;
+acc += Math.sin(46470) + Math.cos(46471) * 7;
+acc += Math.sin(46471) + Math.cos(46472) * 8;
+acc += Math.sin(46472) + Math.cos(46473) * 9;
+acc += Math.sin(46473) + Math.cos(46474) * 10;
+acc += Math.sin(46474) + Math.cos(46475) * 11;
+acc += Math.sin(46475) + Math.cos(46476) * 12;
+acc += Math.sin(46476) + Math.cos(46477) * 13;
+acc += Math.sin(46477) + Math.cos(46478) * 14;
+acc += Math.sin(46478) + Math.cos(46479) * 15;
+acc += Math.sin(46479) + Math.cos(46480) * 16;
+acc += Math.sin(46480) + Math.cos(46481) * 17;
+acc += Math.sin(46481) + Math.cos(46482) * 18;
+acc += Math.sin(46482) + Math.cos(46483) * 19;
+acc += Math.sin(46483) + Math.cos(46484) * 20;
+acc += Math.sin(46484) + Math.cos(46485) * 21;
+acc += Math.sin(46485) + Math.cos(46486) * 22;
+acc += Math.sin(46486) + Math.cos(46487) * 23;
+acc += Math.sin(46487) + Math.cos(46488) * 24;
+acc += Math.sin(46488) + Math.cos(46489) * 25;
+acc += Math.sin(46489) + Math.cos(46490) * 26;
+acc += Math.sin(46490) + Math.cos(46491) * 27;
+acc += Math.sin(46491) + Math.cos(46492) * 28;
+acc += Math.sin(46492) + Math.cos(46493) * 29;
+acc += Math.sin(46493) + Math.cos(46494) * 30;
+acc += Math.sin(46494) + Math.cos(46495) * 31;
+acc += Math.sin(46495) + Math.cos(46496) * 32;
+acc += Math.sin(46496) + Math.cos(46497) * 33;
+acc += Math.sin(46497) + Math.cos(46498) * 34;
+acc += Math.sin(46498) + Math.cos(46499) * 35;
+acc += Math.sin(46499) + Math.cos(46500) * 36;
+acc += Math.sin(46500) + Math.cos(46501) * 37;
+acc += Math.sin(46501) + Math.cos(46502) * 38;
+acc += Math.sin(46502) + Math.cos(46503) * 39;
+acc += Math.sin(46503) + Math.cos(46504) * 40;
+acc += Math.sin(46504) + Math.cos(46505) * 41;
+acc += Math.sin(46505) + Math.cos(46506) * 42;
+acc += Math.sin(46506) + Math.cos(46507) * 43;
+acc += Math.sin(46507) + Math.cos(46508) * 44;
+acc += Math.sin(46508) + Math.cos(46509) * 45;
+acc += Math.sin(46509) + Math.cos(46510) * 46;
+acc += Math.sin(46510) + Math.cos(46511) * 47;
+acc += Math.sin(46511) + Math.cos(46512) * 48;
+acc += Math.sin(46512) + Math.cos(46513) * 49;
+acc += Math.sin(46513) + Math.cos(46514) * 50;
+acc += Math.sin(46514) + Math.cos(46515) * 51;
+acc += Math.sin(46515) + Math.cos(46516) * 52;
+acc += Math.sin(46516) + Math.cos(46517) * 53;
+acc += Math.sin(46517) + Math.cos(46518) * 54;
+acc += Math.sin(46518) + Math.cos(46519) * 55;
+acc += Math.sin(46519) + Math.cos(46520) * 56;
+acc += Math.sin(46520) + Math.cos(46521) * 57;
+acc += Math.sin(46521) + Math.cos(46522) * 58;
+acc += Math.sin(46522) + Math.cos(46523) * 59;
+acc += Math.sin(46523) + Math.cos(46524) * 60;
+acc += Math.sin(46524) + Math.cos(46525) * 61;
+acc += Math.sin(46525) + Math.cos(46526) * 62;
+acc += Math.sin(46526) + Math.cos(46527) * 63;
+acc += Math.sin(46527) + Math.cos(46528) * 64;
+acc += Math.sin(46528) + Math.cos(46529) * 65;
+acc += Math.sin(46529) + Math.cos(46530) * 66;
+acc += Math.sin(46530) + Math.cos(46531) * 67;
+acc += Math.sin(46531) + Math.cos(46532) * 68;
+acc += Math.sin(46532) + Math.cos(46533) * 69;
+acc += Math.sin(46533) + Math.cos(46534) * 70;
+acc += Math.sin(46534) + Math.cos(46535) * 71;
+acc += Math.sin(46535) + Math.cos(46536) * 72;
+acc += Math.sin(46536) + Math.cos(46537) * 73;
+acc += Math.sin(46537) + Math.cos(46538) * 74;
+acc += Math.sin(46538) + Math.cos(46539) * 75;
+acc += Math.sin(46539) + Math.cos(46540) * 76;
+acc += Math.sin(46540) + Math.cos(46541) * 77;
+acc += Math.sin(46541) + Math.cos(46542) * 78;
+acc += Math.sin(46542) + Math.cos(46543) * 79;
+acc += Math.sin(46543) + Math.cos(46544) * 80;
+acc += Math.sin(46544) + Math.cos(46545) * 81;
+acc += Math.sin(46545) + Math.cos(46546) * 82;
+acc += Math.sin(46546) + Math.cos(46547) * 83;
+acc += Math.sin(46547) + Math.cos(46548) * 84;
+acc += Math.sin(46548) + Math.cos(46549) * 85;
+acc += Math.sin(46549) + Math.cos(46550) * 86;
+acc += Math.sin(46550) + Math.cos(46551) * 87;
+acc += Math.sin(46551) + Math.cos(46552) * 88;
+acc += Math.sin(46552) + Math.cos(46553) * 89;
+acc += Math.sin(46553) + Math.cos(46554) * 90;
+acc += Math.sin(46554) + Math.cos(46555) * 91;
+acc += Math.sin(46555) + Math.cos(46556) * 92;
+acc += Math.sin(46556) + Math.cos(46557) * 93;
+acc += Math.sin(46557) + Math.cos(46558) * 94;
+acc += Math.sin(46558) + Math.cos(46559) * 95;
+acc += Math.sin(46559) + Math.cos(46560) * 96;
+acc += Math.sin(46560) + Math.cos(46561) * 0;
+acc += Math.sin(46561) + Math.cos(46562) * 1;
+acc += Math.sin(46562) + Math.cos(46563) * 2;
+acc += Math.sin(46563) + Math.cos(46564) * 3;
+acc += Math.sin(46564) + Math.cos(46565) * 4;
+acc += Math.sin(46565) + Math.cos(46566) * 5;
+acc += Math.sin(46566) + Math.cos(46567) * 6;
+acc += Math.sin(46567) + Math.cos(46568) * 7;
+acc += Math.sin(46568) + Math.cos(46569) * 8;
+acc += Math.sin(46569) + Math.cos(46570) * 9;
+acc += Math.sin(46570) + Math.cos(46571) * 10;
+acc += Math.sin(46571) + Math.cos(46572) * 11;
+acc += Math.sin(46572) + Math.cos(46573) * 12;
+acc += Math.sin(46573) + Math.cos(46574) * 13;
+acc += Math.sin(46574) + Math.cos(46575) * 14;
+acc += Math.sin(46575) + Math.cos(46576) * 15;
+acc += Math.sin(46576) + Math.cos(46577) * 16;
+acc += Math.sin(46577) + Math.cos(46578) * 17;
+acc += Math.sin(46578) + Math.cos(46579) * 18;
+acc += Math.sin(46579) + Math.cos(46580) * 19;
+acc += Math.sin(46580) + Math.cos(46581) * 20;
+acc += Math.sin(46581) + Math.cos(46582) * 21;
+acc += Math.sin(46582) + Math.cos(46583) * 22;
+acc += Math.sin(46583) + Math.cos(46584) * 23;
+acc += Math.sin(46584) + Math.cos(46585) * 24;
+acc += Math.sin(46585) + Math.cos(46586) * 25;
+acc += Math.sin(46586) + Math.cos(46587) * 26;
+acc += Math.sin(46587) + Math.cos(46588) * 27;
+acc += Math.sin(46588) + Math.cos(46589) * 28;
+acc += Math.sin(46589) + Math.cos(46590) * 29;
+acc += Math.sin(46590) + Math.cos(46591) * 30;
+acc += Math.sin(46591) + Math.cos(46592) * 31;
+acc += Math.sin(46592) + Math.cos(46593) * 32;
+acc += Math.sin(46593) + Math.cos(46594) * 33;
+acc += Math.sin(46594) + Math.cos(46595) * 34;
+acc += Math.sin(46595) + Math.cos(46596) * 35;
+acc += Math.sin(46596) + Math.cos(46597) * 36;
+acc += Math.sin(46597) + Math.cos(46598) * 37;
+acc += Math.sin(46598) + Math.cos(46599) * 38;
+acc += Math.sin(46599) + Math.cos(46600) * 39;
+acc += Math.sin(46600) + Math.cos(46601) * 40;
+acc += Math.sin(46601) + Math.cos(46602) * 41;
+acc += Math.sin(46602) + Math.cos(46603) * 42;
+acc += Math.sin(46603) + Math.cos(46604) * 43;
+acc += Math.sin(46604) + Math.cos(46605) * 44;
+acc += Math.sin(46605) + Math.cos(46606) * 45;
+acc += Math.sin(46606) + Math.cos(46607) * 46;
+acc += Math.sin(46607) + Math.cos(46608) * 47;
+acc += Math.sin(46608) + Math.cos(46609) * 48;
+acc += Math.sin(46609) + Math.cos(46610) * 49;
+acc += Math.sin(46610) + Math.cos(46611) * 50;
+acc += Math.sin(46611) + Math.cos(46612) * 51;
+acc += Math.sin(46612) + Math.cos(46613) * 52;
+acc += Math.sin(46613) + Math.cos(46614) * 53;
+acc += Math.sin(46614) + Math.cos(46615) * 54;
+acc += Math.sin(46615) + Math.cos(46616) * 55;
+acc += Math.sin(46616) + Math.cos(46617) * 56;
+acc += Math.sin(46617) + Math.cos(46618) * 57;
+acc += Math.sin(46618) + Math.cos(46619) * 58;
+acc += Math.sin(46619) + Math.cos(46620) * 59;
+acc += Math.sin(46620) + Math.cos(46621) * 60;
+acc += Math.sin(46621) + Math.cos(46622) * 61;
+acc += Math.sin(46622) + Math.cos(46623) * 62;
+acc += Math.sin(46623) + Math.cos(46624) * 63;
+acc += Math.sin(46624) + Math.cos(46625) * 64;
+acc += Math.sin(46625) + Math.cos(46626) * 65;
+acc += Math.sin(46626) + Math.cos(46627) * 66;
+acc += Math.sin(46627) + Math.cos(46628) * 67;
+acc += Math.sin(46628) + Math.cos(46629) * 68;
+acc += Math.sin(46629) + Math.cos(46630) * 69;
+acc += Math.sin(46630) + Math.cos(46631) * 70;
+acc += Math.sin(46631) + Math.cos(46632) * 71;
+acc += Math.sin(46632) + Math.cos(46633) * 72;
+acc += Math.sin(46633) + Math.cos(46634) * 73;
+acc += Math.sin(46634) + Math.cos(46635) * 74;
+acc += Math.sin(46635) + Math.cos(46636) * 75;
+acc += Math.sin(46636) + Math.cos(46637) * 76;
+acc += Math.sin(46637) + Math.cos(46638) * 77;
+acc += Math.sin(46638) + Math.cos(46639) * 78;
+acc += Math.sin(46639) + Math.cos(46640) * 79;
+acc += Math.sin(46640) + Math.cos(46641) * 80;
+acc += Math.sin(46641) + Math.cos(46642) * 81;
+acc += Math.sin(46642) + Math.cos(46643) * 82;
+acc += Math.sin(46643) + Math.cos(46644) * 83;
+acc += Math.sin(46644) + Math.cos(46645) * 84;
+acc += Math.sin(46645) + Math.cos(46646) * 85;
+acc += Math.sin(46646) + Math.cos(46647) * 86;
+acc += Math.sin(46647) + Math.cos(46648) * 87;
+acc += Math.sin(46648) + Math.cos(46649) * 88;
+acc += Math.sin(46649) + Math.cos(46650) * 89;
+acc += Math.sin(46650) + Math.cos(46651) * 90;
+acc += Math.sin(46651) + Math.cos(46652) * 91;
+acc += Math.sin(46652) + Math.cos(46653) * 92;
+acc += Math.sin(46653) + Math.cos(46654) * 93;
+acc += Math.sin(46654) + Math.cos(46655) * 94;
+acc += Math.sin(46655) + Math.cos(46656) * 95;
+acc += Math.sin(46656) + Math.cos(46657) * 96;
+acc += Math.sin(46657) + Math.cos(46658) * 0;
+acc += Math.sin(46658) + Math.cos(46659) * 1;
+acc += Math.sin(46659) + Math.cos(46660) * 2;
+acc += Math.sin(46660) + Math.cos(46661) * 3;
+acc += Math.sin(46661) + Math.cos(46662) * 4;
+acc += Math.sin(46662) + Math.cos(46663) * 5;
+acc += Math.sin(46663) + Math.cos(46664) * 6;
+acc += Math.sin(46664) + Math.cos(46665) * 7;
+acc += Math.sin(46665) + Math.cos(46666) * 8;
+acc += Math.sin(46666) + Math.cos(46667) * 9;
+acc += Math.sin(46667) + Math.cos(46668) * 10;
+acc += Math.sin(46668) + Math.cos(46669) * 11;
+acc += Math.sin(46669) + Math.cos(46670) * 12;
+acc += Math.sin(46670) + Math.cos(46671) * 13;
+acc += Math.sin(46671) + Math.cos(46672) * 14;
+acc += Math.sin(46672) + Math.cos(46673) * 15;
+acc += Math.sin(46673) + Math.cos(46674) * 16;
+acc += Math.sin(46674) + Math.cos(46675) * 17;
+acc += Math.sin(46675) + Math.cos(46676) * 18;
+acc += Math.sin(46676) + Math.cos(46677) * 19;
+acc += Math.sin(46677) + Math.cos(46678) * 20;
+acc += Math.sin(46678) + Math.cos(46679) * 21;
+acc += Math.sin(46679) + Math.cos(46680) * 22;
+acc += Math.sin(46680) + Math.cos(46681) * 23;
+acc += Math.sin(46681) + Math.cos(46682) * 24;
+acc += Math.sin(46682) + Math.cos(46683) * 25;
+acc += Math.sin(46683) + Math.cos(46684) * 26;
+acc += Math.sin(46684) + Math.cos(46685) * 27;
+acc += Math.sin(46685) + Math.cos(46686) * 28;
+acc += Math.sin(46686) + Math.cos(46687) * 29;
+acc += Math.sin(46687) + Math.cos(46688) * 30;
+acc += Math.sin(46688) + Math.cos(46689) * 31;
+acc += Math.sin(46689) + Math.cos(46690) * 32;
+acc += Math.sin(46690) + Math.cos(46691) * 33;
+acc += Math.sin(46691) + Math.cos(46692) * 34;
+acc += Math.sin(46692) + Math.cos(46693) * 35;
+acc += Math.sin(46693) + Math.cos(46694) * 36;
+acc += Math.sin(46694) + Math.cos(46695) * 37;
+acc += Math.sin(46695) + Math.cos(46696) * 38;
+acc += Math.sin(46696) + Math.cos(46697) * 39;
+acc += Math.sin(46697) + Math.cos(46698) * 40;
+acc += Math.sin(46698) + Math.cos(46699) * 41;
+acc += Math.sin(46699) + Math.cos(46700) * 42;
+acc += Math.sin(46700) + Math.cos(46701) * 43;
+acc += Math.sin(46701) + Math.cos(46702) * 44;
+acc += Math.sin(46702) + Math.cos(46703) * 45;
+acc += Math.sin(46703) + Math.cos(46704) * 46;
+acc += Math.sin(46704) + Math.cos(46705) * 47;
+acc += Math.sin(46705) + Math.cos(46706) * 48;
+acc += Math.sin(46706) + Math.cos(46707) * 49;
+acc += Math.sin(46707) + Math.cos(46708) * 50;
+acc += Math.sin(46708) + Math.cos(46709) * 51;
+acc += Math.sin(46709) + Math.cos(46710) * 52;
+acc += Math.sin(46710) + Math.cos(46711) * 53;
+acc += Math.sin(46711) + Math.cos(46712) * 54;
+acc += Math.sin(46712) + Math.cos(46713) * 55;
+acc += Math.sin(46713) + Math.cos(46714) * 56;
+acc += Math.sin(46714) + Math.cos(46715) * 57;
+acc += Math.sin(46715) + Math.cos(46716) * 58;
+acc += Math.sin(46716) + Math.cos(46717) * 59;
+acc += Math.sin(46717) + Math.cos(46718) * 60;
+acc += Math.sin(46718) + Math.cos(46719) * 61;
+acc += Math.sin(46719) + Math.cos(46720) * 62;
+acc += Math.sin(46720) + Math.cos(46721) * 63;
+acc += Math.sin(46721) + Math.cos(46722) * 64;
+acc += Math.sin(46722) + Math.cos(46723) * 65;
+acc += Math.sin(46723) + Math.cos(46724) * 66;
+acc += Math.sin(46724) + Math.cos(46725) * 67;
+acc += Math.sin(46725) + Math.cos(46726) * 68;
+acc += Math.sin(46726) + Math.cos(46727) * 69;
+acc += Math.sin(46727) + Math.cos(46728) * 70;
+acc += Math.sin(46728) + Math.cos(46729) * 71;
+acc += Math.sin(46729) + Math.cos(46730) * 72;
+acc += Math.sin(46730) + Math.cos(46731) * 73;
+acc += Math.sin(46731) + Math.cos(46732) * 74;
+acc += Math.sin(46732) + Math.cos(46733) * 75;
+acc += Math.sin(46733) + Math.cos(46734) * 76;
+acc += Math.sin(46734) + Math.cos(46735) * 77;
+acc += Math.sin(46735) + Math.cos(46736) * 78;
+acc += Math.sin(46736) + Math.cos(46737) * 79;
+acc += Math.sin(46737) + Math.cos(46738) * 80;
+acc += Math.sin(46738) + Math.cos(46739) * 81;
+acc += Math.sin(46739) + Math.cos(46740) * 82;
+acc += Math.sin(46740) + Math.cos(46741) * 83;
+acc += Math.sin(46741) + Math.cos(46742) * 84;
+acc += Math.sin(46742) + Math.cos(46743) * 85;
+acc += Math.sin(46743) + Math.cos(46744) * 86;
+acc += Math.sin(46744) + Math.cos(46745) * 87;
+acc += Math.sin(46745) + Math.cos(46746) * 88;
+acc += Math.sin(46746) + Math.cos(46747) * 89;
+acc += Math.sin(46747) + Math.cos(46748) * 90;
+acc += Math.sin(46748) + Math.cos(46749) * 91;
+acc += Math.sin(46749) + Math.cos(46750) * 92;
+acc += Math.sin(46750) + Math.cos(46751) * 93;
+acc += Math.sin(46751) + Math.cos(46752) * 94;
+acc += Math.sin(46752) + Math.cos(46753) * 95;
+acc += Math.sin(46753) + Math.cos(46754) * 96;
+acc += Math.sin(46754) + Math.cos(46755) * 0;
+acc += Math.sin(46755) + Math.cos(46756) * 1;
+acc += Math.sin(46756) + Math.cos(46757) * 2;
+acc += Math.sin(46757) + Math.cos(46758) * 3;
+acc += Math.sin(46758) + Math.cos(46759) * 4;
+acc += Math.sin(46759) + Math.cos(46760) * 5;
+acc += Math.sin(46760) + Math.cos(46761) * 6;
+acc += Math.sin(46761) + Math.cos(46762) * 7;
+acc += Math.sin(46762) + Math.cos(46763) * 8;
+acc += Math.sin(46763) + Math.cos(46764) * 9;
+acc += Math.sin(46764) + Math.cos(46765) * 10;
+acc += Math.sin(46765) + Math.cos(46766) * 11;
+acc += Math.sin(46766) + Math.cos(46767) * 12;
+acc += Math.sin(46767) + Math.cos(46768) * 13;
+acc += Math.sin(46768) + Math.cos(46769) * 14;
+acc += Math.sin(46769) + Math.cos(46770) * 15;
+acc += Math.sin(46770) + Math.cos(46771) * 16;
+acc += Math.sin(46771) + Math.cos(46772) * 17;
+acc += Math.sin(46772) + Math.cos(46773) * 18;
+acc += Math.sin(46773) + Math.cos(46774) * 19;
+acc += Math.sin(46774) + Math.cos(46775) * 20;
+acc += Math.sin(46775) + Math.cos(46776) * 21;
+acc += Math.sin(46776) + Math.cos(46777) * 22;
+acc += Math.sin(46777) + Math.cos(46778) * 23;
+acc += Math.sin(46778) + Math.cos(46779) * 24;
+acc += Math.sin(46779) + Math.cos(46780) * 25;
+acc += Math.sin(46780) + Math.cos(46781) * 26;
+acc += Math.sin(46781) + Math.cos(46782) * 27;
+acc += Math.sin(46782) + Math.cos(46783) * 28;
+acc += Math.sin(46783) + Math.cos(46784) * 29;
+acc += Math.sin(46784) + Math.cos(46785) * 30;
+acc += Math.sin(46785) + Math.cos(46786) * 31;
+acc += Math.sin(46786) + Math.cos(46787) * 32;
+acc += Math.sin(46787) + Math.cos(46788) * 33;
+acc += Math.sin(46788) + Math.cos(46789) * 34;
+acc += Math.sin(46789) + Math.cos(46790) * 35;
+acc += Math.sin(46790) + Math.cos(46791) * 36;
+acc += Math.sin(46791) + Math.cos(46792) * 37;
+acc += Math.sin(46792) + Math.cos(46793) * 38;
+acc += Math.sin(46793) + Math.cos(46794) * 39;
+acc += Math.sin(46794) + Math.cos(46795) * 40;
+acc += Math.sin(46795) + Math.cos(46796) * 41;
+acc += Math.sin(46796) + Math.cos(46797) * 42;
+acc += Math.sin(46797) + Math.cos(46798) * 43;
+acc += Math.sin(46798) + Math.cos(46799) * 44;
+acc += Math.sin(46799) + Math.cos(46800) * 45;
+acc += Math.sin(46800) + Math.cos(46801) * 46;
+acc += Math.sin(46801) + Math.cos(46802) * 47;
+acc += Math.sin(46802) + Math.cos(46803) * 48;
+acc += Math.sin(46803) + Math.cos(46804) * 49;
+acc += Math.sin(46804) + Math.cos(46805) * 50;
+acc += Math.sin(46805) + Math.cos(46806) * 51;
+acc += Math.sin(46806) + Math.cos(46807) * 52;
+acc += Math.sin(46807) + Math.cos(46808) * 53;
+acc += Math.sin(46808) + Math.cos(46809) * 54;
+acc += Math.sin(46809) + Math.cos(46810) * 55;
+acc += Math.sin(46810) + Math.cos(46811) * 56;
+acc += Math.sin(46811) + Math.cos(46812) * 57;
+acc += Math.sin(46812) + Math.cos(46813) * 58;
+acc += Math.sin(46813) + Math.cos(46814) * 59;
+acc += Math.sin(46814) + Math.cos(46815) * 60;
+acc += Math.sin(46815) + Math.cos(46816) * 61;
+acc += Math.sin(46816) + Math.cos(46817) * 62;
+acc += Math.sin(46817) + Math.cos(46818) * 63;
+acc += Math.sin(46818) + Math.cos(46819) * 64;
+acc += Math.sin(46819) + Math.cos(46820) * 65;
+acc += Math.sin(46820) + Math.cos(46821) * 66;
+acc += Math.sin(46821) + Math.cos(46822) * 67;
+acc += Math.sin(46822) + Math.cos(46823) * 68;
+acc += Math.sin(46823) + Math.cos(46824) * 69;
+acc += Math.sin(46824) + Math.cos(46825) * 70;
+acc += Math.sin(46825) + Math.cos(46826) * 71;
+acc += Math.sin(46826) + Math.cos(46827) * 72;
+acc += Math.sin(46827) + Math.cos(46828) * 73;
+acc += Math.sin(46828) + Math.cos(46829) * 74;
+acc += Math.sin(46829) + Math.cos(46830) * 75;
+acc += Math.sin(46830) + Math.cos(46831) * 76;
+acc += Math.sin(46831) + Math.cos(46832) * 77;
+acc += Math.sin(46832) + Math.cos(46833) * 78;
+acc += Math.sin(46833) + Math.cos(46834) * 79;
+acc += Math.sin(46834) + Math.cos(46835) * 80;
+acc += Math.sin(46835) + Math.cos(46836) * 81;
+acc += Math.sin(46836) + Math.cos(46837) * 82;
+acc += Math.sin(46837) + Math.cos(46838) * 83;
+acc += Math.sin(46838) + Math.cos(46839) * 84;
+acc += Math.sin(46839) + Math.cos(46840) * 85;
+acc += Math.sin(46840) + Math.cos(46841) * 86;
+acc += Math.sin(46841) + Math.cos(46842) * 87;
+acc += Math.sin(46842) + Math.cos(46843) * 88;
+acc += Math.sin(46843) + Math.cos(46844) * 89;
+acc += Math.sin(46844) + Math.cos(46845) * 90;
+acc += Math.sin(46845) + Math.cos(46846) * 91;
+acc += Math.sin(46846) + Math.cos(46847) * 92;
+acc += Math.sin(46847) + Math.cos(46848) * 93;
+acc += Math.sin(46848) + Math.cos(46849) * 94;
+acc += Math.sin(46849) + Math.cos(46850) * 95;
+acc += Math.sin(46850) + Math.cos(46851) * 96;
+acc += Math.sin(46851) + Math.cos(46852) * 0;
+acc += Math.sin(46852) + Math.cos(46853) * 1;
+acc += Math.sin(46853) + Math.cos(46854) * 2;
+acc += Math.sin(46854) + Math.cos(46855) * 3;
+acc += Math.sin(46855) + Math.cos(46856) * 4;
+acc += Math.sin(46856) + Math.cos(46857) * 5;
+acc += Math.sin(46857) + Math.cos(46858) * 6;
+acc += Math.sin(46858) + Math.cos(46859) * 7;
+acc += Math.sin(46859) + Math.cos(46860) * 8;
+acc += Math.sin(46860) + Math.cos(46861) * 9;
+acc += Math.sin(46861) + Math.cos(46862) * 10;
+acc += Math.sin(46862) + Math.cos(46863) * 11;
+acc += Math.sin(46863) + Math.cos(46864) * 12;
+acc += Math.sin(46864) + Math.cos(46865) * 13;
+acc += Math.sin(46865) + Math.cos(46866) * 14;
+acc += Math.sin(46866) + Math.cos(46867) * 15;
+acc += Math.sin(46867) + Math.cos(46868) * 16;
+acc += Math.sin(46868) + Math.cos(46869) * 17;
+acc += Math.sin(46869) + Math.cos(46870) * 18;
+acc += Math.sin(46870) + Math.cos(46871) * 19;
+acc += Math.sin(46871) + Math.cos(46872) * 20;
+acc += Math.sin(46872) + Math.cos(46873) * 21;
+acc += Math.sin(46873) + Math.cos(46874) * 22;
+acc += Math.sin(46874) + Math.cos(46875) * 23;
+acc += Math.sin(46875) + Math.cos(46876) * 24;
+acc += Math.sin(46876) + Math.cos(46877) * 25;
+acc += Math.sin(46877) + Math.cos(46878) * 26;
+acc += Math.sin(46878) + Math.cos(46879) * 27;
+acc += Math.sin(46879) + Math.cos(46880) * 28;
+acc += Math.sin(46880) + Math.cos(46881) * 29;
+acc += Math.sin(46881) + Math.cos(46882) * 30;
+acc += Math.sin(46882) + Math.cos(46883) * 31;
+acc += Math.sin(46883) + Math.cos(46884) * 32;
+acc += Math.sin(46884) + Math.cos(46885) * 33;
+acc += Math.sin(46885) + Math.cos(46886) * 34;
+acc += Math.sin(46886) + Math.cos(46887) * 35;
+acc += Math.sin(46887) + Math.cos(46888) * 36;
+acc += Math.sin(46888) + Math.cos(46889) * 37;
+acc += Math.sin(46889) + Math.cos(46890) * 38;
+acc += Math.sin(46890) + Math.cos(46891) * 39;
+acc += Math.sin(46891) + Math.cos(46892) * 40;
+acc += Math.sin(46892) + Math.cos(46893) * 41;
+acc += Math.sin(46893) + Math.cos(46894) * 42;
+acc += Math.sin(46894) + Math.cos(46895) * 43;
+acc += Math.sin(46895) + Math.cos(46896) * 44;
+acc += Math.sin(46896) + Math.cos(46897) * 45;
+acc += Math.sin(46897) + Math.cos(46898) * 46;
+acc += Math.sin(46898) + Math.cos(46899) * 47;
+acc += Math.sin(46899) + Math.cos(46900) * 48;
+acc += Math.sin(46900) + Math.cos(46901) * 49;
+acc += Math.sin(46901) + Math.cos(46902) * 50;
+acc += Math.sin(46902) + Math.cos(46903) * 51;
+acc += Math.sin(46903) + Math.cos(46904) * 52;
+acc += Math.sin(46904) + Math.cos(46905) * 53;
+acc += Math.sin(46905) + Math.cos(46906) * 54;
+acc += Math.sin(46906) + Math.cos(46907) * 55;
+acc += Math.sin(46907) + Math.cos(46908) * 56;
+acc += Math.sin(46908) + Math.cos(46909) * 57;
+acc += Math.sin(46909) + Math.cos(46910) * 58;
+acc += Math.sin(46910) + Math.cos(46911) * 59;
+acc += Math.sin(46911) + Math.cos(46912) * 60;
+acc += Math.sin(46912) + Math.cos(46913) * 61;
+acc += Math.sin(46913) + Math.cos(46914) * 62;
+acc += Math.sin(46914) + Math.cos(46915) * 63;
+acc += Math.sin(46915) + Math.cos(46916) * 64;
+acc += Math.sin(46916) + Math.cos(46917) * 65;
+acc += Math.sin(46917) + Math.cos(46918) * 66;
+acc += Math.sin(46918) + Math.cos(46919) * 67;
+acc += Math.sin(46919) + Math.cos(46920) * 68;
+acc += Math.sin(46920) + Math.cos(46921) * 69;
+acc += Math.sin(46921) + Math.cos(46922) * 70;
+acc += Math.sin(46922) + Math.cos(46923) * 71;
+acc += Math.sin(46923) + Math.cos(46924) * 72;
+acc += Math.sin(46924) + Math.cos(46925) * 73;
+acc += Math.sin(46925) + Math.cos(46926) * 74;
+acc += Math.sin(46926) + Math.cos(46927) * 75;
+acc += Math.sin(46927) + Math.cos(46928) * 76;
+acc += Math.sin(46928) + Math.cos(46929) * 77;
+acc += Math.sin(46929) + Math.cos(46930) * 78;
+acc += Math.sin(46930) + Math.cos(46931) * 79;
+acc += Math.sin(46931) + Math.cos(46932) * 80;
+acc += Math.sin(46932) + Math.cos(46933) * 81;
+acc += Math.sin(46933) + Math.cos(46934) * 82;
+acc += Math.sin(46934) + Math.cos(46935) * 83;
+acc += Math.sin(46935) + Math.cos(46936) * 84;
+acc += Math.sin(46936) + Math.cos(46937) * 85;
+acc += Math.sin(46937) + Math.cos(46938) * 86;
+acc += Math.sin(46938) + Math.cos(46939) * 87;
+acc += Math.sin(46939) + Math.cos(46940) * 88;
+acc += Math.sin(46940) + Math.cos(46941) * 89;
+acc += Math.sin(46941) + Math.cos(46942) * 90;
+acc += Math.sin(46942) + Math.cos(46943) * 91;
+acc += Math.sin(46943) + Math.cos(46944) * 92;
+acc += Math.sin(46944) + Math.cos(46945) * 93;
+acc += Math.sin(46945) + Math.cos(46946) * 94;
+acc += Math.sin(46946) + Math.cos(46947) * 95;
+acc += Math.sin(46947) + Math.cos(46948) * 96;
+acc += Math.sin(46948) + Math.cos(46949) * 0;
+acc += Math.sin(46949) + Math.cos(46950) * 1;
+acc += Math.sin(46950) + Math.cos(46951) * 2;
+acc += Math.sin(46951) + Math.cos(46952) * 3;
+acc += Math.sin(46952) + Math.cos(46953) * 4;
+acc += Math.sin(46953) + Math.cos(46954) * 5;
+acc += Math.sin(46954) + Math.cos(46955) * 6;
+acc += Math.sin(46955) + Math.cos(46956) * 7;
+acc += Math.sin(46956) + Math.cos(46957) * 8;
+acc += Math.sin(46957) + Math.cos(46958) * 9;
+acc += Math.sin(46958) + Math.cos(46959) * 10;
+acc += Math.sin(46959) + Math.cos(46960) * 11;
+acc += Math.sin(46960) + Math.cos(46961) * 12;
+acc += Math.sin(46961) + Math.cos(46962) * 13;
+acc += Math.sin(46962) + Math.cos(46963) * 14;
+acc += Math.sin(46963) + Math.cos(46964) * 15;
+acc += Math.sin(46964) + Math.cos(46965) * 16;
+acc += Math.sin(46965) + Math.cos(46966) * 17;
+acc += Math.sin(46966) + Math.cos(46967) * 18;
+acc += Math.sin(46967) + Math.cos(46968) * 19;
+acc += Math.sin(46968) + Math.cos(46969) * 20;
+acc += Math.sin(46969) + Math.cos(46970) * 21;
+acc += Math.sin(46970) + Math.cos(46971) * 22;
+acc += Math.sin(46971) + Math.cos(46972) * 23;
+acc += Math.sin(46972) + Math.cos(46973) * 24;
+acc += Math.sin(46973) + Math.cos(46974) * 25;
+acc += Math.sin(46974) + Math.cos(46975) * 26;
+acc += Math.sin(46975) + Math.cos(46976) * 27;
+acc += Math.sin(46976) + Math.cos(46977) * 28;
+acc += Math.sin(46977) + Math.cos(46978) * 29;
+acc += Math.sin(46978) + Math.cos(46979) * 30;
+acc += Math.sin(46979) + Math.cos(46980) * 31;
+acc += Math.sin(46980) + Math.cos(46981) * 32;
+acc += Math.sin(46981) + Math.cos(46982) * 33;
+acc += Math.sin(46982) + Math.cos(46983) * 34;
+acc += Math.sin(46983) + Math.cos(46984) * 35;
+acc += Math.sin(46984) + Math.cos(46985) * 36;
+acc += Math.sin(46985) + Math.cos(46986) * 37;
+acc += Math.sin(46986) + Math.cos(46987) * 38;
+acc += Math.sin(46987) + Math.cos(46988) * 39;
+acc += Math.sin(46988) + Math.cos(46989) * 40;
+acc += Math.sin(46989) + Math.cos(46990) * 41;
+acc += Math.sin(46990) + Math.cos(46991) * 42;
+acc += Math.sin(46991) + Math.cos(46992) * 43;
+acc += Math.sin(46992) + Math.cos(46993) * 44;
+acc += Math.sin(46993) + Math.cos(46994) * 45;
+acc += Math.sin(46994) + Math.cos(46995) * 46;
+acc += Math.sin(46995) + Math.cos(46996) * 47;
+acc += Math.sin(46996) + Math.cos(46997) * 48;
+acc += Math.sin(46997) + Math.cos(46998) * 49;
+acc += Math.sin(46998) + Math.cos(46999) * 50;
+acc += Math.sin(46999) + Math.cos(47000) * 51;
+acc += Math.sin(47000) + Math.cos(47001) * 52;
+acc += Math.sin(47001) + Math.cos(47002) * 53;
+acc += Math.sin(47002) + Math.cos(47003) * 54;
+acc += Math.sin(47003) + Math.cos(47004) * 55;
+acc += Math.sin(47004) + Math.cos(47005) * 56;
+acc += Math.sin(47005) + Math.cos(47006) * 57;
+acc += Math.sin(47006) + Math.cos(47007) * 58;
+acc += Math.sin(47007) + Math.cos(47008) * 59;
+acc += Math.sin(47008) + Math.cos(47009) * 60;
+acc += Math.sin(47009) + Math.cos(47010) * 61;
+acc += Math.sin(47010) + Math.cos(47011) * 62;
+acc += Math.sin(47011) + Math.cos(47012) * 63;
+acc += Math.sin(47012) + Math.cos(47013) * 64;
+acc += Math.sin(47013) + Math.cos(47014) * 65;
+acc += Math.sin(47014) + Math.cos(47015) * 66;
+acc += Math.sin(47015) + Math.cos(47016) * 67;
+acc += Math.sin(47016) + Math.cos(47017) * 68;
+acc += Math.sin(47017) + Math.cos(47018) * 69;
+acc += Math.sin(47018) + Math.cos(47019) * 70;
+acc += Math.sin(47019) + Math.cos(47020) * 71;
+acc += Math.sin(47020) + Math.cos(47021) * 72;
+acc += Math.sin(47021) + Math.cos(47022) * 73;
+acc += Math.sin(47022) + Math.cos(47023) * 74;
+acc += Math.sin(47023) + Math.cos(47024) * 75;
+acc += Math.sin(47024) + Math.cos(47025) * 76;
+acc += Math.sin(47025) + Math.cos(47026) * 77;
+acc += Math.sin(47026) + Math.cos(47027) * 78;
+acc += Math.sin(47027) + Math.cos(47028) * 79;
+acc += Math.sin(47028) + Math.cos(47029) * 80;
+acc += Math.sin(47029) + Math.cos(47030) * 81;
+acc += Math.sin(47030) + Math.cos(47031) * 82;
+acc += Math.sin(47031) + Math.cos(47032) * 83;
+acc += Math.sin(47032) + Math.cos(47033) * 84;
+acc += Math.sin(47033) + Math.cos(47034) * 85;
+acc += Math.sin(47034) + Math.cos(47035) * 86;
+acc += Math.sin(47035) + Math.cos(47036) * 87;
+acc += Math.sin(47036) + Math.cos(47037) * 88;
+acc += Math.sin(47037) + Math.cos(47038) * 89;
+acc += Math.sin(47038) + Math.cos(47039) * 90;
+acc += Math.sin(47039) + Math.cos(47040) * 91;
+acc += Math.sin(47040) + Math.cos(47041) * 92;
+acc += Math.sin(47041) + Math.cos(47042) * 93;
+acc += Math.sin(47042) + Math.cos(47043) * 94;
+acc += Math.sin(47043) + Math.cos(47044) * 95;
+acc += Math.sin(47044) + Math.cos(47045) * 96;
+acc += Math.sin(47045) + Math.cos(47046) * 0;
+acc += Math.sin(47046) + Math.cos(47047) * 1;
+acc += Math.sin(47047) + Math.cos(47048) * 2;
+acc += Math.sin(47048) + Math.cos(47049) * 3;
+acc += Math.sin(47049) + Math.cos(47050) * 4;
+acc += Math.sin(47050) + Math.cos(47051) * 5;
+acc += Math.sin(47051) + Math.cos(47052) * 6;
+acc += Math.sin(47052) + Math.cos(47053) * 7;
+acc += Math.sin(47053) + Math.cos(47054) * 8;
+acc += Math.sin(47054) + Math.cos(47055) * 9;
+acc += Math.sin(47055) + Math.cos(47056) * 10;
+acc += Math.sin(47056) + Math.cos(47057) * 11;
+acc += Math.sin(47057) + Math.cos(47058) * 12;
+acc += Math.sin(47058) + Math.cos(47059) * 13;
+acc += Math.sin(47059) + Math.cos(47060) * 14;
+acc += Math.sin(47060) + Math.cos(47061) * 15;
+acc += Math.sin(47061) + Math.cos(47062) * 16;
+acc += Math.sin(47062) + Math.cos(47063) * 17;
+acc += Math.sin(47063) + Math.cos(47064) * 18;
+acc += Math.sin(47064) + Math.cos(47065) * 19;
+acc += Math.sin(47065) + Math.cos(47066) * 20;
+acc += Math.sin(47066) + Math.cos(47067) * 21;
+acc += Math.sin(47067) + Math.cos(47068) * 22;
+acc += Math.sin(47068) + Math.cos(47069) * 23;
+acc += Math.sin(47069) + Math.cos(47070) * 24;
+acc += Math.sin(47070) + Math.cos(47071) * 25;
+acc += Math.sin(47071) + Math.cos(47072) * 26;
+acc += Math.sin(47072) + Math.cos(47073) * 27;
+acc += Math.sin(47073) + Math.cos(47074) * 28;
+acc += Math.sin(47074) + Math.cos(47075) * 29;
+acc += Math.sin(47075) + Math.cos(47076) * 30;
+acc += Math.sin(47076) + Math.cos(47077) * 31;
+acc += Math.sin(47077) + Math.cos(47078) * 32;
+acc += Math.sin(47078) + Math.cos(47079) * 33;
+acc += Math.sin(47079) + Math.cos(47080) * 34;
+acc += Math.sin(47080) + Math.cos(47081) * 35;
+acc += Math.sin(47081) + Math.cos(47082) * 36;
+acc += Math.sin(47082) + Math.cos(47083) * 37;
+acc += Math.sin(47083) + Math.cos(47084) * 38;
+acc += Math.sin(47084) + Math.cos(47085) * 39;
+acc += Math.sin(47085) + Math.cos(47086) * 40;
+acc += Math.sin(47086) + Math.cos(47087) * 41;
+acc += Math.sin(47087) + Math.cos(47088) * 42;
+acc += Math.sin(47088) + Math.cos(47089) * 43;
+acc += Math.sin(47089) + Math.cos(47090) * 44;
+acc += Math.sin(47090) + Math.cos(47091) * 45;
+acc += Math.sin(47091) + Math.cos(47092) * 46;
+acc += Math.sin(47092) + Math.cos(47093) * 47;
+acc += Math.sin(47093) + Math.cos(47094) * 48;
+acc += Math.sin(47094) + Math.cos(47095) * 49;
+acc += Math.sin(47095) + Math.cos(47096) * 50;
+acc += Math.sin(47096) + Math.cos(47097) * 51;
+acc += Math.sin(47097) + Math.cos(47098) * 52;
+acc += Math.sin(47098) + Math.cos(47099) * 53;
+acc += Math.sin(47099) + Math.cos(47100) * 54;
+acc += Math.sin(47100) + Math.cos(47101) * 55;
+acc += Math.sin(47101) + Math.cos(47102) * 56;
+acc += Math.sin(47102) + Math.cos(47103) * 57;
+acc += Math.sin(47103) + Math.cos(47104) * 58;
+acc += Math.sin(47104) + Math.cos(47105) * 59;
+acc += Math.sin(47105) + Math.cos(47106) * 60;
+acc += Math.sin(47106) + Math.cos(47107) * 61;
+acc += Math.sin(47107) + Math.cos(47108) * 62;
+acc += Math.sin(47108) + Math.cos(47109) * 63;
+acc += Math.sin(47109) + Math.cos(47110) * 64;
+acc += Math.sin(47110) + Math.cos(47111) * 65;
+acc += Math.sin(47111) + Math.cos(47112) * 66;
+acc += Math.sin(47112) + Math.cos(47113) * 67;
+acc += Math.sin(47113) + Math.cos(47114) * 68;
+acc += Math.sin(47114) + Math.cos(47115) * 69;
+acc += Math.sin(47115) + Math.cos(47116) * 70;
+acc += Math.sin(47116) + Math.cos(47117) * 71;
+acc += Math.sin(47117) + Math.cos(47118) * 72;
+acc += Math.sin(47118) + Math.cos(47119) * 73;
+acc += Math.sin(47119) + Math.cos(47120) * 74;
+acc += Math.sin(47120) + Math.cos(47121) * 75;
+acc += Math.sin(47121) + Math.cos(47122) * 76;
+acc += Math.sin(47122) + Math.cos(47123) * 77;
+acc += Math.sin(47123) + Math.cos(47124) * 78;
+acc += Math.sin(47124) + Math.cos(47125) * 79;
+acc += Math.sin(47125) + Math.cos(47126) * 80;
+acc += Math.sin(47126) + Math.cos(47127) * 81;
+acc += Math.sin(47127) + Math.cos(47128) * 82;
+acc += Math.sin(47128) + Math.cos(47129) * 83;
+acc += Math.sin(47129) + Math.cos(47130) * 84;
+acc += Math.sin(47130) + Math.cos(47131) * 85;
+acc += Math.sin(47131) + Math.cos(47132) * 86;
+acc += Math.sin(47132) + Math.cos(47133) * 87;
+acc += Math.sin(47133) + Math.cos(47134) * 88;
+acc += Math.sin(47134) + Math.cos(47135) * 89;
+acc += Math.sin(47135) + Math.cos(47136) * 90;
+acc += Math.sin(47136) + Math.cos(47137) * 91;
+acc += Math.sin(47137) + Math.cos(47138) * 92;
+acc += Math.sin(47138) + Math.cos(47139) * 93;
+acc += Math.sin(47139) + Math.cos(47140) * 94;
+acc += Math.sin(47140) + Math.cos(47141) * 95;
+acc += Math.sin(47141) + Math.cos(47142) * 96;
+acc += Math.sin(47142) + Math.cos(47143) * 0;
+acc += Math.sin(47143) + Math.cos(47144) * 1;
+acc += Math.sin(47144) + Math.cos(47145) * 2;
+acc += Math.sin(47145) + Math.cos(47146) * 3;
+acc += Math.sin(47146) + Math.cos(47147) * 4;
+acc += Math.sin(47147) + Math.cos(47148) * 5;
+acc += Math.sin(47148) + Math.cos(47149) * 6;
+acc += Math.sin(47149) + Math.cos(47150) * 7;
+acc += Math.sin(47150) + Math.cos(47151) * 8;
+acc += Math.sin(47151) + Math.cos(47152) * 9;
+acc += Math.sin(47152) + Math.cos(47153) * 10;
+acc += Math.sin(47153) + Math.cos(47154) * 11;
+acc += Math.sin(47154) + Math.cos(47155) * 12;
+acc += Math.sin(47155) + Math.cos(47156) * 13;
+acc += Math.sin(47156) + Math.cos(47157) * 14;
+acc += Math.sin(47157) + Math.cos(47158) * 15;
+acc += Math.sin(47158) + Math.cos(47159) * 16;
+acc += Math.sin(47159) + Math.cos(47160) * 17;
+acc += Math.sin(47160) + Math.cos(47161) * 18;
+acc += Math.sin(47161) + Math.cos(47162) * 19;
+acc += Math.sin(47162) + Math.cos(47163) * 20;
+acc += Math.sin(47163) + Math.cos(47164) * 21;
+acc += Math.sin(47164) + Math.cos(47165) * 22;
+acc += Math.sin(47165) + Math.cos(47166) * 23;
+acc += Math.sin(47166) + Math.cos(47167) * 24;
+acc += Math.sin(47167) + Math.cos(47168) * 25;
+acc += Math.sin(47168) + Math.cos(47169) * 26;
+acc += Math.sin(47169) + Math.cos(47170) * 27;
+acc += Math.sin(47170) + Math.cos(47171) * 28;
+acc += Math.sin(47171) + Math.cos(47172) * 29;
+acc += Math.sin(47172) + Math.cos(47173) * 30;
+acc += Math.sin(47173) + Math.cos(47174) * 31;
+acc += Math.sin(47174) + Math.cos(47175) * 32;
+acc += Math.sin(47175) + Math.cos(47176) * 33;
+acc += Math.sin(47176) + Math.cos(47177) * 34;
+acc += Math.sin(47177) + Math.cos(47178) * 35;
+acc += Math.sin(47178) + Math.cos(47179) * 36;
+acc += Math.sin(47179) + Math.cos(47180) * 37;
+acc += Math.sin(47180) + Math.cos(47181) * 38;
+acc += Math.sin(47181) + Math.cos(47182) * 39;
+acc += Math.sin(47182) + Math.cos(47183) * 40;
+acc += Math.sin(47183) + Math.cos(47184) * 41;
+acc += Math.sin(47184) + Math.cos(47185) * 42;
+acc += Math.sin(47185) + Math.cos(47186) * 43;
+acc += Math.sin(47186) + Math.cos(47187) * 44;
+acc += Math.sin(47187) + Math.cos(47188) * 45;
+acc += Math.sin(47188) + Math.cos(47189) * 46;
+acc += Math.sin(47189) + Math.cos(47190) * 47;
+acc += Math.sin(47190) + Math.cos(47191) * 48;
+acc += Math.sin(47191) + Math.cos(47192) * 49;
+acc += Math.sin(47192) + Math.cos(47193) * 50;
+acc += Math.sin(47193) + Math.cos(47194) * 51;
+acc += Math.sin(47194) + Math.cos(47195) * 52;
+acc += Math.sin(47195) + Math.cos(47196) * 53;
+acc += Math.sin(47196) + Math.cos(47197) * 54;
+acc += Math.sin(47197) + Math.cos(47198) * 55;
+acc += Math.sin(47198) + Math.cos(47199) * 56;
+acc += Math.sin(47199) + Math.cos(47200) * 57;
+acc += Math.sin(47200) + Math.cos(47201) * 58;
+acc += Math.sin(47201) + Math.cos(47202) * 59;
+acc += Math.sin(47202) + Math.cos(47203) * 60;
+acc += Math.sin(47203) + Math.cos(47204) * 61;
+acc += Math.sin(47204) + Math.cos(47205) * 62;
+acc += Math.sin(47205) + Math.cos(47206) * 63;
+acc += Math.sin(47206) + Math.cos(47207) * 64;
+acc += Math.sin(47207) + Math.cos(47208) * 65;
+acc += Math.sin(47208) + Math.cos(47209) * 66;
+acc += Math.sin(47209) + Math.cos(47210) * 67;
+acc += Math.sin(47210) + Math.cos(47211) * 68;
+acc += Math.sin(47211) + Math.cos(47212) * 69;
+acc += Math.sin(47212) + Math.cos(47213) * 70;
+acc += Math.sin(47213) + Math.cos(47214) * 71;
+acc += Math.sin(47214) + Math.cos(47215) * 72;
+acc += Math.sin(47215) + Math.cos(47216) * 73;
+acc += Math.sin(47216) + Math.cos(47217) * 74;
+acc += Math.sin(47217) + Math.cos(47218) * 75;
+acc += Math.sin(47218) + Math.cos(47219) * 76;
+acc += Math.sin(47219) + Math.cos(47220) * 77;
+acc += Math.sin(47220) + Math.cos(47221) * 78;
+acc += Math.sin(47221) + Math.cos(47222) * 79;
+acc += Math.sin(47222) + Math.cos(47223) * 80;
+acc += Math.sin(47223) + Math.cos(47224) * 81;
+acc += Math.sin(47224) + Math.cos(47225) * 82;
+acc += Math.sin(47225) + Math.cos(47226) * 83;
+acc += Math.sin(47226) + Math.cos(47227) * 84;
+acc += Math.sin(47227) + Math.cos(47228) * 85;
+acc += Math.sin(47228) + Math.cos(47229) * 86;
+acc += Math.sin(47229) + Math.cos(47230) * 87;
+acc += Math.sin(47230) + Math.cos(47231) * 88;
+acc += Math.sin(47231) + Math.cos(47232) * 89;
+acc += Math.sin(47232) + Math.cos(47233) * 90;
+acc += Math.sin(47233) + Math.cos(47234) * 91;
+acc += Math.sin(47234) + Math.cos(47235) * 92;
+acc += Math.sin(47235) + Math.cos(47236) * 93;
+acc += Math.sin(47236) + Math.cos(47237) * 94;
+acc += Math.sin(47237) + Math.cos(47238) * 95;
+acc += Math.sin(47238) + Math.cos(47239) * 96;
+acc += Math.sin(47239) + Math.cos(47240) * 0;
+acc += Math.sin(47240) + Math.cos(47241) * 1;
+acc += Math.sin(47241) + Math.cos(47242) * 2;
+acc += Math.sin(47242) + Math.cos(47243) * 3;
+acc += Math.sin(47243) + Math.cos(47244) * 4;
+acc += Math.sin(47244) + Math.cos(47245) * 5;
+acc += Math.sin(47245) + Math.cos(47246) * 6;
+acc += Math.sin(47246) + Math.cos(47247) * 7;
+acc += Math.sin(47247) + Math.cos(47248) * 8;
+acc += Math.sin(47248) + Math.cos(47249) * 9;
+acc += Math.sin(47249) + Math.cos(47250) * 10;
+acc += Math.sin(47250) + Math.cos(47251) * 11;
+acc += Math.sin(47251) + Math.cos(47252) * 12;
+acc += Math.sin(47252) + Math.cos(47253) * 13;
+acc += Math.sin(47253) + Math.cos(47254) * 14;
+acc += Math.sin(47254) + Math.cos(47255) * 15;
+acc += Math.sin(47255) + Math.cos(47256) * 16;
+acc += Math.sin(47256) + Math.cos(47257) * 17;
+acc += Math.sin(47257) + Math.cos(47258) * 18;
+acc += Math.sin(47258) + Math.cos(47259) * 19;
+acc += Math.sin(47259) + Math.cos(47260) * 20;
+acc += Math.sin(47260) + Math.cos(47261) * 21;
+acc += Math.sin(47261) + Math.cos(47262) * 22;
+acc += Math.sin(47262) + Math.cos(47263) * 23;
+acc += Math.sin(47263) + Math.cos(47264) * 24;
+acc += Math.sin(47264) + Math.cos(47265) * 25;
+acc += Math.sin(47265) + Math.cos(47266) * 26;
+acc += Math.sin(47266) + Math.cos(47267) * 27;
+acc += Math.sin(47267) + Math.cos(47268) * 28;
+acc += Math.sin(47268) + Math.cos(47269) * 29;
+acc += Math.sin(47269) + Math.cos(47270) * 30;
+acc += Math.sin(47270) + Math.cos(47271) * 31;
+acc += Math.sin(47271) + Math.cos(47272) * 32;
+acc += Math.sin(47272) + Math.cos(47273) * 33;
+acc += Math.sin(47273) + Math.cos(47274) * 34;
+acc += Math.sin(47274) + Math.cos(47275) * 35;
+acc += Math.sin(47275) + Math.cos(47276) * 36;
+acc += Math.sin(47276) + Math.cos(47277) * 37;
+acc += Math.sin(47277) + Math.cos(47278) * 38;
+acc += Math.sin(47278) + Math.cos(47279) * 39;
+acc += Math.sin(47279) + Math.cos(47280) * 40;
+acc += Math.sin(47280) + Math.cos(47281) * 41;
+acc += Math.sin(47281) + Math.cos(47282) * 42;
+acc += Math.sin(47282) + Math.cos(47283) * 43;
+acc += Math.sin(47283) + Math.cos(47284) * 44;
+acc += Math.sin(47284) + Math.cos(47285) * 45;
+acc += Math.sin(47285) + Math.cos(47286) * 46;
+acc += Math.sin(47286) + Math.cos(47287) * 47;
+acc += Math.sin(47287) + Math.cos(47288) * 48;
+acc += Math.sin(47288) + Math.cos(47289) * 49;
+acc += Math.sin(47289) + Math.cos(47290) * 50;
+acc += Math.sin(47290) + Math.cos(47291) * 51;
+acc += Math.sin(47291) + Math.cos(47292) * 52;
+acc += Math.sin(47292) + Math.cos(47293) * 53;
+acc += Math.sin(47293) + Math.cos(47294) * 54;
+acc += Math.sin(47294) + Math.cos(47295) * 55;
+acc += Math.sin(47295) + Math.cos(47296) * 56;
+acc += Math.sin(47296) + Math.cos(47297) * 57;
+acc += Math.sin(47297) + Math.cos(47298) * 58;
+acc += Math.sin(47298) + Math.cos(47299) * 59;
+acc += Math.sin(47299) + Math.cos(47300) * 60;
+acc += Math.sin(47300) + Math.cos(47301) * 61;
+acc += Math.sin(47301) + Math.cos(47302) * 62;
+acc += Math.sin(47302) + Math.cos(47303) * 63;
+acc += Math.sin(47303) + Math.cos(47304) * 64;
+acc += Math.sin(47304) + Math.cos(47305) * 65;
+acc += Math.sin(47305) + Math.cos(47306) * 66;
+acc += Math.sin(47306) + Math.cos(47307) * 67;
+acc += Math.sin(47307) + Math.cos(47308) * 68;
+acc += Math.sin(47308) + Math.cos(47309) * 69;
+acc += Math.sin(47309) + Math.cos(47310) * 70;
+acc += Math.sin(47310) + Math.cos(47311) * 71;
+acc += Math.sin(47311) + Math.cos(47312) * 72;
+acc += Math.sin(47312) + Math.cos(47313) * 73;
+acc += Math.sin(47313) + Math.cos(47314) * 74;
+acc += Math.sin(47314) + Math.cos(47315) * 75;
+acc += Math.sin(47315) + Math.cos(47316) * 76;
+acc += Math.sin(47316) + Math.cos(47317) * 77;
+acc += Math.sin(47317) + Math.cos(47318) * 78;
+acc += Math.sin(47318) + Math.cos(47319) * 79;
+acc += Math.sin(47319) + Math.cos(47320) * 80;
+acc += Math.sin(47320) + Math.cos(47321) * 81;
+acc += Math.sin(47321) + Math.cos(47322) * 82;
+acc += Math.sin(47322) + Math.cos(47323) * 83;
+acc += Math.sin(47323) + Math.cos(47324) * 84;
+acc += Math.sin(47324) + Math.cos(47325) * 85;
+acc += Math.sin(47325) + Math.cos(47326) * 86;
+acc += Math.sin(47326) + Math.cos(47327) * 87;
+acc += Math.sin(47327) + Math.cos(47328) * 88;
+acc += Math.sin(47328) + Math.cos(47329) * 89;
+acc += Math.sin(47329) + Math.cos(47330) * 90;
+acc += Math.sin(47330) + Math.cos(47331) * 91;
+acc += Math.sin(47331) + Math.cos(47332) * 92;
+acc += Math.sin(47332) + Math.cos(47333) * 93;
+acc += Math.sin(47333) + Math.cos(47334) * 94;
+acc += Math.sin(47334) + Math.cos(47335) * 95;
+acc += Math.sin(47335) + Math.cos(47336) * 96;
+acc += Math.sin(47336) + Math.cos(47337) * 0;
+acc += Math.sin(47337) + Math.cos(47338) * 1;
+acc += Math.sin(47338) + Math.cos(47339) * 2;
+acc += Math.sin(47339) + Math.cos(47340) * 3;
+acc += Math.sin(47340) + Math.cos(47341) * 4;
+acc += Math.sin(47341) + Math.cos(47342) * 5;
+acc += Math.sin(47342) + Math.cos(47343) * 6;
+acc += Math.sin(47343) + Math.cos(47344) * 7;
+acc += Math.sin(47344) + Math.cos(47345) * 8;
+acc += Math.sin(47345) + Math.cos(47346) * 9;
+acc += Math.sin(47346) + Math.cos(47347) * 10;
+acc += Math.sin(47347) + Math.cos(47348) * 11;
+acc += Math.sin(47348) + Math.cos(47349) * 12;
+acc += Math.sin(47349) + Math.cos(47350) * 13;
+acc += Math.sin(47350) + Math.cos(47351) * 14;
+acc += Math.sin(47351) + Math.cos(47352) * 15;
+acc += Math.sin(47352) + Math.cos(47353) * 16;
+acc += Math.sin(47353) + Math.cos(47354) * 17;
+acc += Math.sin(47354) + Math.cos(47355) * 18;
+acc += Math.sin(47355) + Math.cos(47356) * 19;
+acc += Math.sin(47356) + Math.cos(47357) * 20;
+acc += Math.sin(47357) + Math.cos(47358) * 21;
+acc += Math.sin(47358) + Math.cos(47359) * 22;
+acc += Math.sin(47359) + Math.cos(47360) * 23;
+acc += Math.sin(47360) + Math.cos(47361) * 24;
+acc += Math.sin(47361) + Math.cos(47362) * 25;
+acc += Math.sin(47362) + Math.cos(47363) * 26;
+acc += Math.sin(47363) + Math.cos(47364) * 27;
+acc += Math.sin(47364) + Math.cos(47365) * 28;
+acc += Math.sin(47365) + Math.cos(47366) * 29;
+acc += Math.sin(47366) + Math.cos(47367) * 30;
+acc += Math.sin(47367) + Math.cos(47368) * 31;
+acc += Math.sin(47368) + Math.cos(47369) * 32;
+acc += Math.sin(47369) + Math.cos(47370) * 33;
+acc += Math.sin(47370) + Math.cos(47371) * 34;
+acc += Math.sin(47371) + Math.cos(47372) * 35;
+acc += Math.sin(47372) + Math.cos(47373) * 36;
+acc += Math.sin(47373) + Math.cos(47374) * 37;
+acc += Math.sin(47374) + Math.cos(47375) * 38;
+acc += Math.sin(47375) + Math.cos(47376) * 39;
+acc += Math.sin(47376) + Math.cos(47377) * 40;
+acc += Math.sin(47377) + Math.cos(47378) * 41;
+acc += Math.sin(47378) + Math.cos(47379) * 42;
+acc += Math.sin(47379) + Math.cos(47380) * 43;
+acc += Math.sin(47380) + Math.cos(47381) * 44;
+acc += Math.sin(47381) + Math.cos(47382) * 45;
+acc += Math.sin(47382) + Math.cos(47383) * 46;
+acc += Math.sin(47383) + Math.cos(47384) * 47;
+acc += Math.sin(47384) + Math.cos(47385) * 48;
+acc += Math.sin(47385) + Math.cos(47386) * 49;
+acc += Math.sin(47386) + Math.cos(47387) * 50;
+acc += Math.sin(47387) + Math.cos(47388) * 51;
+acc += Math.sin(47388) + Math.cos(47389) * 52;
+acc += Math.sin(47389) + Math.cos(47390) * 53;
+acc += Math.sin(47390) + Math.cos(47391) * 54;
+acc += Math.sin(47391) + Math.cos(47392) * 55;
+acc += Math.sin(47392) + Math.cos(47393) * 56;
+acc += Math.sin(47393) + Math.cos(47394) * 57;
+acc += Math.sin(47394) + Math.cos(47395) * 58;
+acc += Math.sin(47395) + Math.cos(47396) * 59;
+acc += Math.sin(47396) + Math.cos(47397) * 60;
+acc += Math.sin(47397) + Math.cos(47398) * 61;
+acc += Math.sin(47398) + Math.cos(47399) * 62;
+acc += Math.sin(47399) + Math.cos(47400) * 63;
+acc += Math.sin(47400) + Math.cos(47401) * 64;
+acc += Math.sin(47401) + Math.cos(47402) * 65;
+acc += Math.sin(47402) + Math.cos(47403) * 66;
+acc += Math.sin(47403) + Math.cos(47404) * 67;
+acc += Math.sin(47404) + Math.cos(47405) * 68;
+acc += Math.sin(47405) + Math.cos(47406) * 69;
+acc += Math.sin(47406) + Math.cos(47407) * 70;
+acc += Math.sin(47407) + Math.cos(47408) * 71;
+acc += Math.sin(47408) + Math.cos(47409) * 72;
+acc += Math.sin(47409) + Math.cos(47410) * 73;
+acc += Math.sin(47410) + Math.cos(47411) * 74;
+acc += Math.sin(47411) + Math.cos(47412) * 75;
+acc += Math.sin(47412) + Math.cos(47413) * 76;
+acc += Math.sin(47413) + Math.cos(47414) * 77;
+acc += Math.sin(47414) + Math.cos(47415) * 78;
+acc += Math.sin(47415) + Math.cos(47416) * 79;
+acc += Math.sin(47416) + Math.cos(47417) * 80;
+acc += Math.sin(47417) + Math.cos(47418) * 81;
+acc += Math.sin(47418) + Math.cos(47419) * 82;
+acc += Math.sin(47419) + Math.cos(47420) * 83;
+acc += Math.sin(47420) + Math.cos(47421) * 84;
+acc += Math.sin(47421) + Math.cos(47422) * 85;
+acc += Math.sin(47422) + Math.cos(47423) * 86;
+acc += Math.sin(47423) + Math.cos(47424) * 87;
+acc += Math.sin(47424) + Math.cos(47425) * 88;
+acc += Math.sin(47425) + Math.cos(47426) * 89;
+acc += Math.sin(47426) + Math.cos(47427) * 90;
+acc += Math.sin(47427) + Math.cos(47428) * 91;
+acc += Math.sin(47428) + Math.cos(47429) * 92;
+acc += Math.sin(47429) + Math.cos(47430) * 93;
+acc += Math.sin(47430) + Math.cos(47431) * 94;
+acc += Math.sin(47431) + Math.cos(47432) * 95;
+acc += Math.sin(47432) + Math.cos(47433) * 96;
+acc += Math.sin(47433) + Math.cos(47434) * 0;
+acc += Math.sin(47434) + Math.cos(47435) * 1;
+acc += Math.sin(47435) + Math.cos(47436) * 2;
+acc += Math.sin(47436) + Math.cos(47437) * 3;
+acc += Math.sin(47437) + Math.cos(47438) * 4;
+acc += Math.sin(47438) + Math.cos(47439) * 5;
+acc += Math.sin(47439) + Math.cos(47440) * 6;
+acc += Math.sin(47440) + Math.cos(47441) * 7;
+acc += Math.sin(47441) + Math.cos(47442) * 8;
+acc += Math.sin(47442) + Math.cos(47443) * 9;
+acc += Math.sin(47443) + Math.cos(47444) * 10;
+acc += Math.sin(47444) + Math.cos(47445) * 11;
+acc += Math.sin(47445) + Math.cos(47446) * 12;
+acc += Math.sin(47446) + Math.cos(47447) * 13;
+acc += Math.sin(47447) + Math.cos(47448) * 14;
+acc += Math.sin(47448) + Math.cos(47449) * 15;
+acc += Math.sin(47449) + Math.cos(47450) * 16;
+acc += Math.sin(47450) + Math.cos(47451) * 17;
+acc += Math.sin(47451) + Math.cos(47452) * 18;
+acc += Math.sin(47452) + Math.cos(47453) * 19;
+acc += Math.sin(47453) + Math.cos(47454) * 20;
+acc += Math.sin(47454) + Math.cos(47455) * 21;
+acc += Math.sin(47455) + Math.cos(47456) * 22;
+acc += Math.sin(47456) + Math.cos(47457) * 23;
+acc += Math.sin(47457) + Math.cos(47458) * 24;
+acc += Math.sin(47458) + Math.cos(47459) * 25;
+acc += Math.sin(47459) + Math.cos(47460) * 26;
+acc += Math.sin(47460) + Math.cos(47461) * 27;
+acc += Math.sin(47461) + Math.cos(47462) * 28;
+acc += Math.sin(47462) + Math.cos(47463) * 29;
+acc += Math.sin(47463) + Math.cos(47464) * 30;
+acc += Math.sin(47464) + Math.cos(47465) * 31;
+acc += Math.sin(47465) + Math.cos(47466) * 32;
+acc += Math.sin(47466) + Math.cos(47467) * 33;
+acc += Math.sin(47467) + Math.cos(47468) * 34;
+acc += Math.sin(47468) + Math.cos(47469) * 35;
+acc += Math.sin(47469) + Math.cos(47470) * 36;
+acc += Math.sin(47470) + Math.cos(47471) * 37;
+acc += Math.sin(47471) + Math.cos(47472) * 38;
+acc += Math.sin(47472) + Math.cos(47473) * 39;
+acc += Math.sin(47473) + Math.cos(47474) * 40;
+acc += Math.sin(47474) + Math.cos(47475) * 41;
+acc += Math.sin(47475) + Math.cos(47476) * 42;
+acc += Math.sin(47476) + Math.cos(47477) * 43;
+acc += Math.sin(47477) + Math.cos(47478) * 44;
+acc += Math.sin(47478) + Math.cos(47479) * 45;
+acc += Math.sin(47479) + Math.cos(47480) * 46;
+acc += Math.sin(47480) + Math.cos(47481) * 47;
+acc += Math.sin(47481) + Math.cos(47482) * 48;
+acc += Math.sin(47482) + Math.cos(47483) * 49;
+acc += Math.sin(47483) + Math.cos(47484) * 50;
+acc += Math.sin(47484) + Math.cos(47485) * 51;
+acc += Math.sin(47485) + Math.cos(47486) * 52;
+acc += Math.sin(47486) + Math.cos(47487) * 53;
+acc += Math.sin(47487) + Math.cos(47488) * 54;
+acc += Math.sin(47488) + Math.cos(47489) * 55;
+acc += Math.sin(47489) + Math.cos(47490) * 56;
+acc += Math.sin(47490) + Math.cos(47491) * 57;
+acc += Math.sin(47491) + Math.cos(47492) * 58;
+acc += Math.sin(47492) + Math.cos(47493) * 59;
+acc += Math.sin(47493) + Math.cos(47494) * 60;
+acc += Math.sin(47494) + Math.cos(47495) * 61;
+acc += Math.sin(47495) + Math.cos(47496) * 62;
+acc += Math.sin(47496) + Math.cos(47497) * 63;
+acc += Math.sin(47497) + Math.cos(47498) * 64;
+acc += Math.sin(47498) + Math.cos(47499) * 65;
+acc += Math.sin(47499) + Math.cos(47500) * 66;
+acc += Math.sin(47500) + Math.cos(47501) * 67;
+acc += Math.sin(47501) + Math.cos(47502) * 68;
+acc += Math.sin(47502) + Math.cos(47503) * 69;
+acc += Math.sin(47503) + Math.cos(47504) * 70;
+acc += Math.sin(47504) + Math.cos(47505) * 71;
+acc += Math.sin(47505) + Math.cos(47506) * 72;
+acc += Math.sin(47506) + Math.cos(47507) * 73;
+acc += Math.sin(47507) + Math.cos(47508) * 74;
+acc += Math.sin(47508) + Math.cos(47509) * 75;
+acc += Math.sin(47509) + Math.cos(47510) * 76;
+acc += Math.sin(47510) + Math.cos(47511) * 77;
+acc += Math.sin(47511) + Math.cos(47512) * 78;
+acc += Math.sin(47512) + Math.cos(47513) * 79;
+acc += Math.sin(47513) + Math.cos(47514) * 80;
+acc += Math.sin(47514) + Math.cos(47515) * 81;
+acc += Math.sin(47515) + Math.cos(47516) * 82;
+acc += Math.sin(47516) + Math.cos(47517) * 83;
+acc += Math.sin(47517) + Math.cos(47518) * 84;
+acc += Math.sin(47518) + Math.cos(47519) * 85;
+acc += Math.sin(47519) + Math.cos(47520) * 86;
+acc += Math.sin(47520) + Math.cos(47521) * 87;
+acc += Math.sin(47521) + Math.cos(47522) * 88;
+acc += Math.sin(47522) + Math.cos(47523) * 89;
+acc += Math.sin(47523) + Math.cos(47524) * 90;
+acc += Math.sin(47524) + Math.cos(47525) * 91;
+acc += Math.sin(47525) + Math.cos(47526) * 92;
+acc += Math.sin(47526) + Math.cos(47527) * 93;
+acc += Math.sin(47527) + Math.cos(47528) * 94;
+acc += Math.sin(47528) + Math.cos(47529) * 95;
+acc += Math.sin(47529) + Math.cos(47530) * 96;
+acc += Math.sin(47530) + Math.cos(47531) * 0;
+acc += Math.sin(47531) + Math.cos(47532) * 1;
+acc += Math.sin(47532) + Math.cos(47533) * 2;
+acc += Math.sin(47533) + Math.cos(47534) * 3;
+acc += Math.sin(47534) + Math.cos(47535) * 4;
+acc += Math.sin(47535) + Math.cos(47536) * 5;
+acc += Math.sin(47536) + Math.cos(47537) * 6;
+acc += Math.sin(47537) + Math.cos(47538) * 7;
+acc += Math.sin(47538) + Math.cos(47539) * 8;
+acc += Math.sin(47539) + Math.cos(47540) * 9;
+acc += Math.sin(47540) + Math.cos(47541) * 10;
+acc += Math.sin(47541) + Math.cos(47542) * 11;
+acc += Math.sin(47542) + Math.cos(47543) * 12;
+acc += Math.sin(47543) + Math.cos(47544) * 13;
+acc += Math.sin(47544) + Math.cos(47545) * 14;
+acc += Math.sin(47545) + Math.cos(47546) * 15;
+acc += Math.sin(47546) + Math.cos(47547) * 16;
+acc += Math.sin(47547) + Math.cos(47548) * 17;
+acc += Math.sin(47548) + Math.cos(47549) * 18;
+acc += Math.sin(47549) + Math.cos(47550) * 19;
+acc += Math.sin(47550) + Math.cos(47551) * 20;
+acc += Math.sin(47551) + Math.cos(47552) * 21;
+acc += Math.sin(47552) + Math.cos(47553) * 22;
+acc += Math.sin(47553) + Math.cos(47554) * 23;
+acc += Math.sin(47554) + Math.cos(47555) * 24;
+acc += Math.sin(47555) + Math.cos(47556) * 25;
+acc += Math.sin(47556) + Math.cos(47557) * 26;
+acc += Math.sin(47557) + Math.cos(47558) * 27;
+acc += Math.sin(47558) + Math.cos(47559) * 28;
+acc += Math.sin(47559) + Math.cos(47560) * 29;
+acc += Math.sin(47560) + Math.cos(47561) * 30;
+acc += Math.sin(47561) + Math.cos(47562) * 31;
+acc += Math.sin(47562) + Math.cos(47563) * 32;
+acc += Math.sin(47563) + Math.cos(47564) * 33;
+acc += Math.sin(47564) + Math.cos(47565) * 34;
+acc += Math.sin(47565) + Math.cos(47566) * 35;
+acc += Math.sin(47566) + Math.cos(47567) * 36;
+acc += Math.sin(47567) + Math.cos(47568) * 37;
+acc += Math.sin(47568) + Math.cos(47569) * 38;
+acc += Math.sin(47569) + Math.cos(47570) * 39;
+acc += Math.sin(47570) + Math.cos(47571) * 40;
+acc += Math.sin(47571) + Math.cos(47572) * 41;
+acc += Math.sin(47572) + Math.cos(47573) * 42;
+acc += Math.sin(47573) + Math.cos(47574) * 43;
+acc += Math.sin(47574) + Math.cos(47575) * 44;
+acc += Math.sin(47575) + Math.cos(47576) * 45;
+acc += Math.sin(47576) + Math.cos(47577) * 46;
+acc += Math.sin(47577) + Math.cos(47578) * 47;
+acc += Math.sin(47578) + Math.cos(47579) * 48;
+acc += Math.sin(47579) + Math.cos(47580) * 49;
+acc += Math.sin(47580) + Math.cos(47581) * 50;
+acc += Math.sin(47581) + Math.cos(47582) * 51;
+acc += Math.sin(47582) + Math.cos(47583) * 52;
+acc += Math.sin(47583) + Math.cos(47584) * 53;
+acc += Math.sin(47584) + Math.cos(47585) * 54;
+acc += Math.sin(47585) + Math.cos(47586) * 55;
+acc += Math.sin(47586) + Math.cos(47587) * 56;
+acc += Math.sin(47587) + Math.cos(47588) * 57;
+acc += Math.sin(47588) + Math.cos(47589) * 58;
+acc += Math.sin(47589) + Math.cos(47590) * 59;
+acc += Math.sin(47590) + Math.cos(47591) * 60;
+acc += Math.sin(47591) + Math.cos(47592) * 61;
+acc += Math.sin(47592) + Math.cos(47593) * 62;
+acc += Math.sin(47593) + Math.cos(47594) * 63;
+acc += Math.sin(47594) + Math.cos(47595) * 64;
+acc += Math.sin(47595) + Math.cos(47596) * 65;
+acc += Math.sin(47596) + Math.cos(47597) * 66;
+acc += Math.sin(47597) + Math.cos(47598) * 67;
+acc += Math.sin(47598) + Math.cos(47599) * 68;
+acc += Math.sin(47599) + Math.cos(47600) * 69;
+acc += Math.sin(47600) + Math.cos(47601) * 70;
+acc += Math.sin(47601) + Math.cos(47602) * 71;
+acc += Math.sin(47602) + Math.cos(47603) * 72;
+acc += Math.sin(47603) + Math.cos(47604) * 73;
+acc += Math.sin(47604) + Math.cos(47605) * 74;
+acc += Math.sin(47605) + Math.cos(47606) * 75;
+acc += Math.sin(47606) + Math.cos(47607) * 76;
+acc += Math.sin(47607) + Math.cos(47608) * 77;
+acc += Math.sin(47608) + Math.cos(47609) * 78;
+acc += Math.sin(47609) + Math.cos(47610) * 79;
+acc += Math.sin(47610) + Math.cos(47611) * 80;
+acc += Math.sin(47611) + Math.cos(47612) * 81;
+acc += Math.sin(47612) + Math.cos(47613) * 82;
+acc += Math.sin(47613) + Math.cos(47614) * 83;
+acc += Math.sin(47614) + Math.cos(47615) * 84;
+acc += Math.sin(47615) + Math.cos(47616) * 85;
+acc += Math.sin(47616) + Math.cos(47617) * 86;
+acc += Math.sin(47617) + Math.cos(47618) * 87;
+acc += Math.sin(47618) + Math.cos(47619) * 88;
+acc += Math.sin(47619) + Math.cos(47620) * 89;
+acc += Math.sin(47620) + Math.cos(47621) * 90;
+acc += Math.sin(47621) + Math.cos(47622) * 91;
+acc += Math.sin(47622) + Math.cos(47623) * 92;
+acc += Math.sin(47623) + Math.cos(47624) * 93;
+acc += Math.sin(47624) + Math.cos(47625) * 94;
+acc += Math.sin(47625) + Math.cos(47626) * 95;
+acc += Math.sin(47626) + Math.cos(47627) * 96;
+acc += Math.sin(47627) + Math.cos(47628) * 0;
+acc += Math.sin(47628) + Math.cos(47629) * 1;
+acc += Math.sin(47629) + Math.cos(47630) * 2;
+acc += Math.sin(47630) + Math.cos(47631) * 3;
+acc += Math.sin(47631) + Math.cos(47632) * 4;
+acc += Math.sin(47632) + Math.cos(47633) * 5;
+acc += Math.sin(47633) + Math.cos(47634) * 6;
+acc += Math.sin(47634) + Math.cos(47635) * 7;
+acc += Math.sin(47635) + Math.cos(47636) * 8;
+acc += Math.sin(47636) + Math.cos(47637) * 9;
+acc += Math.sin(47637) + Math.cos(47638) * 10;
+acc += Math.sin(47638) + Math.cos(47639) * 11;
+acc += Math.sin(47639) + Math.cos(47640) * 12;
+acc += Math.sin(47640) + Math.cos(47641) * 13;
+acc += Math.sin(47641) + Math.cos(47642) * 14;
+acc += Math.sin(47642) + Math.cos(47643) * 15;
+acc += Math.sin(47643) + Math.cos(47644) * 16;
+acc += Math.sin(47644) + Math.cos(47645) * 17;
+acc += Math.sin(47645) + Math.cos(47646) * 18;
+acc += Math.sin(47646) + Math.cos(47647) * 19;
+acc += Math.sin(47647) + Math.cos(47648) * 20;
+acc += Math.sin(47648) + Math.cos(47649) * 21;
+acc += Math.sin(47649) + Math.cos(47650) * 22;
+acc += Math.sin(47650) + Math.cos(47651) * 23;
+acc += Math.sin(47651) + Math.cos(47652) * 24;
+acc += Math.sin(47652) + Math.cos(47653) * 25;
+acc += Math.sin(47653) + Math.cos(47654) * 26;
+acc += Math.sin(47654) + Math.cos(47655) * 27;
+acc += Math.sin(47655) + Math.cos(47656) * 28;
+acc += Math.sin(47656) + Math.cos(47657) * 29;
+acc += Math.sin(47657) + Math.cos(47658) * 30;
+acc += Math.sin(47658) + Math.cos(47659) * 31;
+acc += Math.sin(47659) + Math.cos(47660) * 32;
+acc += Math.sin(47660) + Math.cos(47661) * 33;
+acc += Math.sin(47661) + Math.cos(47662) * 34;
+acc += Math.sin(47662) + Math.cos(47663) * 35;
+acc += Math.sin(47663) + Math.cos(47664) * 36;
+acc += Math.sin(47664) + Math.cos(47665) * 37;
+acc += Math.sin(47665) + Math.cos(47666) * 38;
+acc += Math.sin(47666) + Math.cos(47667) * 39;
+acc += Math.sin(47667) + Math.cos(47668) * 40;
+acc += Math.sin(47668) + Math.cos(47669) * 41;
+acc += Math.sin(47669) + Math.cos(47670) * 42;
+acc += Math.sin(47670) + Math.cos(47671) * 43;
+acc += Math.sin(47671) + Math.cos(47672) * 44;
+acc += Math.sin(47672) + Math.cos(47673) * 45;
+acc += Math.sin(47673) + Math.cos(47674) * 46;
+acc += Math.sin(47674) + Math.cos(47675) * 47;
+acc += Math.sin(47675) + Math.cos(47676) * 48;
+acc += Math.sin(47676) + Math.cos(47677) * 49;
+acc += Math.sin(47677) + Math.cos(47678) * 50;
+acc += Math.sin(47678) + Math.cos(47679) * 51;
+acc += Math.sin(47679) + Math.cos(47680) * 52;
+acc += Math.sin(47680) + Math.cos(47681) * 53;
+acc += Math.sin(47681) + Math.cos(47682) * 54;
+acc += Math.sin(47682) + Math.cos(47683) * 55;
+acc += Math.sin(47683) + Math.cos(47684) * 56;
+acc += Math.sin(47684) + Math.cos(47685) * 57;
+acc += Math.sin(47685) + Math.cos(47686) * 58;
+acc += Math.sin(47686) + Math.cos(47687) * 59;
+acc += Math.sin(47687) + Math.cos(47688) * 60;
+acc += Math.sin(47688) + Math.cos(47689) * 61;
+acc += Math.sin(47689) + Math.cos(47690) * 62;
+acc += Math.sin(47690) + Math.cos(47691) * 63;
+acc += Math.sin(47691) + Math.cos(47692) * 64;
+acc += Math.sin(47692) + Math.cos(47693) * 65;
+acc += Math.sin(47693) + Math.cos(47694) * 66;
+acc += Math.sin(47694) + Math.cos(47695) * 67;
+acc += Math.sin(47695) + Math.cos(47696) * 68;
+acc += Math.sin(47696) + Math.cos(47697) * 69;
+acc += Math.sin(47697) + Math.cos(47698) * 70;
+acc += Math.sin(47698) + Math.cos(47699) * 71;
+acc += Math.sin(47699) + Math.cos(47700) * 72;
+acc += Math.sin(47700) + Math.cos(47701) * 73;
+acc += Math.sin(47701) + Math.cos(47702) * 74;
+acc += Math.sin(47702) + Math.cos(47703) * 75;
+acc += Math.sin(47703) + Math.cos(47704) * 76;
+acc += Math.sin(47704) + Math.cos(47705) * 77;
+acc += Math.sin(47705) + Math.cos(47706) * 78;
+acc += Math.sin(47706) + Math.cos(47707) * 79;
+acc += Math.sin(47707) + Math.cos(47708) * 80;
+acc += Math.sin(47708) + Math.cos(47709) * 81;
+acc += Math.sin(47709) + Math.cos(47710) * 82;
+acc += Math.sin(47710) + Math.cos(47711) * 83;
+acc += Math.sin(47711) + Math.cos(47712) * 84;
+acc += Math.sin(47712) + Math.cos(47713) * 85;
+acc += Math.sin(47713) + Math.cos(47714) * 86;
+acc += Math.sin(47714) + Math.cos(47715) * 87;
+acc += Math.sin(47715) + Math.cos(47716) * 88;
+acc += Math.sin(47716) + Math.cos(47717) * 89;
+acc += Math.sin(47717) + Math.cos(47718) * 90;
+acc += Math.sin(47718) + Math.cos(47719) * 91;
+acc += Math.sin(47719) + Math.cos(47720) * 92;
+acc += Math.sin(47720) + Math.cos(47721) * 93;
+acc += Math.sin(47721) + Math.cos(47722) * 94;
+acc += Math.sin(47722) + Math.cos(47723) * 95;
+acc += Math.sin(47723) + Math.cos(47724) * 96;
+acc += Math.sin(47724) + Math.cos(47725) * 0;
+acc += Math.sin(47725) + Math.cos(47726) * 1;
+acc += Math.sin(47726) + Math.cos(47727) * 2;
+acc += Math.sin(47727) + Math.cos(47728) * 3;
+acc += Math.sin(47728) + Math.cos(47729) * 4;
+acc += Math.sin(47729) + Math.cos(47730) * 5;
+acc += Math.sin(47730) + Math.cos(47731) * 6;
+acc += Math.sin(47731) + Math.cos(47732) * 7;
+acc += Math.sin(47732) + Math.cos(47733) * 8;
+acc += Math.sin(47733) + Math.cos(47734) * 9;
+acc += Math.sin(47734) + Math.cos(47735) * 10;
+acc += Math.sin(47735) + Math.cos(47736) * 11;
+acc += Math.sin(47736) + Math.cos(47737) * 12;
+acc += Math.sin(47737) + Math.cos(47738) * 13;
+acc += Math.sin(47738) + Math.cos(47739) * 14;
+acc += Math.sin(47739) + Math.cos(47740) * 15;
+acc += Math.sin(47740) + Math.cos(47741) * 16;
+acc += Math.sin(47741) + Math.cos(47742) * 17;
+acc += Math.sin(47742) + Math.cos(47743) * 18;
+acc += Math.sin(47743) + Math.cos(47744) * 19;
+acc += Math.sin(47744) + Math.cos(47745) * 20;
+acc += Math.sin(47745) + Math.cos(47746) * 21;
+acc += Math.sin(47746) + Math.cos(47747) * 22;
+acc += Math.sin(47747) + Math.cos(47748) * 23;
+acc += Math.sin(47748) + Math.cos(47749) * 24;
+acc += Math.sin(47749) + Math.cos(47750) * 25;
+acc += Math.sin(47750) + Math.cos(47751) * 26;
+acc += Math.sin(47751) + Math.cos(47752) * 27;
+acc += Math.sin(47752) + Math.cos(47753) * 28;
+acc += Math.sin(47753) + Math.cos(47754) * 29;
+acc += Math.sin(47754) + Math.cos(47755) * 30;
+acc += Math.sin(47755) + Math.cos(47756) * 31;
+acc += Math.sin(47756) + Math.cos(47757) * 32;
+acc += Math.sin(47757) + Math.cos(47758) * 33;
+acc += Math.sin(47758) + Math.cos(47759) * 34;
+acc += Math.sin(47759) + Math.cos(47760) * 35;
+acc += Math.sin(47760) + Math.cos(47761) * 36;
+acc += Math.sin(47761) + Math.cos(47762) * 37;
+acc += Math.sin(47762) + Math.cos(47763) * 38;
+acc += Math.sin(47763) + Math.cos(47764) * 39;
+acc += Math.sin(47764) + Math.cos(47765) * 40;
+acc += Math.sin(47765) + Math.cos(47766) * 41;
+acc += Math.sin(47766) + Math.cos(47767) * 42;
+acc += Math.sin(47767) + Math.cos(47768) * 43;
+acc += Math.sin(47768) + Math.cos(47769) * 44;
+acc += Math.sin(47769) + Math.cos(47770) * 45;
+acc += Math.sin(47770) + Math.cos(47771) * 46;
+acc += Math.sin(47771) + Math.cos(47772) * 47;
+acc += Math.sin(47772) + Math.cos(47773) * 48;
+acc += Math.sin(47773) + Math.cos(47774) * 49;
+acc += Math.sin(47774) + Math.cos(47775) * 50;
+acc += Math.sin(47775) + Math.cos(47776) * 51;
+acc += Math.sin(47776) + Math.cos(47777) * 52;
+acc += Math.sin(47777) + Math.cos(47778) * 53;
+acc += Math.sin(47778) + Math.cos(47779) * 54;
+acc += Math.sin(47779) + Math.cos(47780) * 55;
+acc += Math.sin(47780) + Math.cos(47781) * 56;
+acc += Math.sin(47781) + Math.cos(47782) * 57;
+acc += Math.sin(47782) + Math.cos(47783) * 58;
+acc += Math.sin(47783) + Math.cos(47784) * 59;
+acc += Math.sin(47784) + Math.cos(47785) * 60;
+acc += Math.sin(47785) + Math.cos(47786) * 61;
+acc += Math.sin(47786) + Math.cos(47787) * 62;
+acc += Math.sin(47787) + Math.cos(47788) * 63;
+acc += Math.sin(47788) + Math.cos(47789) * 64;
+acc += Math.sin(47789) + Math.cos(47790) * 65;
+acc += Math.sin(47790) + Math.cos(47791) * 66;
+acc += Math.sin(47791) + Math.cos(47792) * 67;
+acc += Math.sin(47792) + Math.cos(47793) * 68;
+acc += Math.sin(47793) + Math.cos(47794) * 69;
+acc += Math.sin(47794) + Math.cos(47795) * 70;
+acc += Math.sin(47795) + Math.cos(47796) * 71;
+acc += Math.sin(47796) + Math.cos(47797) * 72;
+acc += Math.sin(47797) + Math.cos(47798) * 73;
+acc += Math.sin(47798) + Math.cos(47799) * 74;
+acc += Math.sin(47799) + Math.cos(47800) * 75;
+acc += Math.sin(47800) + Math.cos(47801) * 76;
+acc += Math.sin(47801) + Math.cos(47802) * 77;
+acc += Math.sin(47802) + Math.cos(47803) * 78;
+acc += Math.sin(47803) + Math.cos(47804) * 79;
+acc += Math.sin(47804) + Math.cos(47805) * 80;
+acc += Math.sin(47805) + Math.cos(47806) * 81;
+acc += Math.sin(47806) + Math.cos(47807) * 82;
+acc += Math.sin(47807) + Math.cos(47808) * 83;
+acc += Math.sin(47808) + Math.cos(47809) * 84;
+acc += Math.sin(47809) + Math.cos(47810) * 85;
+acc += Math.sin(47810) + Math.cos(47811) * 86;
+acc += Math.sin(47811) + Math.cos(47812) * 87;
+acc += Math.sin(47812) + Math.cos(47813) * 88;
+acc += Math.sin(47813) + Math.cos(47814) * 89;
+acc += Math.sin(47814) + Math.cos(47815) * 90;
+acc += Math.sin(47815) + Math.cos(47816) * 91;
+acc += Math.sin(47816) + Math.cos(47817) * 92;
+acc += Math.sin(47817) + Math.cos(47818) * 93;
+acc += Math.sin(47818) + Math.cos(47819) * 94;
+acc += Math.sin(47819) + Math.cos(47820) * 95;
+acc += Math.sin(47820) + Math.cos(47821) * 96;
+acc += Math.sin(47821) + Math.cos(47822) * 0;
+acc += Math.sin(47822) + Math.cos(47823) * 1;
+acc += Math.sin(47823) + Math.cos(47824) * 2;
+acc += Math.sin(47824) + Math.cos(47825) * 3;
+acc += Math.sin(47825) + Math.cos(47826) * 4;
+acc += Math.sin(47826) + Math.cos(47827) * 5;
+acc += Math.sin(47827) + Math.cos(47828) * 6;
+acc += Math.sin(47828) + Math.cos(47829) * 7;
+acc += Math.sin(47829) + Math.cos(47830) * 8;
+acc += Math.sin(47830) + Math.cos(47831) * 9;
+acc += Math.sin(47831) + Math.cos(47832) * 10;
+acc += Math.sin(47832) + Math.cos(47833) * 11;
+acc += Math.sin(47833) + Math.cos(47834) * 12;
+acc += Math.sin(47834) + Math.cos(47835) * 13;
+acc += Math.sin(47835) + Math.cos(47836) * 14;
+acc += Math.sin(47836) + Math.cos(47837) * 15;
+acc += Math.sin(47837) + Math.cos(47838) * 16;
+acc += Math.sin(47838) + Math.cos(47839) * 17;
+acc += Math.sin(47839) + Math.cos(47840) * 18;
+acc += Math.sin(47840) + Math.cos(47841) * 19;
+acc += Math.sin(47841) + Math.cos(47842) * 20;
+acc += Math.sin(47842) + Math.cos(47843) * 21;
+acc += Math.sin(47843) + Math.cos(47844) * 22;
+acc += Math.sin(47844) + Math.cos(47845) * 23;
+acc += Math.sin(47845) + Math.cos(47846) * 24;
+acc += Math.sin(47846) + Math.cos(47847) * 25;
+acc += Math.sin(47847) + Math.cos(47848) * 26;
+acc += Math.sin(47848) + Math.cos(47849) * 27;
+acc += Math.sin(47849) + Math.cos(47850) * 28;
+acc += Math.sin(47850) + Math.cos(47851) * 29;
+acc += Math.sin(47851) + Math.cos(47852) * 30;
+acc += Math.sin(47852) + Math.cos(47853) * 31;
+acc += Math.sin(47853) + Math.cos(47854) * 32;
+acc += Math.sin(47854) + Math.cos(47855) * 33;
+acc += Math.sin(47855) + Math.cos(47856) * 34;
+acc += Math.sin(47856) + Math.cos(47857) * 35;
+acc += Math.sin(47857) + Math.cos(47858) * 36;
+acc += Math.sin(47858) + Math.cos(47859) * 37;
+acc += Math.sin(47859) + Math.cos(47860) * 38;
+acc += Math.sin(47860) + Math.cos(47861) * 39;
+acc += Math.sin(47861) + Math.cos(47862) * 40;
+acc += Math.sin(47862) + Math.cos(47863) * 41;
+acc += Math.sin(47863) + Math.cos(47864) * 42;
+acc += Math.sin(47864) + Math.cos(47865) * 43;
+acc += Math.sin(47865) + Math.cos(47866) * 44;
+acc += Math.sin(47866) + Math.cos(47867) * 45;
+acc += Math.sin(47867) + Math.cos(47868) * 46;
+acc += Math.sin(47868) + Math.cos(47869) * 47;
+acc += Math.sin(47869) + Math.cos(47870) * 48;
+acc += Math.sin(47870) + Math.cos(47871) * 49;
+acc += Math.sin(47871) + Math.cos(47872) * 50;
+acc += Math.sin(47872) + Math.cos(47873) * 51;
+acc += Math.sin(47873) + Math.cos(47874) * 52;
+acc += Math.sin(47874) + Math.cos(47875) * 53;
+acc += Math.sin(47875) + Math.cos(47876) * 54;
+acc += Math.sin(47876) + Math.cos(47877) * 55;
+acc += Math.sin(47877) + Math.cos(47878) * 56;
+acc += Math.sin(47878) + Math.cos(47879) * 57;
+acc += Math.sin(47879) + Math.cos(47880) * 58;
+acc += Math.sin(47880) + Math.cos(47881) * 59;
+acc += Math.sin(47881) + Math.cos(47882) * 60;
+acc += Math.sin(47882) + Math.cos(47883) * 61;
+acc += Math.sin(47883) + Math.cos(47884) * 62;
+acc += Math.sin(47884) + Math.cos(47885) * 63;
+acc += Math.sin(47885) + Math.cos(47886) * 64;
+acc += Math.sin(47886) + Math.cos(47887) * 65;
+acc += Math.sin(47887) + Math.cos(47888) * 66;
+acc += Math.sin(47888) + Math.cos(47889) * 67;
+acc += Math.sin(47889) + Math.cos(47890) * 68;
+acc += Math.sin(47890) + Math.cos(47891) * 69;
+acc += Math.sin(47891) + Math.cos(47892) * 70;
+acc += Math.sin(47892) + Math.cos(47893) * 71;
+acc += Math.sin(47893) + Math.cos(47894) * 72;
+acc += Math.sin(47894) + Math.cos(47895) * 73;
+acc += Math.sin(47895) + Math.cos(47896) * 74;
+acc += Math.sin(47896) + Math.cos(47897) * 75;
+acc += Math.sin(47897) + Math.cos(47898) * 76;
+acc += Math.sin(47898) + Math.cos(47899) * 77;
+acc += Math.sin(47899) + Math.cos(47900) * 78;
+acc += Math.sin(47900) + Math.cos(47901) * 79;
+acc += Math.sin(47901) + Math.cos(47902) * 80;
+acc += Math.sin(47902) + Math.cos(47903) * 81;
+acc += Math.sin(47903) + Math.cos(47904) * 82;
+acc += Math.sin(47904) + Math.cos(47905) * 83;
+acc += Math.sin(47905) + Math.cos(47906) * 84;
+acc += Math.sin(47906) + Math.cos(47907) * 85;
+acc += Math.sin(47907) + Math.cos(47908) * 86;
+acc += Math.sin(47908) + Math.cos(47909) * 87;
+acc += Math.sin(47909) + Math.cos(47910) * 88;
+acc += Math.sin(47910) + Math.cos(47911) * 89;
+acc += Math.sin(47911) + Math.cos(47912) * 90;
+acc += Math.sin(47912) + Math.cos(47913) * 91;
+acc += Math.sin(47913) + Math.cos(47914) * 92;
+acc += Math.sin(47914) + Math.cos(47915) * 93;
+acc += Math.sin(47915) + Math.cos(47916) * 94;
+acc += Math.sin(47916) + Math.cos(47917) * 95;
+acc += Math.sin(47917) + Math.cos(47918) * 96;
+acc += Math.sin(47918) + Math.cos(47919) * 0;
+acc += Math.sin(47919) + Math.cos(47920) * 1;
+acc += Math.sin(47920) + Math.cos(47921) * 2;
+acc += Math.sin(47921) + Math.cos(47922) * 3;
+acc += Math.sin(47922) + Math.cos(47923) * 4;
+acc += Math.sin(47923) + Math.cos(47924) * 5;
+acc += Math.sin(47924) + Math.cos(47925) * 6;
+acc += Math.sin(47925) + Math.cos(47926) * 7;
+acc += Math.sin(47926) + Math.cos(47927) * 8;
+acc += Math.sin(47927) + Math.cos(47928) * 9;
+acc += Math.sin(47928) + Math.cos(47929) * 10;
+acc += Math.sin(47929) + Math.cos(47930) * 11;
+acc += Math.sin(47930) + Math.cos(47931) * 12;
+acc += Math.sin(47931) + Math.cos(47932) * 13;
+acc += Math.sin(47932) + Math.cos(47933) * 14;
+acc += Math.sin(47933) + Math.cos(47934) * 15;
+acc += Math.sin(47934) + Math.cos(47935) * 16;
+acc += Math.sin(47935) + Math.cos(47936) * 17;
+acc += Math.sin(47936) + Math.cos(47937) * 18;
+acc += Math.sin(47937) + Math.cos(47938) * 19;
+acc += Math.sin(47938) + Math.cos(47939) * 20;
+acc += Math.sin(47939) + Math.cos(47940) * 21;
+acc += Math.sin(47940) + Math.cos(47941) * 22;
+acc += Math.sin(47941) + Math.cos(47942) * 23;
+acc += Math.sin(47942) + Math.cos(47943) * 24;
+acc += Math.sin(47943) + Math.cos(47944) * 25;
+acc += Math.sin(47944) + Math.cos(47945) * 26;
+acc += Math.sin(47945) + Math.cos(47946) * 27;
+acc += Math.sin(47946) + Math.cos(47947) * 28;
+acc += Math.sin(47947) + Math.cos(47948) * 29;
+acc += Math.sin(47948) + Math.cos(47949) * 30;
+acc += Math.sin(47949) + Math.cos(47950) * 31;
+acc += Math.sin(47950) + Math.cos(47951) * 32;
+acc += Math.sin(47951) + Math.cos(47952) * 33;
+acc += Math.sin(47952) + Math.cos(47953) * 34;
+acc += Math.sin(47953) + Math.cos(47954) * 35;
+acc += Math.sin(47954) + Math.cos(47955) * 36;
+acc += Math.sin(47955) + Math.cos(47956) * 37;
+acc += Math.sin(47956) + Math.cos(47957) * 38;
+acc += Math.sin(47957) + Math.cos(47958) * 39;
+acc += Math.sin(47958) + Math.cos(47959) * 40;
+acc += Math.sin(47959) + Math.cos(47960) * 41;
+acc += Math.sin(47960) + Math.cos(47961) * 42;
+acc += Math.sin(47961) + Math.cos(47962) * 43;
+acc += Math.sin(47962) + Math.cos(47963) * 44;
+acc += Math.sin(47963) + Math.cos(47964) * 45;
+acc += Math.sin(47964) + Math.cos(47965) * 46;
+acc += Math.sin(47965) + Math.cos(47966) * 47;
+acc += Math.sin(47966) + Math.cos(47967) * 48;
+acc += Math.sin(47967) + Math.cos(47968) * 49;
+acc += Math.sin(47968) + Math.cos(47969) * 50;
+acc += Math.sin(47969) + Math.cos(47970) * 51;
+acc += Math.sin(47970) + Math.cos(47971) * 52;
+acc += Math.sin(47971) + Math.cos(47972) * 53;
+acc += Math.sin(47972) + Math.cos(47973) * 54;
+acc += Math.sin(47973) + Math.cos(47974) * 55;
+acc += Math.sin(47974) + Math.cos(47975) * 56;
+acc += Math.sin(47975) + Math.cos(47976) * 57;
+acc += Math.sin(47976) + Math.cos(47977) * 58;
+acc += Math.sin(47977) + Math.cos(47978) * 59;
+acc += Math.sin(47978) + Math.cos(47979) * 60;
+acc += Math.sin(47979) + Math.cos(47980) * 61;
+acc += Math.sin(47980) + Math.cos(47981) * 62;
+acc += Math.sin(47981) + Math.cos(47982) * 63;
+acc += Math.sin(47982) + Math.cos(47983) * 64;
+acc += Math.sin(47983) + Math.cos(47984) * 65;
+acc += Math.sin(47984) + Math.cos(47985) * 66;
+acc += Math.sin(47985) + Math.cos(47986) * 67;
+acc += Math.sin(47986) + Math.cos(47987) * 68;
+acc += Math.sin(47987) + Math.cos(47988) * 69;
+acc += Math.sin(47988) + Math.cos(47989) * 70;
+acc += Math.sin(47989) + Math.cos(47990) * 71;
+acc += Math.sin(47990) + Math.cos(47991) * 72;
+acc += Math.sin(47991) + Math.cos(47992) * 73;
+acc += Math.sin(47992) + Math.cos(47993) * 74;
+acc += Math.sin(47993) + Math.cos(47994) * 75;
+acc += Math.sin(47994) + Math.cos(47995) * 76;
+acc += Math.sin(47995) + Math.cos(47996) * 77;
+acc += Math.sin(47996) + Math.cos(47997) * 78;
+acc += Math.sin(47997) + Math.cos(47998) * 79;
+acc += Math.sin(47998) + Math.cos(47999) * 80;
+acc += Math.sin(47999) + Math.cos(48000) * 81;
+acc += Math.sin(48000) + Math.cos(48001) * 82;
+acc += Math.sin(48001) + Math.cos(48002) * 83;
+acc += Math.sin(48002) + Math.cos(48003) * 84;
+acc += Math.sin(48003) + Math.cos(48004) * 85;
+acc += Math.sin(48004) + Math.cos(48005) * 86;
+acc += Math.sin(48005) + Math.cos(48006) * 87;
+acc += Math.sin(48006) + Math.cos(48007) * 88;
+acc += Math.sin(48007) + Math.cos(48008) * 89;
+acc += Math.sin(48008) + Math.cos(48009) * 90;
+acc += Math.sin(48009) + Math.cos(48010) * 91;
+acc += Math.sin(48010) + Math.cos(48011) * 92;
+acc += Math.sin(48011) + Math.cos(48012) * 93;
+acc += Math.sin(48012) + Math.cos(48013) * 94;
+acc += Math.sin(48013) + Math.cos(48014) * 95;
+acc += Math.sin(48014) + Math.cos(48015) * 96;
+acc += Math.sin(48015) + Math.cos(48016) * 0;
+acc += Math.sin(48016) + Math.cos(48017) * 1;
+acc += Math.sin(48017) + Math.cos(48018) * 2;
+acc += Math.sin(48018) + Math.cos(48019) * 3;
+acc += Math.sin(48019) + Math.cos(48020) * 4;
+acc += Math.sin(48020) + Math.cos(48021) * 5;
+acc += Math.sin(48021) + Math.cos(48022) * 6;
+acc += Math.sin(48022) + Math.cos(48023) * 7;
+acc += Math.sin(48023) + Math.cos(48024) * 8;
+acc += Math.sin(48024) + Math.cos(48025) * 9;
+acc += Math.sin(48025) + Math.cos(48026) * 10;
+acc += Math.sin(48026) + Math.cos(48027) * 11;
+acc += Math.sin(48027) + Math.cos(48028) * 12;
+acc += Math.sin(48028) + Math.cos(48029) * 13;
+acc += Math.sin(48029) + Math.cos(48030) * 14;
+acc += Math.sin(48030) + Math.cos(48031) * 15;
+acc += Math.sin(48031) + Math.cos(48032) * 16;
+acc += Math.sin(48032) + Math.cos(48033) * 17;
+acc += Math.sin(48033) + Math.cos(48034) * 18;
+acc += Math.sin(48034) + Math.cos(48035) * 19;
+acc += Math.sin(48035) + Math.cos(48036) * 20;
+acc += Math.sin(48036) + Math.cos(48037) * 21;
+acc += Math.sin(48037) + Math.cos(48038) * 22;
+acc += Math.sin(48038) + Math.cos(48039) * 23;
+acc += Math.sin(48039) + Math.cos(48040) * 24;
+acc += Math.sin(48040) + Math.cos(48041) * 25;
+acc += Math.sin(48041) + Math.cos(48042) * 26;
+acc += Math.sin(48042) + Math.cos(48043) * 27;
+acc += Math.sin(48043) + Math.cos(48044) * 28;
+acc += Math.sin(48044) + Math.cos(48045) * 29;
+acc += Math.sin(48045) + Math.cos(48046) * 30;
+acc += Math.sin(48046) + Math.cos(48047) * 31;
+acc += Math.sin(48047) + Math.cos(48048) * 32;
+acc += Math.sin(48048) + Math.cos(48049) * 33;
+acc += Math.sin(48049) + Math.cos(48050) * 34;
+acc += Math.sin(48050) + Math.cos(48051) * 35;
+acc += Math.sin(48051) + Math.cos(48052) * 36;
+acc += Math.sin(48052) + Math.cos(48053) * 37;
+acc += Math.sin(48053) + Math.cos(48054) * 38;
+acc += Math.sin(48054) + Math.cos(48055) * 39;
+acc += Math.sin(48055) + Math.cos(48056) * 40;
+acc += Math.sin(48056) + Math.cos(48057) * 41;
+acc += Math.sin(48057) + Math.cos(48058) * 42;
+acc += Math.sin(48058) + Math.cos(48059) * 43;
+acc += Math.sin(48059) + Math.cos(48060) * 44;
+acc += Math.sin(48060) + Math.cos(48061) * 45;
+acc += Math.sin(48061) + Math.cos(48062) * 46;
+acc += Math.sin(48062) + Math.cos(48063) * 47;
+acc += Math.sin(48063) + Math.cos(48064) * 48;
+acc += Math.sin(48064) + Math.cos(48065) * 49;
+acc += Math.sin(48065) + Math.cos(48066) * 50;
+acc += Math.sin(48066) + Math.cos(48067) * 51;
+acc += Math.sin(48067) + Math.cos(48068) * 52;
+acc += Math.sin(48068) + Math.cos(48069) * 53;
+acc += Math.sin(48069) + Math.cos(48070) * 54;
+acc += Math.sin(48070) + Math.cos(48071) * 55;
+acc += Math.sin(48071) + Math.cos(48072) * 56;
+acc += Math.sin(48072) + Math.cos(48073) * 57;
+acc += Math.sin(48073) + Math.cos(48074) * 58;
+acc += Math.sin(48074) + Math.cos(48075) * 59;
+acc += Math.sin(48075) + Math.cos(48076) * 60;
+acc += Math.sin(48076) + Math.cos(48077) * 61;
+acc += Math.sin(48077) + Math.cos(48078) * 62;
+acc += Math.sin(48078) + Math.cos(48079) * 63;
+acc += Math.sin(48079) + Math.cos(48080) * 64;
+acc += Math.sin(48080) + Math.cos(48081) * 65;
+acc += Math.sin(48081) + Math.cos(48082) * 66;
+acc += Math.sin(48082) + Math.cos(48083) * 67;
+acc += Math.sin(48083) + Math.cos(48084) * 68;
+acc += Math.sin(48084) + Math.cos(48085) * 69;
+acc += Math.sin(48085) + Math.cos(48086) * 70;
+acc += Math.sin(48086) + Math.cos(48087) * 71;
+acc += Math.sin(48087) + Math.cos(48088) * 72;
+acc += Math.sin(48088) + Math.cos(48089) * 73;
+acc += Math.sin(48089) + Math.cos(48090) * 74;
+acc += Math.sin(48090) + Math.cos(48091) * 75;
+acc += Math.sin(48091) + Math.cos(48092) * 76;
+acc += Math.sin(48092) + Math.cos(48093) * 77;
+acc += Math.sin(48093) + Math.cos(48094) * 78;
+acc += Math.sin(48094) + Math.cos(48095) * 79;
+acc += Math.sin(48095) + Math.cos(48096) * 80;
+acc += Math.sin(48096) + Math.cos(48097) * 81;
+acc += Math.sin(48097) + Math.cos(48098) * 82;
+acc += Math.sin(48098) + Math.cos(48099) * 83;
+acc += Math.sin(48099) + Math.cos(48100) * 84;
+acc += Math.sin(48100) + Math.cos(48101) * 85;
+acc += Math.sin(48101) + Math.cos(48102) * 86;
+acc += Math.sin(48102) + Math.cos(48103) * 87;
+acc += Math.sin(48103) + Math.cos(48104) * 88;
+acc += Math.sin(48104) + Math.cos(48105) * 89;
+acc += Math.sin(48105) + Math.cos(48106) * 90;
+acc += Math.sin(48106) + Math.cos(48107) * 91;
+acc += Math.sin(48107) + Math.cos(48108) * 92;
+acc += Math.sin(48108) + Math.cos(48109) * 93;
+acc += Math.sin(48109) + Math.cos(48110) * 94;
+acc += Math.sin(48110) + Math.cos(48111) * 95;
+acc += Math.sin(48111) + Math.cos(48112) * 96;
+acc += Math.sin(48112) + Math.cos(48113) * 0;
+acc += Math.sin(48113) + Math.cos(48114) * 1;
+acc += Math.sin(48114) + Math.cos(48115) * 2;
+acc += Math.sin(48115) + Math.cos(48116) * 3;
+acc += Math.sin(48116) + Math.cos(48117) * 4;
+acc += Math.sin(48117) + Math.cos(48118) * 5;
+acc += Math.sin(48118) + Math.cos(48119) * 6;
+acc += Math.sin(48119) + Math.cos(48120) * 7;
+acc += Math.sin(48120) + Math.cos(48121) * 8;
+acc += Math.sin(48121) + Math.cos(48122) * 9;
+acc += Math.sin(48122) + Math.cos(48123) * 10;
+acc += Math.sin(48123) + Math.cos(48124) * 11;
+acc += Math.sin(48124) + Math.cos(48125) * 12;
+acc += Math.sin(48125) + Math.cos(48126) * 13;
+acc += Math.sin(48126) + Math.cos(48127) * 14;
+acc += Math.sin(48127) + Math.cos(48128) * 15;
+acc += Math.sin(48128) + Math.cos(48129) * 16;
+acc += Math.sin(48129) + Math.cos(48130) * 17;
+acc += Math.sin(48130) + Math.cos(48131) * 18;
+acc += Math.sin(48131) + Math.cos(48132) * 19;
+acc += Math.sin(48132) + Math.cos(48133) * 20;
+acc += Math.sin(48133) + Math.cos(48134) * 21;
+acc += Math.sin(48134) + Math.cos(48135) * 22;
+acc += Math.sin(48135) + Math.cos(48136) * 23;
+acc += Math.sin(48136) + Math.cos(48137) * 24;
+acc += Math.sin(48137) + Math.cos(48138) * 25;
+acc += Math.sin(48138) + Math.cos(48139) * 26;
+acc += Math.sin(48139) + Math.cos(48140) * 27;
+acc += Math.sin(48140) + Math.cos(48141) * 28;
+acc += Math.sin(48141) + Math.cos(48142) * 29;
+acc += Math.sin(48142) + Math.cos(48143) * 30;
+acc += Math.sin(48143) + Math.cos(48144) * 31;
+acc += Math.sin(48144) + Math.cos(48145) * 32;
+acc += Math.sin(48145) + Math.cos(48146) * 33;
+acc += Math.sin(48146) + Math.cos(48147) * 34;
+acc += Math.sin(48147) + Math.cos(48148) * 35;
+acc += Math.sin(48148) + Math.cos(48149) * 36;
+acc += Math.sin(48149) + Math.cos(48150) * 37;
+acc += Math.sin(48150) + Math.cos(48151) * 38;
+acc += Math.sin(48151) + Math.cos(48152) * 39;
+acc += Math.sin(48152) + Math.cos(48153) * 40;
+acc += Math.sin(48153) + Math.cos(48154) * 41;
+acc += Math.sin(48154) + Math.cos(48155) * 42;
+acc += Math.sin(48155) + Math.cos(48156) * 43;
+acc += Math.sin(48156) + Math.cos(48157) * 44;
+acc += Math.sin(48157) + Math.cos(48158) * 45;
+acc += Math.sin(48158) + Math.cos(48159) * 46;
+acc += Math.sin(48159) + Math.cos(48160) * 47;
+acc += Math.sin(48160) + Math.cos(48161) * 48;
+acc += Math.sin(48161) + Math.cos(48162) * 49;
+acc += Math.sin(48162) + Math.cos(48163) * 50;
+acc += Math.sin(48163) + Math.cos(48164) * 51;
+acc += Math.sin(48164) + Math.cos(48165) * 52;
+acc += Math.sin(48165) + Math.cos(48166) * 53;
+acc += Math.sin(48166) + Math.cos(48167) * 54;
+acc += Math.sin(48167) + Math.cos(48168) * 55;
+acc += Math.sin(48168) + Math.cos(48169) * 56;
+acc += Math.sin(48169) + Math.cos(48170) * 57;
+acc += Math.sin(48170) + Math.cos(48171) * 58;
+acc += Math.sin(48171) + Math.cos(48172) * 59;
+acc += Math.sin(48172) + Math.cos(48173) * 60;
+acc += Math.sin(48173) + Math.cos(48174) * 61;
+acc += Math.sin(48174) + Math.cos(48175) * 62;
+acc += Math.sin(48175) + Math.cos(48176) * 63;
+acc += Math.sin(48176) + Math.cos(48177) * 64;
+acc += Math.sin(48177) + Math.cos(48178) * 65;
+acc += Math.sin(48178) + Math.cos(48179) * 66;
+acc += Math.sin(48179) + Math.cos(48180) * 67;
+acc += Math.sin(48180) + Math.cos(48181) * 68;
+acc += Math.sin(48181) + Math.cos(48182) * 69;
+acc += Math.sin(48182) + Math.cos(48183) * 70;
+acc += Math.sin(48183) + Math.cos(48184) * 71;
+acc += Math.sin(48184) + Math.cos(48185) * 72;
+acc += Math.sin(48185) + Math.cos(48186) * 73;
+acc += Math.sin(48186) + Math.cos(48187) * 74;
+acc += Math.sin(48187) + Math.cos(48188) * 75;
+acc += Math.sin(48188) + Math.cos(48189) * 76;
+acc += Math.sin(48189) + Math.cos(48190) * 77;
+acc += Math.sin(48190) + Math.cos(48191) * 78;
+acc += Math.sin(48191) + Math.cos(48192) * 79;
+acc += Math.sin(48192) + Math.cos(48193) * 80;
+acc += Math.sin(48193) + Math.cos(48194) * 81;
+acc += Math.sin(48194) + Math.cos(48195) * 82;
+acc += Math.sin(48195) + Math.cos(48196) * 83;
+acc += Math.sin(48196) + Math.cos(48197) * 84;
+acc += Math.sin(48197) + Math.cos(48198) * 85;
+acc += Math.sin(48198) + Math.cos(48199) * 86;
+acc += Math.sin(48199) + Math.cos(48200) * 87;
+acc += Math.sin(48200) + Math.cos(48201) * 88;
+acc += Math.sin(48201) + Math.cos(48202) * 89;
+acc += Math.sin(48202) + Math.cos(48203) * 90;
+acc += Math.sin(48203) + Math.cos(48204) * 91;
+acc += Math.sin(48204) + Math.cos(48205) * 92;
+acc += Math.sin(48205) + Math.cos(48206) * 93;
+acc += Math.sin(48206) + Math.cos(48207) * 94;
+acc += Math.sin(48207) + Math.cos(48208) * 95;
+acc += Math.sin(48208) + Math.cos(48209) * 96;
+acc += Math.sin(48209) + Math.cos(48210) * 0;
+acc += Math.sin(48210) + Math.cos(48211) * 1;
+acc += Math.sin(48211) + Math.cos(48212) * 2;
+acc += Math.sin(48212) + Math.cos(48213) * 3;
+acc += Math.sin(48213) + Math.cos(48214) * 4;
+acc += Math.sin(48214) + Math.cos(48215) * 5;
+acc += Math.sin(48215) + Math.cos(48216) * 6;
+acc += Math.sin(48216) + Math.cos(48217) * 7;
+acc += Math.sin(48217) + Math.cos(48218) * 8;
+acc += Math.sin(48218) + Math.cos(48219) * 9;
+acc += Math.sin(48219) + Math.cos(48220) * 10;
+acc += Math.sin(48220) + Math.cos(48221) * 11;
+acc += Math.sin(48221) + Math.cos(48222) * 12;
+acc += Math.sin(48222) + Math.cos(48223) * 13;
+acc += Math.sin(48223) + Math.cos(48224) * 14;
+acc += Math.sin(48224) + Math.cos(48225) * 15;
+acc += Math.sin(48225) + Math.cos(48226) * 16;
+acc += Math.sin(48226) + Math.cos(48227) * 17;
+acc += Math.sin(48227) + Math.cos(48228) * 18;
+acc += Math.sin(48228) + Math.cos(48229) * 19;
+acc += Math.sin(48229) + Math.cos(48230) * 20;
+acc += Math.sin(48230) + Math.cos(48231) * 21;
+acc += Math.sin(48231) + Math.cos(48232) * 22;
+acc += Math.sin(48232) + Math.cos(48233) * 23;
+acc += Math.sin(48233) + Math.cos(48234) * 24;
+acc += Math.sin(48234) + Math.cos(48235) * 25;
+acc += Math.sin(48235) + Math.cos(48236) * 26;
+acc += Math.sin(48236) + Math.cos(48237) * 27;
+acc += Math.sin(48237) + Math.cos(48238) * 28;
+acc += Math.sin(48238) + Math.cos(48239) * 29;
+acc += Math.sin(48239) + Math.cos(48240) * 30;
+acc += Math.sin(48240) + Math.cos(48241) * 31;
+acc += Math.sin(48241) + Math.cos(48242) * 32;
+acc += Math.sin(48242) + Math.cos(48243) * 33;
+acc += Math.sin(48243) + Math.cos(48244) * 34;
+acc += Math.sin(48244) + Math.cos(48245) * 35;
+acc += Math.sin(48245) + Math.cos(48246) * 36;
+acc += Math.sin(48246) + Math.cos(48247) * 37;
+acc += Math.sin(48247) + Math.cos(48248) * 38;
+acc += Math.sin(48248) + Math.cos(48249) * 39;
+acc += Math.sin(48249) + Math.cos(48250) * 40;
+acc += Math.sin(48250) + Math.cos(48251) * 41;
+acc += Math.sin(48251) + Math.cos(48252) * 42;
+acc += Math.sin(48252) + Math.cos(48253) * 43;
+acc += Math.sin(48253) + Math.cos(48254) * 44;
+acc += Math.sin(48254) + Math.cos(48255) * 45;
+acc += Math.sin(48255) + Math.cos(48256) * 46;
+acc += Math.sin(48256) + Math.cos(48257) * 47;
+acc += Math.sin(48257) + Math.cos(48258) * 48;
+acc += Math.sin(48258) + Math.cos(48259) * 49;
+acc += Math.sin(48259) + Math.cos(48260) * 50;
+acc += Math.sin(48260) + Math.cos(48261) * 51;
+acc += Math.sin(48261) + Math.cos(48262) * 52;
+acc += Math.sin(48262) + Math.cos(48263) * 53;
+acc += Math.sin(48263) + Math.cos(48264) * 54;
+acc += Math.sin(48264) + Math.cos(48265) * 55;
+acc += Math.sin(48265) + Math.cos(48266) * 56;
+acc += Math.sin(48266) + Math.cos(48267) * 57;
+acc += Math.sin(48267) + Math.cos(48268) * 58;
+acc += Math.sin(48268) + Math.cos(48269) * 59;
+acc += Math.sin(48269) + Math.cos(48270) * 60;
+acc += Math.sin(48270) + Math.cos(48271) * 61;
+acc += Math.sin(48271) + Math.cos(48272) * 62;
+acc += Math.sin(48272) + Math.cos(48273) * 63;
+acc += Math.sin(48273) + Math.cos(48274) * 64;
+acc += Math.sin(48274) + Math.cos(48275) * 65;
+acc += Math.sin(48275) + Math.cos(48276) * 66;
+acc += Math.sin(48276) + Math.cos(48277) * 67;
+acc += Math.sin(48277) + Math.cos(48278) * 68;
+acc += Math.sin(48278) + Math.cos(48279) * 69;
+acc += Math.sin(48279) + Math.cos(48280) * 70;
+acc += Math.sin(48280) + Math.cos(48281) * 71;
+acc += Math.sin(48281) + Math.cos(48282) * 72;
+acc += Math.sin(48282) + Math.cos(48283) * 73;
+acc += Math.sin(48283) + Math.cos(48284) * 74;
+acc += Math.sin(48284) + Math.cos(48285) * 75;
+acc += Math.sin(48285) + Math.cos(48286) * 76;
+acc += Math.sin(48286) + Math.cos(48287) * 77;
+acc += Math.sin(48287) + Math.cos(48288) * 78;
+acc += Math.sin(48288) + Math.cos(48289) * 79;
+acc += Math.sin(48289) + Math.cos(48290) * 80;
+acc += Math.sin(48290) + Math.cos(48291) * 81;
+acc += Math.sin(48291) + Math.cos(48292) * 82;
+acc += Math.sin(48292) + Math.cos(48293) * 83;
+acc += Math.sin(48293) + Math.cos(48294) * 84;
+acc += Math.sin(48294) + Math.cos(48295) * 85;
+acc += Math.sin(48295) + Math.cos(48296) * 86;
+acc += Math.sin(48296) + Math.cos(48297) * 87;
+acc += Math.sin(48297) + Math.cos(48298) * 88;
+acc += Math.sin(48298) + Math.cos(48299) * 89;
+acc += Math.sin(48299) + Math.cos(48300) * 90;
+acc += Math.sin(48300) + Math.cos(48301) * 91;
+acc += Math.sin(48301) + Math.cos(48302) * 92;
+acc += Math.sin(48302) + Math.cos(48303) * 93;
+acc += Math.sin(48303) + Math.cos(48304) * 94;
+acc += Math.sin(48304) + Math.cos(48305) * 95;
+acc += Math.sin(48305) + Math.cos(48306) * 96;
+acc += Math.sin(48306) + Math.cos(48307) * 0;
+acc += Math.sin(48307) + Math.cos(48308) * 1;
+acc += Math.sin(48308) + Math.cos(48309) * 2;
+acc += Math.sin(48309) + Math.cos(48310) * 3;
+acc += Math.sin(48310) + Math.cos(48311) * 4;
+acc += Math.sin(48311) + Math.cos(48312) * 5;
+acc += Math.sin(48312) + Math.cos(48313) * 6;
+acc += Math.sin(48313) + Math.cos(48314) * 7;
+acc += Math.sin(48314) + Math.cos(48315) * 8;
+acc += Math.sin(48315) + Math.cos(48316) * 9;
+acc += Math.sin(48316) + Math.cos(48317) * 10;
+acc += Math.sin(48317) + Math.cos(48318) * 11;
+acc += Math.sin(48318) + Math.cos(48319) * 12;
+acc += Math.sin(48319) + Math.cos(48320) * 13;
+acc += Math.sin(48320) + Math.cos(48321) * 14;
+acc += Math.sin(48321) + Math.cos(48322) * 15;
+acc += Math.sin(48322) + Math.cos(48323) * 16;
+acc += Math.sin(48323) + Math.cos(48324) * 17;
+acc += Math.sin(48324) + Math.cos(48325) * 18;
+acc += Math.sin(48325) + Math.cos(48326) * 19;
+acc += Math.sin(48326) + Math.cos(48327) * 20;
+acc += Math.sin(48327) + Math.cos(48328) * 21;
+acc += Math.sin(48328) + Math.cos(48329) * 22;
+acc += Math.sin(48329) + Math.cos(48330) * 23;
+acc += Math.sin(48330) + Math.cos(48331) * 24;
+acc += Math.sin(48331) + Math.cos(48332) * 25;
+acc += Math.sin(48332) + Math.cos(48333) * 26;
+acc += Math.sin(48333) + Math.cos(48334) * 27;
+acc += Math.sin(48334) + Math.cos(48335) * 28;
+acc += Math.sin(48335) + Math.cos(48336) * 29;
+acc += Math.sin(48336) + Math.cos(48337) * 30;
+acc += Math.sin(48337) + Math.cos(48338) * 31;
+acc += Math.sin(48338) + Math.cos(48339) * 32;
+acc += Math.sin(48339) + Math.cos(48340) * 33;
+acc += Math.sin(48340) + Math.cos(48341) * 34;
+acc += Math.sin(48341) + Math.cos(48342) * 35;
+acc += Math.sin(48342) + Math.cos(48343) * 36;
+acc += Math.sin(48343) + Math.cos(48344) * 37;
+acc += Math.sin(48344) + Math.cos(48345) * 38;
+acc += Math.sin(48345) + Math.cos(48346) * 39;
+acc += Math.sin(48346) + Math.cos(48347) * 40;
+acc += Math.sin(48347) + Math.cos(48348) * 41;
+acc += Math.sin(48348) + Math.cos(48349) * 42;
+acc += Math.sin(48349) + Math.cos(48350) * 43;
+acc += Math.sin(48350) + Math.cos(48351) * 44;
+acc += Math.sin(48351) + Math.cos(48352) * 45;
+acc += Math.sin(48352) + Math.cos(48353) * 46;
+acc += Math.sin(48353) + Math.cos(48354) * 47;
+acc += Math.sin(48354) + Math.cos(48355) * 48;
+acc += Math.sin(48355) + Math.cos(48356) * 49;
+acc += Math.sin(48356) + Math.cos(48357) * 50;
+acc += Math.sin(48357) + Math.cos(48358) * 51;
+acc += Math.sin(48358) + Math.cos(48359) * 52;
+acc += Math.sin(48359) + Math.cos(48360) * 53;
+acc += Math.sin(48360) + Math.cos(48361) * 54;
+acc += Math.sin(48361) + Math.cos(48362) * 55;
+acc += Math.sin(48362) + Math.cos(48363) * 56;
+acc += Math.sin(48363) + Math.cos(48364) * 57;
+acc += Math.sin(48364) + Math.cos(48365) * 58;
+acc += Math.sin(48365) + Math.cos(48366) * 59;
+acc += Math.sin(48366) + Math.cos(48367) * 60;
+acc += Math.sin(48367) + Math.cos(48368) * 61;
+acc += Math.sin(48368) + Math.cos(48369) * 62;
+acc += Math.sin(48369) + Math.cos(48370) * 63;
+acc += Math.sin(48370) + Math.cos(48371) * 64;
+acc += Math.sin(48371) + Math.cos(48372) * 65;
+acc += Math.sin(48372) + Math.cos(48373) * 66;
+acc += Math.sin(48373) + Math.cos(48374) * 67;
+acc += Math.sin(48374) + Math.cos(48375) * 68;
+acc += Math.sin(48375) + Math.cos(48376) * 69;
+acc += Math.sin(48376) + Math.cos(48377) * 70;
+acc += Math.sin(48377) + Math.cos(48378) * 71;
+acc += Math.sin(48378) + Math.cos(48379) * 72;
+acc += Math.sin(48379) + Math.cos(48380) * 73;
+acc += Math.sin(48380) + Math.cos(48381) * 74;
+acc += Math.sin(48381) + Math.cos(48382) * 75;
+acc += Math.sin(48382) + Math.cos(48383) * 76;
+acc += Math.sin(48383) + Math.cos(48384) * 77;
+acc += Math.sin(48384) + Math.cos(48385) * 78;
+acc += Math.sin(48385) + Math.cos(48386) * 79;
+acc += Math.sin(48386) + Math.cos(48387) * 80;
+acc += Math.sin(48387) + Math.cos(48388) * 81;
+acc += Math.sin(48388) + Math.cos(48389) * 82;
+acc += Math.sin(48389) + Math.cos(48390) * 83;
+acc += Math.sin(48390) + Math.cos(48391) * 84;
+acc += Math.sin(48391) + Math.cos(48392) * 85;
+acc += Math.sin(48392) + Math.cos(48393) * 86;
+acc += Math.sin(48393) + Math.cos(48394) * 87;
+acc += Math.sin(48394) + Math.cos(48395) * 88;
+acc += Math.sin(48395) + Math.cos(48396) * 89;
+acc += Math.sin(48396) + Math.cos(48397) * 90;
+acc += Math.sin(48397) + Math.cos(48398) * 91;
+acc += Math.sin(48398) + Math.cos(48399) * 92;
+acc += Math.sin(48399) + Math.cos(48400) * 93;
+acc += Math.sin(48400) + Math.cos(48401) * 94;
+acc += Math.sin(48401) + Math.cos(48402) * 95;
+acc += Math.sin(48402) + Math.cos(48403) * 96;
+acc += Math.sin(48403) + Math.cos(48404) * 0;
+acc += Math.sin(48404) + Math.cos(48405) * 1;
+acc += Math.sin(48405) + Math.cos(48406) * 2;
+acc += Math.sin(48406) + Math.cos(48407) * 3;
+acc += Math.sin(48407) + Math.cos(48408) * 4;
+acc += Math.sin(48408) + Math.cos(48409) * 5;
+acc += Math.sin(48409) + Math.cos(48410) * 6;
+acc += Math.sin(48410) + Math.cos(48411) * 7;
+acc += Math.sin(48411) + Math.cos(48412) * 8;
+acc += Math.sin(48412) + Math.cos(48413) * 9;
+acc += Math.sin(48413) + Math.cos(48414) * 10;
+acc += Math.sin(48414) + Math.cos(48415) * 11;
+acc += Math.sin(48415) + Math.cos(48416) * 12;
+acc += Math.sin(48416) + Math.cos(48417) * 13;
+acc += Math.sin(48417) + Math.cos(48418) * 14;
+acc += Math.sin(48418) + Math.cos(48419) * 15;
+acc += Math.sin(48419) + Math.cos(48420) * 16;
+acc += Math.sin(48420) + Math.cos(48421) * 17;
+acc += Math.sin(48421) + Math.cos(48422) * 18;
+acc += Math.sin(48422) + Math.cos(48423) * 19;
+acc += Math.sin(48423) + Math.cos(48424) * 20;
+acc += Math.sin(48424) + Math.cos(48425) * 21;
+acc += Math.sin(48425) + Math.cos(48426) * 22;
+acc += Math.sin(48426) + Math.cos(48427) * 23;
+acc += Math.sin(48427) + Math.cos(48428) * 24;
+acc += Math.sin(48428) + Math.cos(48429) * 25;
+acc += Math.sin(48429) + Math.cos(48430) * 26;
+acc += Math.sin(48430) + Math.cos(48431) * 27;
+acc += Math.sin(48431) + Math.cos(48432) * 28;
+acc += Math.sin(48432) + Math.cos(48433) * 29;
+acc += Math.sin(48433) + Math.cos(48434) * 30;
+acc += Math.sin(48434) + Math.cos(48435) * 31;
+acc += Math.sin(48435) + Math.cos(48436) * 32;
+acc += Math.sin(48436) + Math.cos(48437) * 33;
+acc += Math.sin(48437) + Math.cos(48438) * 34;
+acc += Math.sin(48438) + Math.cos(48439) * 35;
+acc += Math.sin(48439) + Math.cos(48440) * 36;
+acc += Math.sin(48440) + Math.cos(48441) * 37;
+acc += Math.sin(48441) + Math.cos(48442) * 38;
+acc += Math.sin(48442) + Math.cos(48443) * 39;
+acc += Math.sin(48443) + Math.cos(48444) * 40;
+acc += Math.sin(48444) + Math.cos(48445) * 41;
+acc += Math.sin(48445) + Math.cos(48446) * 42;
+acc += Math.sin(48446) + Math.cos(48447) * 43;
+acc += Math.sin(48447) + Math.cos(48448) * 44;
+acc += Math.sin(48448) + Math.cos(48449) * 45;
+acc += Math.sin(48449) + Math.cos(48450) * 46;
+acc += Math.sin(48450) + Math.cos(48451) * 47;
+acc += Math.sin(48451) + Math.cos(48452) * 48;
+acc += Math.sin(48452) + Math.cos(48453) * 49;
+acc += Math.sin(48453) + Math.cos(48454) * 50;
+acc += Math.sin(48454) + Math.cos(48455) * 51;
+acc += Math.sin(48455) + Math.cos(48456) * 52;
+acc += Math.sin(48456) + Math.cos(48457) * 53;
+acc += Math.sin(48457) + Math.cos(48458) * 54;
+acc += Math.sin(48458) + Math.cos(48459) * 55;
+acc += Math.sin(48459) + Math.cos(48460) * 56;
+acc += Math.sin(48460) + Math.cos(48461) * 57;
+acc += Math.sin(48461) + Math.cos(48462) * 58;
+acc += Math.sin(48462) + Math.cos(48463) * 59;
+acc += Math.sin(48463) + Math.cos(48464) * 60;
+acc += Math.sin(48464) + Math.cos(48465) * 61;
+acc += Math.sin(48465) + Math.cos(48466) * 62;
+acc += Math.sin(48466) + Math.cos(48467) * 63;
+acc += Math.sin(48467) + Math.cos(48468) * 64;
+acc += Math.sin(48468) + Math.cos(48469) * 65;
+acc += Math.sin(48469) + Math.cos(48470) * 66;
+acc += Math.sin(48470) + Math.cos(48471) * 67;
+acc += Math.sin(48471) + Math.cos(48472) * 68;
+acc += Math.sin(48472) + Math.cos(48473) * 69;
+acc += Math.sin(48473) + Math.cos(48474) * 70;
+acc += Math.sin(48474) + Math.cos(48475) * 71;
+acc += Math.sin(48475) + Math.cos(48476) * 72;
+acc += Math.sin(48476) + Math.cos(48477) * 73;
+acc += Math.sin(48477) + Math.cos(48478) * 74;
+acc += Math.sin(48478) + Math.cos(48479) * 75;
+acc += Math.sin(48479) + Math.cos(48480) * 76;
+acc += Math.sin(48480) + Math.cos(48481) * 77;
+acc += Math.sin(48481) + Math.cos(48482) * 78;
+acc += Math.sin(48482) + Math.cos(48483) * 79;
+acc += Math.sin(48483) + Math.cos(48484) * 80;
+acc += Math.sin(48484) + Math.cos(48485) * 81;
+acc += Math.sin(48485) + Math.cos(48486) * 82;
+acc += Math.sin(48486) + Math.cos(48487) * 83;
+acc += Math.sin(48487) + Math.cos(48488) * 84;
+acc += Math.sin(48488) + Math.cos(48489) * 85;
+acc += Math.sin(48489) + Math.cos(48490) * 86;
+acc += Math.sin(48490) + Math.cos(48491) * 87;
+acc += Math.sin(48491) + Math.cos(48492) * 88;
+acc += Math.sin(48492) + Math.cos(48493) * 89;
+acc += Math.sin(48493) + Math.cos(48494) * 90;
+acc += Math.sin(48494) + Math.cos(48495) * 91;
+acc += Math.sin(48495) + Math.cos(48496) * 92;
+acc += Math.sin(48496) + Math.cos(48497) * 93;
+acc += Math.sin(48497) + Math.cos(48498) * 94;
+acc += Math.sin(48498) + Math.cos(48499) * 95;
+acc += Math.sin(48499) + Math.cos(48500) * 96;
+acc += Math.sin(48500) + Math.cos(48501) * 0;
+acc += Math.sin(48501) + Math.cos(48502) * 1;
+acc += Math.sin(48502) + Math.cos(48503) * 2;
+acc += Math.sin(48503) + Math.cos(48504) * 3;
+acc += Math.sin(48504) + Math.cos(48505) * 4;
+acc += Math.sin(48505) + Math.cos(48506) * 5;
+acc += Math.sin(48506) + Math.cos(48507) * 6;
+acc += Math.sin(48507) + Math.cos(48508) * 7;
+acc += Math.sin(48508) + Math.cos(48509) * 8;
+acc += Math.sin(48509) + Math.cos(48510) * 9;
+acc += Math.sin(48510) + Math.cos(48511) * 10;
+acc += Math.sin(48511) + Math.cos(48512) * 11;
+acc += Math.sin(48512) + Math.cos(48513) * 12;
+acc += Math.sin(48513) + Math.cos(48514) * 13;
+acc += Math.sin(48514) + Math.cos(48515) * 14;
+acc += Math.sin(48515) + Math.cos(48516) * 15;
+acc += Math.sin(48516) + Math.cos(48517) * 16;
+acc += Math.sin(48517) + Math.cos(48518) * 17;
+acc += Math.sin(48518) + Math.cos(48519) * 18;
+acc += Math.sin(48519) + Math.cos(48520) * 19;
+acc += Math.sin(48520) + Math.cos(48521) * 20;
+acc += Math.sin(48521) + Math.cos(48522) * 21;
+acc += Math.sin(48522) + Math.cos(48523) * 22;
+acc += Math.sin(48523) + Math.cos(48524) * 23;
+acc += Math.sin(48524) + Math.cos(48525) * 24;
+acc += Math.sin(48525) + Math.cos(48526) * 25;
+acc += Math.sin(48526) + Math.cos(48527) * 26;
+acc += Math.sin(48527) + Math.cos(48528) * 27;
+acc += Math.sin(48528) + Math.cos(48529) * 28;
+acc += Math.sin(48529) + Math.cos(48530) * 29;
+acc += Math.sin(48530) + Math.cos(48531) * 30;
+acc += Math.sin(48531) + Math.cos(48532) * 31;
+acc += Math.sin(48532) + Math.cos(48533) * 32;
+acc += Math.sin(48533) + Math.cos(48534) * 33;
+acc += Math.sin(48534) + Math.cos(48535) * 34;
+acc += Math.sin(48535) + Math.cos(48536) * 35;
+acc += Math.sin(48536) + Math.cos(48537) * 36;
+acc += Math.sin(48537) + Math.cos(48538) * 37;
+acc += Math.sin(48538) + Math.cos(48539) * 38;
+acc += Math.sin(48539) + Math.cos(48540) * 39;
+acc += Math.sin(48540) + Math.cos(48541) * 40;
+acc += Math.sin(48541) + Math.cos(48542) * 41;
+acc += Math.sin(48542) + Math.cos(48543) * 42;
+acc += Math.sin(48543) + Math.cos(48544) * 43;
+acc += Math.sin(48544) + Math.cos(48545) * 44;
+acc += Math.sin(48545) + Math.cos(48546) * 45;
+acc += Math.sin(48546) + Math.cos(48547) * 46;
+acc += Math.sin(48547) + Math.cos(48548) * 47;
+acc += Math.sin(48548) + Math.cos(48549) * 48;
+acc += Math.sin(48549) + Math.cos(48550) * 49;
+acc += Math.sin(48550) + Math.cos(48551) * 50;
+acc += Math.sin(48551) + Math.cos(48552) * 51;
+acc += Math.sin(48552) + Math.cos(48553) * 52;
+acc += Math.sin(48553) + Math.cos(48554) * 53;
+acc += Math.sin(48554) + Math.cos(48555) * 54;
+acc += Math.sin(48555) + Math.cos(48556) * 55;
+acc += Math.sin(48556) + Math.cos(48557) * 56;
+acc += Math.sin(48557) + Math.cos(48558) * 57;
+acc += Math.sin(48558) + Math.cos(48559) * 58;
+acc += Math.sin(48559) + Math.cos(48560) * 59;
+acc += Math.sin(48560) + Math.cos(48561) * 60;
+acc += Math.sin(48561) + Math.cos(48562) * 61;
+acc += Math.sin(48562) + Math.cos(48563) * 62;
+acc += Math.sin(48563) + Math.cos(48564) * 63;
+acc += Math.sin(48564) + Math.cos(48565) * 64;
+acc += Math.sin(48565) + Math.cos(48566) * 65;
+acc += Math.sin(48566) + Math.cos(48567) * 66;
+acc += Math.sin(48567) + Math.cos(48568) * 67;
+acc += Math.sin(48568) + Math.cos(48569) * 68;
+acc += Math.sin(48569) + Math.cos(48570) * 69;
+acc += Math.sin(48570) + Math.cos(48571) * 70;
+acc += Math.sin(48571) + Math.cos(48572) * 71;
+acc += Math.sin(48572) + Math.cos(48573) * 72;
+acc += Math.sin(48573) + Math.cos(48574) * 73;
+acc += Math.sin(48574) + Math.cos(48575) * 74;
+acc += Math.sin(48575) + Math.cos(48576) * 75;
+acc += Math.sin(48576) + Math.cos(48577) * 76;
+acc += Math.sin(48577) + Math.cos(48578) * 77;
+acc += Math.sin(48578) + Math.cos(48579) * 78;
+acc += Math.sin(48579) + Math.cos(48580) * 79;
+acc += Math.sin(48580) + Math.cos(48581) * 80;
+acc += Math.sin(48581) + Math.cos(48582) * 81;
+acc += Math.sin(48582) + Math.cos(48583) * 82;
+acc += Math.sin(48583) + Math.cos(48584) * 83;
+acc += Math.sin(48584) + Math.cos(48585) * 84;
+acc += Math.sin(48585) + Math.cos(48586) * 85;
+acc += Math.sin(48586) + Math.cos(48587) * 86;
+acc += Math.sin(48587) + Math.cos(48588) * 87;
+acc += Math.sin(48588) + Math.cos(48589) * 88;
+acc += Math.sin(48589) + Math.cos(48590) * 89;
+acc += Math.sin(48590) + Math.cos(48591) * 90;
+acc += Math.sin(48591) + Math.cos(48592) * 91;
+acc += Math.sin(48592) + Math.cos(48593) * 92;
+acc += Math.sin(48593) + Math.cos(48594) * 93;
+acc += Math.sin(48594) + Math.cos(48595) * 94;
+acc += Math.sin(48595) + Math.cos(48596) * 95;
+acc += Math.sin(48596) + Math.cos(48597) * 96;
+acc += Math.sin(48597) + Math.cos(48598) * 0;
+acc += Math.sin(48598) + Math.cos(48599) * 1;
+acc += Math.sin(48599) + Math.cos(48600) * 2;
+acc += Math.sin(48600) + Math.cos(48601) * 3;
+acc += Math.sin(48601) + Math.cos(48602) * 4;
+acc += Math.sin(48602) + Math.cos(48603) * 5;
+acc += Math.sin(48603) + Math.cos(48604) * 6;
+acc += Math.sin(48604) + Math.cos(48605) * 7;
+acc += Math.sin(48605) + Math.cos(48606) * 8;
+acc += Math.sin(48606) + Math.cos(48607) * 9;
+acc += Math.sin(48607) + Math.cos(48608) * 10;
+acc += Math.sin(48608) + Math.cos(48609) * 11;
+acc += Math.sin(48609) + Math.cos(48610) * 12;
+acc += Math.sin(48610) + Math.cos(48611) * 13;
+acc += Math.sin(48611) + Math.cos(48612) * 14;
+acc += Math.sin(48612) + Math.cos(48613) * 15;
+acc += Math.sin(48613) + Math.cos(48614) * 16;
+acc += Math.sin(48614) + Math.cos(48615) * 17;
+acc += Math.sin(48615) + Math.cos(48616) * 18;
+acc += Math.sin(48616) + Math.cos(48617) * 19;
+acc += Math.sin(48617) + Math.cos(48618) * 20;
+acc += Math.sin(48618) + Math.cos(48619) * 21;
+acc += Math.sin(48619) + Math.cos(48620) * 22;
+acc += Math.sin(48620) + Math.cos(48621) * 23;
+acc += Math.sin(48621) + Math.cos(48622) * 24;
+acc += Math.sin(48622) + Math.cos(48623) * 25;
+acc += Math.sin(48623) + Math.cos(48624) * 26;
+acc += Math.sin(48624) + Math.cos(48625) * 27;
+acc += Math.sin(48625) + Math.cos(48626) * 28;
+acc += Math.sin(48626) + Math.cos(48627) * 29;
+acc += Math.sin(48627) + Math.cos(48628) * 30;
+acc += Math.sin(48628) + Math.cos(48629) * 31;
+acc += Math.sin(48629) + Math.cos(48630) * 32;
+acc += Math.sin(48630) + Math.cos(48631) * 33;
+acc += Math.sin(48631) + Math.cos(48632) * 34;
+acc += Math.sin(48632) + Math.cos(48633) * 35;
+acc += Math.sin(48633) + Math.cos(48634) * 36;
+acc += Math.sin(48634) + Math.cos(48635) * 37;
+acc += Math.sin(48635) + Math.cos(48636) * 38;
+acc += Math.sin(48636) + Math.cos(48637) * 39;
+acc += Math.sin(48637) + Math.cos(48638) * 40;
+acc += Math.sin(48638) + Math.cos(48639) * 41;
+acc += Math.sin(48639) + Math.cos(48640) * 42;
+acc += Math.sin(48640) + Math.cos(48641) * 43;
+acc += Math.sin(48641) + Math.cos(48642) * 44;
+acc += Math.sin(48642) + Math.cos(48643) * 45;
+acc += Math.sin(48643) + Math.cos(48644) * 46;
+acc += Math.sin(48644) + Math.cos(48645) * 47;
+acc += Math.sin(48645) + Math.cos(48646) * 48;
+acc += Math.sin(48646) + Math.cos(48647) * 49;
+acc += Math.sin(48647) + Math.cos(48648) * 50;
+acc += Math.sin(48648) + Math.cos(48649) * 51;
+acc += Math.sin(48649) + Math.cos(48650) * 52;
+acc += Math.sin(48650) + Math.cos(48651) * 53;
+acc += Math.sin(48651) + Math.cos(48652) * 54;
+acc += Math.sin(48652) + Math.cos(48653) * 55;
+acc += Math.sin(48653) + Math.cos(48654) * 56;
+acc += Math.sin(48654) + Math.cos(48655) * 57;
+acc += Math.sin(48655) + Math.cos(48656) * 58;
+acc += Math.sin(48656) + Math.cos(48657) * 59;
+acc += Math.sin(48657) + Math.cos(48658) * 60;
+acc += Math.sin(48658) + Math.cos(48659) * 61;
+acc += Math.sin(48659) + Math.cos(48660) * 62;
+acc += Math.sin(48660) + Math.cos(48661) * 63;
+acc += Math.sin(48661) + Math.cos(48662) * 64;
+acc += Math.sin(48662) + Math.cos(48663) * 65;
+acc += Math.sin(48663) + Math.cos(48664) * 66;
+acc += Math.sin(48664) + Math.cos(48665) * 67;
+acc += Math.sin(48665) + Math.cos(48666) * 68;
+acc += Math.sin(48666) + Math.cos(48667) * 69;
+acc += Math.sin(48667) + Math.cos(48668) * 70;
+acc += Math.sin(48668) + Math.cos(48669) * 71;
+acc += Math.sin(48669) + Math.cos(48670) * 72;
+acc += Math.sin(48670) + Math.cos(48671) * 73;
+acc += Math.sin(48671) + Math.cos(48672) * 74;
+acc += Math.sin(48672) + Math.cos(48673) * 75;
+acc += Math.sin(48673) + Math.cos(48674) * 76;
+acc += Math.sin(48674) + Math.cos(48675) * 77;
+acc += Math.sin(48675) + Math.cos(48676) * 78;
+acc += Math.sin(48676) + Math.cos(48677) * 79;
+acc += Math.sin(48677) + Math.cos(48678) * 80;
+acc += Math.sin(48678) + Math.cos(48679) * 81;
+acc += Math.sin(48679) + Math.cos(48680) * 82;
+acc += Math.sin(48680) + Math.cos(48681) * 83;
+acc += Math.sin(48681) + Math.cos(48682) * 84;
+acc += Math.sin(48682) + Math.cos(48683) * 85;
+acc += Math.sin(48683) + Math.cos(48684) * 86;
+acc += Math.sin(48684) + Math.cos(48685) * 87;
+acc += Math.sin(48685) + Math.cos(48686) * 88;
+acc += Math.sin(48686) + Math.cos(48687) * 89;
+acc += Math.sin(48687) + Math.cos(48688) * 90;
+acc += Math.sin(48688) + Math.cos(48689) * 91;
+acc += Math.sin(48689) + Math.cos(48690) * 92;
+acc += Math.sin(48690) + Math.cos(48691) * 93;
+acc += Math.sin(48691) + Math.cos(48692) * 94;
+acc += Math.sin(48692) + Math.cos(48693) * 95;
+acc += Math.sin(48693) + Math.cos(48694) * 96;
+acc += Math.sin(48694) + Math.cos(48695) * 0;
+acc += Math.sin(48695) + Math.cos(48696) * 1;
+acc += Math.sin(48696) + Math.cos(48697) * 2;
+acc += Math.sin(48697) + Math.cos(48698) * 3;
+acc += Math.sin(48698) + Math.cos(48699) * 4;
+acc += Math.sin(48699) + Math.cos(48700) * 5;
+acc += Math.sin(48700) + Math.cos(48701) * 6;
+acc += Math.sin(48701) + Math.cos(48702) * 7;
+acc += Math.sin(48702) + Math.cos(48703) * 8;
+acc += Math.sin(48703) + Math.cos(48704) * 9;
+acc += Math.sin(48704) + Math.cos(48705) * 10;
+acc += Math.sin(48705) + Math.cos(48706) * 11;
+acc += Math.sin(48706) + Math.cos(48707) * 12;
+acc += Math.sin(48707) + Math.cos(48708) * 13;
+acc += Math.sin(48708) + Math.cos(48709) * 14;
+acc += Math.sin(48709) + Math.cos(48710) * 15;
+acc += Math.sin(48710) + Math.cos(48711) * 16;
+acc += Math.sin(48711) + Math.cos(48712) * 17;
+acc += Math.sin(48712) + Math.cos(48713) * 18;
+acc += Math.sin(48713) + Math.cos(48714) * 19;
+acc += Math.sin(48714) + Math.cos(48715) * 20;
+acc += Math.sin(48715) + Math.cos(48716) * 21;
+acc += Math.sin(48716) + Math.cos(48717) * 22;
+acc += Math.sin(48717) + Math.cos(48718) * 23;
+acc += Math.sin(48718) + Math.cos(48719) * 24;
+acc += Math.sin(48719) + Math.cos(48720) * 25;
+acc += Math.sin(48720) + Math.cos(48721) * 26;
+acc += Math.sin(48721) + Math.cos(48722) * 27;
+acc += Math.sin(48722) + Math.cos(48723) * 28;
+acc += Math.sin(48723) + Math.cos(48724) * 29;
+acc += Math.sin(48724) + Math.cos(48725) * 30;
+acc += Math.sin(48725) + Math.cos(48726) * 31;
+acc += Math.sin(48726) + Math.cos(48727) * 32;
+acc += Math.sin(48727) + Math.cos(48728) * 33;
+acc += Math.sin(48728) + Math.cos(48729) * 34;
+acc += Math.sin(48729) + Math.cos(48730) * 35;
+acc += Math.sin(48730) + Math.cos(48731) * 36;
+acc += Math.sin(48731) + Math.cos(48732) * 37;
+acc += Math.sin(48732) + Math.cos(48733) * 38;
+acc += Math.sin(48733) + Math.cos(48734) * 39;
+acc += Math.sin(48734) + Math.cos(48735) * 40;
+acc += Math.sin(48735) + Math.cos(48736) * 41;
+acc += Math.sin(48736) + Math.cos(48737) * 42;
+acc += Math.sin(48737) + Math.cos(48738) * 43;
+acc += Math.sin(48738) + Math.cos(48739) * 44;
+acc += Math.sin(48739) + Math.cos(48740) * 45;
+acc += Math.sin(48740) + Math.cos(48741) * 46;
+acc += Math.sin(48741) + Math.cos(48742) * 47;
+acc += Math.sin(48742) + Math.cos(48743) * 48;
+acc += Math.sin(48743) + Math.cos(48744) * 49;
+acc += Math.sin(48744) + Math.cos(48745) * 50;
+acc += Math.sin(48745) + Math.cos(48746) * 51;
+acc += Math.sin(48746) + Math.cos(48747) * 52;
+acc += Math.sin(48747) + Math.cos(48748) * 53;
+acc += Math.sin(48748) + Math.cos(48749) * 54;
+acc += Math.sin(48749) + Math.cos(48750) * 55;
+acc += Math.sin(48750) + Math.cos(48751) * 56;
+acc += Math.sin(48751) + Math.cos(48752) * 57;
+acc += Math.sin(48752) + Math.cos(48753) * 58;
+acc += Math.sin(48753) + Math.cos(48754) * 59;
+acc += Math.sin(48754) + Math.cos(48755) * 60;
+acc += Math.sin(48755) + Math.cos(48756) * 61;
+acc += Math.sin(48756) + Math.cos(48757) * 62;
+acc += Math.sin(48757) + Math.cos(48758) * 63;
+acc += Math.sin(48758) + Math.cos(48759) * 64;
+acc += Math.sin(48759) + Math.cos(48760) * 65;
+acc += Math.sin(48760) + Math.cos(48761) * 66;
+acc += Math.sin(48761) + Math.cos(48762) * 67;
+acc += Math.sin(48762) + Math.cos(48763) * 68;
+acc += Math.sin(48763) + Math.cos(48764) * 69;
+acc += Math.sin(48764) + Math.cos(48765) * 70;
+acc += Math.sin(48765) + Math.cos(48766) * 71;
+acc += Math.sin(48766) + Math.cos(48767) * 72;
+acc += Math.sin(48767) + Math.cos(48768) * 73;
+acc += Math.sin(48768) + Math.cos(48769) * 74;
+acc += Math.sin(48769) + Math.cos(48770) * 75;
+acc += Math.sin(48770) + Math.cos(48771) * 76;
+acc += Math.sin(48771) + Math.cos(48772) * 77;
+acc += Math.sin(48772) + Math.cos(48773) * 78;
+acc += Math.sin(48773) + Math.cos(48774) * 79;
+acc += Math.sin(48774) + Math.cos(48775) * 80;
+acc += Math.sin(48775) + Math.cos(48776) * 81;
+acc += Math.sin(48776) + Math.cos(48777) * 82;
+acc += Math.sin(48777) + Math.cos(48778) * 83;
+acc += Math.sin(48778) + Math.cos(48779) * 84;
+acc += Math.sin(48779) + Math.cos(48780) * 85;
+acc += Math.sin(48780) + Math.cos(48781) * 86;
+acc += Math.sin(48781) + Math.cos(48782) * 87;
+acc += Math.sin(48782) + Math.cos(48783) * 88;
+acc += Math.sin(48783) + Math.cos(48784) * 89;
+acc += Math.sin(48784) + Math.cos(48785) * 90;
+acc += Math.sin(48785) + Math.cos(48786) * 91;
+acc += Math.sin(48786) + Math.cos(48787) * 92;
+acc += Math.sin(48787) + Math.cos(48788) * 93;
+acc += Math.sin(48788) + Math.cos(48789) * 94;
+acc += Math.sin(48789) + Math.cos(48790) * 95;
+acc += Math.sin(48790) + Math.cos(48791) * 96;
+acc += Math.sin(48791) + Math.cos(48792) * 0;
+acc += Math.sin(48792) + Math.cos(48793) * 1;
+acc += Math.sin(48793) + Math.cos(48794) * 2;
+acc += Math.sin(48794) + Math.cos(48795) * 3;
+acc += Math.sin(48795) + Math.cos(48796) * 4;
+acc += Math.sin(48796) + Math.cos(48797) * 5;
+acc += Math.sin(48797) + Math.cos(48798) * 6;
+acc += Math.sin(48798) + Math.cos(48799) * 7;
+acc += Math.sin(48799) + Math.cos(48800) * 8;
+acc += Math.sin(48800) + Math.cos(48801) * 9;
+acc += Math.sin(48801) + Math.cos(48802) * 10;
+acc += Math.sin(48802) + Math.cos(48803) * 11;
+acc += Math.sin(48803) + Math.cos(48804) * 12;
+acc += Math.sin(48804) + Math.cos(48805) * 13;
+acc += Math.sin(48805) + Math.cos(48806) * 14;
+acc += Math.sin(48806) + Math.cos(48807) * 15;
+acc += Math.sin(48807) + Math.cos(48808) * 16;
+acc += Math.sin(48808) + Math.cos(48809) * 17;
+acc += Math.sin(48809) + Math.cos(48810) * 18;
+acc += Math.sin(48810) + Math.cos(48811) * 19;
+acc += Math.sin(48811) + Math.cos(48812) * 20;
+acc += Math.sin(48812) + Math.cos(48813) * 21;
+acc += Math.sin(48813) + Math.cos(48814) * 22;
+acc += Math.sin(48814) + Math.cos(48815) * 23;
+acc += Math.sin(48815) + Math.cos(48816) * 24;
+acc += Math.sin(48816) + Math.cos(48817) * 25;
+acc += Math.sin(48817) + Math.cos(48818) * 26;
+acc += Math.sin(48818) + Math.cos(48819) * 27;
+acc += Math.sin(48819) + Math.cos(48820) * 28;
+acc += Math.sin(48820) + Math.cos(48821) * 29;
+acc += Math.sin(48821) + Math.cos(48822) * 30;
+acc += Math.sin(48822) + Math.cos(48823) * 31;
+acc += Math.sin(48823) + Math.cos(48824) * 32;
+acc += Math.sin(48824) + Math.cos(48825) * 33;
+acc += Math.sin(48825) + Math.cos(48826) * 34;
+acc += Math.sin(48826) + Math.cos(48827) * 35;
+acc += Math.sin(48827) + Math.cos(48828) * 36;
+acc += Math.sin(48828) + Math.cos(48829) * 37;
+acc += Math.sin(48829) + Math.cos(48830) * 38;
+acc += Math.sin(48830) + Math.cos(48831) * 39;
+acc += Math.sin(48831) + Math.cos(48832) * 40;
+acc += Math.sin(48832) + Math.cos(48833) * 41;
+acc += Math.sin(48833) + Math.cos(48834) * 42;
+acc += Math.sin(48834) + Math.cos(48835) * 43;
+acc += Math.sin(48835) + Math.cos(48836) * 44;
+acc += Math.sin(48836) + Math.cos(48837) * 45;
+acc += Math.sin(48837) + Math.cos(48838) * 46;
+acc += Math.sin(48838) + Math.cos(48839) * 47;
+acc += Math.sin(48839) + Math.cos(48840) * 48;
+acc += Math.sin(48840) + Math.cos(48841) * 49;
+acc += Math.sin(48841) + Math.cos(48842) * 50;
+acc += Math.sin(48842) + Math.cos(48843) * 51;
+acc += Math.sin(48843) + Math.cos(48844) * 52;
+acc += Math.sin(48844) + Math.cos(48845) * 53;
+acc += Math.sin(48845) + Math.cos(48846) * 54;
+acc += Math.sin(48846) + Math.cos(48847) * 55;
+acc += Math.sin(48847) + Math.cos(48848) * 56;
+acc += Math.sin(48848) + Math.cos(48849) * 57;
+acc += Math.sin(48849) + Math.cos(48850) * 58;
+acc += Math.sin(48850) + Math.cos(48851) * 59;
+acc += Math.sin(48851) + Math.cos(48852) * 60;
+acc += Math.sin(48852) + Math.cos(48853) * 61;
+acc += Math.sin(48853) + Math.cos(48854) * 62;
+acc += Math.sin(48854) + Math.cos(48855) * 63;
+acc += Math.sin(48855) + Math.cos(48856) * 64;
+acc += Math.sin(48856) + Math.cos(48857) * 65;
+acc += Math.sin(48857) + Math.cos(48858) * 66;
+acc += Math.sin(48858) + Math.cos(48859) * 67;
+acc += Math.sin(48859) + Math.cos(48860) * 68;
+acc += Math.sin(48860) + Math.cos(48861) * 69;
+acc += Math.sin(48861) + Math.cos(48862) * 70;
+acc += Math.sin(48862) + Math.cos(48863) * 71;
+acc += Math.sin(48863) + Math.cos(48864) * 72;
+acc += Math.sin(48864) + Math.cos(48865) * 73;
+acc += Math.sin(48865) + Math.cos(48866) * 74;
+acc += Math.sin(48866) + Math.cos(48867) * 75;
+acc += Math.sin(48867) + Math.cos(48868) * 76;
+acc += Math.sin(48868) + Math.cos(48869) * 77;
+acc += Math.sin(48869) + Math.cos(48870) * 78;
+acc += Math.sin(48870) + Math.cos(48871) * 79;
+acc += Math.sin(48871) + Math.cos(48872) * 80;
+acc += Math.sin(48872) + Math.cos(48873) * 81;
+acc += Math.sin(48873) + Math.cos(48874) * 82;
+acc += Math.sin(48874) + Math.cos(48875) * 83;
+acc += Math.sin(48875) + Math.cos(48876) * 84;
+acc += Math.sin(48876) + Math.cos(48877) * 85;
+acc += Math.sin(48877) + Math.cos(48878) * 86;
+acc += Math.sin(48878) + Math.cos(48879) * 87;
+acc += Math.sin(48879) + Math.cos(48880) * 88;
+acc += Math.sin(48880) + Math.cos(48881) * 89;
+acc += Math.sin(48881) + Math.cos(48882) * 90;
+acc += Math.sin(48882) + Math.cos(48883) * 91;
+acc += Math.sin(48883) + Math.cos(48884) * 92;
+acc += Math.sin(48884) + Math.cos(48885) * 93;
+acc += Math.sin(48885) + Math.cos(48886) * 94;
+acc += Math.sin(48886) + Math.cos(48887) * 95;
+acc += Math.sin(48887) + Math.cos(48888) * 96;
+acc += Math.sin(48888) + Math.cos(48889) * 0;
+acc += Math.sin(48889) + Math.cos(48890) * 1;
+acc += Math.sin(48890) + Math.cos(48891) * 2;
+acc += Math.sin(48891) + Math.cos(48892) * 3;
+acc += Math.sin(48892) + Math.cos(48893) * 4;
+acc += Math.sin(48893) + Math.cos(48894) * 5;
+acc += Math.sin(48894) + Math.cos(48895) * 6;
+acc += Math.sin(48895) + Math.cos(48896) * 7;
+acc += Math.sin(48896) + Math.cos(48897) * 8;
+acc += Math.sin(48897) + Math.cos(48898) * 9;
+acc += Math.sin(48898) + Math.cos(48899) * 10;
+acc += Math.sin(48899) + Math.cos(48900) * 11;
+acc += Math.sin(48900) + Math.cos(48901) * 12;
+acc += Math.sin(48901) + Math.cos(48902) * 13;
+acc += Math.sin(48902) + Math.cos(48903) * 14;
+acc += Math.sin(48903) + Math.cos(48904) * 15;
+acc += Math.sin(48904) + Math.cos(48905) * 16;
+acc += Math.sin(48905) + Math.cos(48906) * 17;
+acc += Math.sin(48906) + Math.cos(48907) * 18;
+acc += Math.sin(48907) + Math.cos(48908) * 19;
+acc += Math.sin(48908) + Math.cos(48909) * 20;
+acc += Math.sin(48909) + Math.cos(48910) * 21;
+acc += Math.sin(48910) + Math.cos(48911) * 22;
+acc += Math.sin(48911) + Math.cos(48912) * 23;
+acc += Math.sin(48912) + Math.cos(48913) * 24;
+acc += Math.sin(48913) + Math.cos(48914) * 25;
+acc += Math.sin(48914) + Math.cos(48915) * 26;
+acc += Math.sin(48915) + Math.cos(48916) * 27;
+acc += Math.sin(48916) + Math.cos(48917) * 28;
+acc += Math.sin(48917) + Math.cos(48918) * 29;
+acc += Math.sin(48918) + Math.cos(48919) * 30;
+acc += Math.sin(48919) + Math.cos(48920) * 31;
+acc += Math.sin(48920) + Math.cos(48921) * 32;
+acc += Math.sin(48921) + Math.cos(48922) * 33;
+acc += Math.sin(48922) + Math.cos(48923) * 34;
+acc += Math.sin(48923) + Math.cos(48924) * 35;
+acc += Math.sin(48924) + Math.cos(48925) * 36;
+acc += Math.sin(48925) + Math.cos(48926) * 37;
+acc += Math.sin(48926) + Math.cos(48927) * 38;
+acc += Math.sin(48927) + Math.cos(48928) * 39;
+acc += Math.sin(48928) + Math.cos(48929) * 40;
+acc += Math.sin(48929) + Math.cos(48930) * 41;
+acc += Math.sin(48930) + Math.cos(48931) * 42;
+acc += Math.sin(48931) + Math.cos(48932) * 43;
+acc += Math.sin(48932) + Math.cos(48933) * 44;
+acc += Math.sin(48933) + Math.cos(48934) * 45;
+acc += Math.sin(48934) + Math.cos(48935) * 46;
+acc += Math.sin(48935) + Math.cos(48936) * 47;
+acc += Math.sin(48936) + Math.cos(48937) * 48;
+acc += Math.sin(48937) + Math.cos(48938) * 49;
+acc += Math.sin(48938) + Math.cos(48939) * 50;
+acc += Math.sin(48939) + Math.cos(48940) * 51;
+acc += Math.sin(48940) + Math.cos(48941) * 52;
+acc += Math.sin(48941) + Math.cos(48942) * 53;
+acc += Math.sin(48942) + Math.cos(48943) * 54;
+acc += Math.sin(48943) + Math.cos(48944) * 55;
+acc += Math.sin(48944) + Math.cos(48945) * 56;
+acc += Math.sin(48945) + Math.cos(48946) * 57;
+acc += Math.sin(48946) + Math.cos(48947) * 58;
+acc += Math.sin(48947) + Math.cos(48948) * 59;
+acc += Math.sin(48948) + Math.cos(48949) * 60;
+acc += Math.sin(48949) + Math.cos(48950) * 61;
+acc += Math.sin(48950) + Math.cos(48951) * 62;
+acc += Math.sin(48951) + Math.cos(48952) * 63;
+acc += Math.sin(48952) + Math.cos(48953) * 64;
+acc += Math.sin(48953) + Math.cos(48954) * 65;
+acc += Math.sin(48954) + Math.cos(48955) * 66;
+acc += Math.sin(48955) + Math.cos(48956) * 67;
+acc += Math.sin(48956) + Math.cos(48957) * 68;
+acc += Math.sin(48957) + Math.cos(48958) * 69;
+acc += Math.sin(48958) + Math.cos(48959) * 70;
+acc += Math.sin(48959) + Math.cos(48960) * 71;
+acc += Math.sin(48960) + Math.cos(48961) * 72;
+acc += Math.sin(48961) + Math.cos(48962) * 73;
+acc += Math.sin(48962) + Math.cos(48963) * 74;
+acc += Math.sin(48963) + Math.cos(48964) * 75;
+acc += Math.sin(48964) + Math.cos(48965) * 76;
+acc += Math.sin(48965) + Math.cos(48966) * 77;
+acc += Math.sin(48966) + Math.cos(48967) * 78;
+acc += Math.sin(48967) + Math.cos(48968) * 79;
+acc += Math.sin(48968) + Math.cos(48969) * 80;
+acc += Math.sin(48969) + Math.cos(48970) * 81;
+acc += Math.sin(48970) + Math.cos(48971) * 82;
+acc += Math.sin(48971) + Math.cos(48972) * 83;
+acc += Math.sin(48972) + Math.cos(48973) * 84;
+acc += Math.sin(48973) + Math.cos(48974) * 85;
+acc += Math.sin(48974) + Math.cos(48975) * 86;
+acc += Math.sin(48975) + Math.cos(48976) * 87;
+acc += Math.sin(48976) + Math.cos(48977) * 88;
+acc += Math.sin(48977) + Math.cos(48978) * 89;
+acc += Math.sin(48978) + Math.cos(48979) * 90;
+acc += Math.sin(48979) + Math.cos(48980) * 91;
+acc += Math.sin(48980) + Math.cos(48981) * 92;
+acc += Math.sin(48981) + Math.cos(48982) * 93;
+acc += Math.sin(48982) + Math.cos(48983) * 94;
+acc += Math.sin(48983) + Math.cos(48984) * 95;
+acc += Math.sin(48984) + Math.cos(48985) * 96;
+acc += Math.sin(48985) + Math.cos(48986) * 0;
+acc += Math.sin(48986) + Math.cos(48987) * 1;
+acc += Math.sin(48987) + Math.cos(48988) * 2;
+acc += Math.sin(48988) + Math.cos(48989) * 3;
+acc += Math.sin(48989) + Math.cos(48990) * 4;
+acc += Math.sin(48990) + Math.cos(48991) * 5;
+acc += Math.sin(48991) + Math.cos(48992) * 6;
+acc += Math.sin(48992) + Math.cos(48993) * 7;
+acc += Math.sin(48993) + Math.cos(48994) * 8;
+acc += Math.sin(48994) + Math.cos(48995) * 9;
+acc += Math.sin(48995) + Math.cos(48996) * 10;
+acc += Math.sin(48996) + Math.cos(48997) * 11;
+acc += Math.sin(48997) + Math.cos(48998) * 12;
+acc += Math.sin(48998) + Math.cos(48999) * 13;
+acc += Math.sin(48999) + Math.cos(49000) * 14;
+acc += Math.sin(49000) + Math.cos(49001) * 15;
+acc += Math.sin(49001) + Math.cos(49002) * 16;
+acc += Math.sin(49002) + Math.cos(49003) * 17;
+acc += Math.sin(49003) + Math.cos(49004) * 18;
+acc += Math.sin(49004) + Math.cos(49005) * 19;
+acc += Math.sin(49005) + Math.cos(49006) * 20;
+acc += Math.sin(49006) + Math.cos(49007) * 21;
+acc += Math.sin(49007) + Math.cos(49008) * 22;
+acc += Math.sin(49008) + Math.cos(49009) * 23;
+acc += Math.sin(49009) + Math.cos(49010) * 24;
+acc += Math.sin(49010) + Math.cos(49011) * 25;
+acc += Math.sin(49011) + Math.cos(49012) * 26;
+acc += Math.sin(49012) + Math.cos(49013) * 27;
+acc += Math.sin(49013) + Math.cos(49014) * 28;
+acc += Math.sin(49014) + Math.cos(49015) * 29;
+acc += Math.sin(49015) + Math.cos(49016) * 30;
+acc += Math.sin(49016) + Math.cos(49017) * 31;
+acc += Math.sin(49017) + Math.cos(49018) * 32;
+acc += Math.sin(49018) + Math.cos(49019) * 33;
+acc += Math.sin(49019) + Math.cos(49020) * 34;
+acc += Math.sin(49020) + Math.cos(49021) * 35;
+acc += Math.sin(49021) + Math.cos(49022) * 36;
+acc += Math.sin(49022) + Math.cos(49023) * 37;
+acc += Math.sin(49023) + Math.cos(49024) * 38;
+acc += Math.sin(49024) + Math.cos(49025) * 39;
+acc += Math.sin(49025) + Math.cos(49026) * 40;
+acc += Math.sin(49026) + Math.cos(49027) * 41;
+acc += Math.sin(49027) + Math.cos(49028) * 42;
+acc += Math.sin(49028) + Math.cos(49029) * 43;
+acc += Math.sin(49029) + Math.cos(49030) * 44;
+acc += Math.sin(49030) + Math.cos(49031) * 45;
+acc += Math.sin(49031) + Math.cos(49032) * 46;
+acc += Math.sin(49032) + Math.cos(49033) * 47;
+acc += Math.sin(49033) + Math.cos(49034) * 48;
+acc += Math.sin(49034) + Math.cos(49035) * 49;
+acc += Math.sin(49035) + Math.cos(49036) * 50;
+acc += Math.sin(49036) + Math.cos(49037) * 51;
+acc += Math.sin(49037) + Math.cos(49038) * 52;
+acc += Math.sin(49038) + Math.cos(49039) * 53;
+acc += Math.sin(49039) + Math.cos(49040) * 54;
+acc += Math.sin(49040) + Math.cos(49041) * 55;
+acc += Math.sin(49041) + Math.cos(49042) * 56;
+acc += Math.sin(49042) + Math.cos(49043) * 57;
+acc += Math.sin(49043) + Math.cos(49044) * 58;
+acc += Math.sin(49044) + Math.cos(49045) * 59;
+acc += Math.sin(49045) + Math.cos(49046) * 60;
+acc += Math.sin(49046) + Math.cos(49047) * 61;
+acc += Math.sin(49047) + Math.cos(49048) * 62;
+acc += Math.sin(49048) + Math.cos(49049) * 63;
+acc += Math.sin(49049) + Math.cos(49050) * 64;
+acc += Math.sin(49050) + Math.cos(49051) * 65;
+acc += Math.sin(49051) + Math.cos(49052) * 66;
+acc += Math.sin(49052) + Math.cos(49053) * 67;
+acc += Math.sin(49053) + Math.cos(49054) * 68;
+acc += Math.sin(49054) + Math.cos(49055) * 69;
+acc += Math.sin(49055) + Math.cos(49056) * 70;
+acc += Math.sin(49056) + Math.cos(49057) * 71;
+acc += Math.sin(49057) + Math.cos(49058) * 72;
+acc += Math.sin(49058) + Math.cos(49059) * 73;
+acc += Math.sin(49059) + Math.cos(49060) * 74;
+acc += Math.sin(49060) + Math.cos(49061) * 75;
+acc += Math.sin(49061) + Math.cos(49062) * 76;
+acc += Math.sin(49062) + Math.cos(49063) * 77;
+acc += Math.sin(49063) + Math.cos(49064) * 78;
+acc += Math.sin(49064) + Math.cos(49065) * 79;
+acc += Math.sin(49065) + Math.cos(49066) * 80;
+acc += Math.sin(49066) + Math.cos(49067) * 81;
+acc += Math.sin(49067) + Math.cos(49068) * 82;
+acc += Math.sin(49068) + Math.cos(49069) * 83;
+acc += Math.sin(49069) + Math.cos(49070) * 84;
+acc += Math.sin(49070) + Math.cos(49071) * 85;
+acc += Math.sin(49071) + Math.cos(49072) * 86;
+acc += Math.sin(49072) + Math.cos(49073) * 87;
+acc += Math.sin(49073) + Math.cos(49074) * 88;
+acc += Math.sin(49074) + Math.cos(49075) * 89;
+acc += Math.sin(49075) + Math.cos(49076) * 90;
+acc += Math.sin(49076) + Math.cos(49077) * 91;
+acc += Math.sin(49077) + Math.cos(49078) * 92;
+acc += Math.sin(49078) + Math.cos(49079) * 93;
+acc += Math.sin(49079) + Math.cos(49080) * 94;
+acc += Math.sin(49080) + Math.cos(49081) * 95;
+acc += Math.sin(49081) + Math.cos(49082) * 96;
+acc += Math.sin(49082) + Math.cos(49083) * 0;
+acc += Math.sin(49083) + Math.cos(49084) * 1;
+acc += Math.sin(49084) + Math.cos(49085) * 2;
+acc += Math.sin(49085) + Math.cos(49086) * 3;
+acc += Math.sin(49086) + Math.cos(49087) * 4;
+acc += Math.sin(49087) + Math.cos(49088) * 5;
+acc += Math.sin(49088) + Math.cos(49089) * 6;
+acc += Math.sin(49089) + Math.cos(49090) * 7;
+acc += Math.sin(49090) + Math.cos(49091) * 8;
+acc += Math.sin(49091) + Math.cos(49092) * 9;
+acc += Math.sin(49092) + Math.cos(49093) * 10;
+acc += Math.sin(49093) + Math.cos(49094) * 11;
+acc += Math.sin(49094) + Math.cos(49095) * 12;
+acc += Math.sin(49095) + Math.cos(49096) * 13;
+acc += Math.sin(49096) + Math.cos(49097) * 14;
+acc += Math.sin(49097) + Math.cos(49098) * 15;
+acc += Math.sin(49098) + Math.cos(49099) * 16;
+acc += Math.sin(49099) + Math.cos(49100) * 17;
+acc += Math.sin(49100) + Math.cos(49101) * 18;
+acc += Math.sin(49101) + Math.cos(49102) * 19;
+acc += Math.sin(49102) + Math.cos(49103) * 20;
+acc += Math.sin(49103) + Math.cos(49104) * 21;
+acc += Math.sin(49104) + Math.cos(49105) * 22;
+acc += Math.sin(49105) + Math.cos(49106) * 23;
+acc += Math.sin(49106) + Math.cos(49107) * 24;
+acc += Math.sin(49107) + Math.cos(49108) * 25;
+acc += Math.sin(49108) + Math.cos(49109) * 26;
+acc += Math.sin(49109) + Math.cos(49110) * 27;
+acc += Math.sin(49110) + Math.cos(49111) * 28;
+acc += Math.sin(49111) + Math.cos(49112) * 29;
+acc += Math.sin(49112) + Math.cos(49113) * 30;
+acc += Math.sin(49113) + Math.cos(49114) * 31;
+acc += Math.sin(49114) + Math.cos(49115) * 32;
+acc += Math.sin(49115) + Math.cos(49116) * 33;
+acc += Math.sin(49116) + Math.cos(49117) * 34;
+acc += Math.sin(49117) + Math.cos(49118) * 35;
+acc += Math.sin(49118) + Math.cos(49119) * 36;
+acc += Math.sin(49119) + Math.cos(49120) * 37;
+acc += Math.sin(49120) + Math.cos(49121) * 38;
+acc += Math.sin(49121) + Math.cos(49122) * 39;
+acc += Math.sin(49122) + Math.cos(49123) * 40;
+acc += Math.sin(49123) + Math.cos(49124) * 41;
+acc += Math.sin(49124) + Math.cos(49125) * 42;
+acc += Math.sin(49125) + Math.cos(49126) * 43;
+acc += Math.sin(49126) + Math.cos(49127) * 44;
+acc += Math.sin(49127) + Math.cos(49128) * 45;
+acc += Math.sin(49128) + Math.cos(49129) * 46;
+acc += Math.sin(49129) + Math.cos(49130) * 47;
+acc += Math.sin(49130) + Math.cos(49131) * 48;
+acc += Math.sin(49131) + Math.cos(49132) * 49;
+acc += Math.sin(49132) + Math.cos(49133) * 50;
+acc += Math.sin(49133) + Math.cos(49134) * 51;
+acc += Math.sin(49134) + Math.cos(49135) * 52;
+acc += Math.sin(49135) + Math.cos(49136) * 53;
+acc += Math.sin(49136) + Math.cos(49137) * 54;
+acc += Math.sin(49137) + Math.cos(49138) * 55;
+acc += Math.sin(49138) + Math.cos(49139) * 56;
+acc += Math.sin(49139) + Math.cos(49140) * 57;
+acc += Math.sin(49140) + Math.cos(49141) * 58;
+acc += Math.sin(49141) + Math.cos(49142) * 59;
+acc += Math.sin(49142) + Math.cos(49143) * 60;
+acc += Math.sin(49143) + Math.cos(49144) * 61;
+acc += Math.sin(49144) + Math.cos(49145) * 62;
+acc += Math.sin(49145) + Math.cos(49146) * 63;
+acc += Math.sin(49146) + Math.cos(49147) * 64;
+acc += Math.sin(49147) + Math.cos(49148) * 65;
+acc += Math.sin(49148) + Math.cos(49149) * 66;
+acc += Math.sin(49149) + Math.cos(49150) * 67;
+acc += Math.sin(49150) + Math.cos(49151) * 68;
+acc += Math.sin(49151) + Math.cos(49152) * 69;
+acc += Math.sin(49152) + Math.cos(49153) * 70;
+acc += Math.sin(49153) + Math.cos(49154) * 71;
+acc += Math.sin(49154) + Math.cos(49155) * 72;
+acc += Math.sin(49155) + Math.cos(49156) * 73;
+acc += Math.sin(49156) + Math.cos(49157) * 74;
+acc += Math.sin(49157) + Math.cos(49158) * 75;
+acc += Math.sin(49158) + Math.cos(49159) * 76;
+acc += Math.sin(49159) + Math.cos(49160) * 77;
+acc += Math.sin(49160) + Math.cos(49161) * 78;
+acc += Math.sin(49161) + Math.cos(49162) * 79;
+acc += Math.sin(49162) + Math.cos(49163) * 80;
+acc += Math.sin(49163) + Math.cos(49164) * 81;
+acc += Math.sin(49164) + Math.cos(49165) * 82;
+acc += Math.sin(49165) + Math.cos(49166) * 83;
+acc += Math.sin(49166) + Math.cos(49167) * 84;
+acc += Math.sin(49167) + Math.cos(49168) * 85;
+acc += Math.sin(49168) + Math.cos(49169) * 86;
+acc += Math.sin(49169) + Math.cos(49170) * 87;
+acc += Math.sin(49170) + Math.cos(49171) * 88;
+acc += Math.sin(49171) + Math.cos(49172) * 89;
+acc += Math.sin(49172) + Math.cos(49173) * 90;
+acc += Math.sin(49173) + Math.cos(49174) * 91;
+acc += Math.sin(49174) + Math.cos(49175) * 92;
+acc += Math.sin(49175) + Math.cos(49176) * 93;
+acc += Math.sin(49176) + Math.cos(49177) * 94;
+acc += Math.sin(49177) + Math.cos(49178) * 95;
+acc += Math.sin(49178) + Math.cos(49179) * 96;
+acc += Math.sin(49179) + Math.cos(49180) * 0;
+acc += Math.sin(49180) + Math.cos(49181) * 1;
+acc += Math.sin(49181) + Math.cos(49182) * 2;
+acc += Math.sin(49182) + Math.cos(49183) * 3;
+acc += Math.sin(49183) + Math.cos(49184) * 4;
+acc += Math.sin(49184) + Math.cos(49185) * 5;
+acc += Math.sin(49185) + Math.cos(49186) * 6;
+acc += Math.sin(49186) + Math.cos(49187) * 7;
+acc += Math.sin(49187) + Math.cos(49188) * 8;
+acc += Math.sin(49188) + Math.cos(49189) * 9;
+acc += Math.sin(49189) + Math.cos(49190) * 10;
+acc += Math.sin(49190) + Math.cos(49191) * 11;
+acc += Math.sin(49191) + Math.cos(49192) * 12;
+acc += Math.sin(49192) + Math.cos(49193) * 13;
+acc += Math.sin(49193) + Math.cos(49194) * 14;
+acc += Math.sin(49194) + Math.cos(49195) * 15;
+acc += Math.sin(49195) + Math.cos(49196) * 16;
+acc += Math.sin(49196) + Math.cos(49197) * 17;
+acc += Math.sin(49197) + Math.cos(49198) * 18;
+acc += Math.sin(49198) + Math.cos(49199) * 19;
+acc += Math.sin(49199) + Math.cos(49200) * 20;
+acc += Math.sin(49200) + Math.cos(49201) * 21;
+acc += Math.sin(49201) + Math.cos(49202) * 22;
+acc += Math.sin(49202) + Math.cos(49203) * 23;
+acc += Math.sin(49203) + Math.cos(49204) * 24;
+acc += Math.sin(49204) + Math.cos(49205) * 25;
+acc += Math.sin(49205) + Math.cos(49206) * 26;
+acc += Math.sin(49206) + Math.cos(49207) * 27;
+acc += Math.sin(49207) + Math.cos(49208) * 28;
+acc += Math.sin(49208) + Math.cos(49209) * 29;
+acc += Math.sin(49209) + Math.cos(49210) * 30;
+acc += Math.sin(49210) + Math.cos(49211) * 31;
+acc += Math.sin(49211) + Math.cos(49212) * 32;
+acc += Math.sin(49212) + Math.cos(49213) * 33;
+acc += Math.sin(49213) + Math.cos(49214) * 34;
+acc += Math.sin(49214) + Math.cos(49215) * 35;
+acc += Math.sin(49215) + Math.cos(49216) * 36;
+acc += Math.sin(49216) + Math.cos(49217) * 37;
+acc += Math.sin(49217) + Math.cos(49218) * 38;
+acc += Math.sin(49218) + Math.cos(49219) * 39;
+acc += Math.sin(49219) + Math.cos(49220) * 40;
+acc += Math.sin(49220) + Math.cos(49221) * 41;
+acc += Math.sin(49221) + Math.cos(49222) * 42;
+acc += Math.sin(49222) + Math.cos(49223) * 43;
+acc += Math.sin(49223) + Math.cos(49224) * 44;
+acc += Math.sin(49224) + Math.cos(49225) * 45;
+acc += Math.sin(49225) + Math.cos(49226) * 46;
+acc += Math.sin(49226) + Math.cos(49227) * 47;
+acc += Math.sin(49227) + Math.cos(49228) * 48;
+acc += Math.sin(49228) + Math.cos(49229) * 49;
+acc += Math.sin(49229) + Math.cos(49230) * 50;
+acc += Math.sin(49230) + Math.cos(49231) * 51;
+acc += Math.sin(49231) + Math.cos(49232) * 52;
+acc += Math.sin(49232) + Math.cos(49233) * 53;
+acc += Math.sin(49233) + Math.cos(49234) * 54;
+acc += Math.sin(49234) + Math.cos(49235) * 55;
+acc += Math.sin(49235) + Math.cos(49236) * 56;
+acc += Math.sin(49236) + Math.cos(49237) * 57;
+acc += Math.sin(49237) + Math.cos(49238) * 58;
+acc += Math.sin(49238) + Math.cos(49239) * 59;
+acc += Math.sin(49239) + Math.cos(49240) * 60;
+acc += Math.sin(49240) + Math.cos(49241) * 61;
+acc += Math.sin(49241) + Math.cos(49242) * 62;
+acc += Math.sin(49242) + Math.cos(49243) * 63;
+acc += Math.sin(49243) + Math.cos(49244) * 64;
+acc += Math.sin(49244) + Math.cos(49245) * 65;
+acc += Math.sin(49245) + Math.cos(49246) * 66;
+acc += Math.sin(49246) + Math.cos(49247) * 67;
+acc += Math.sin(49247) + Math.cos(49248) * 68;
+acc += Math.sin(49248) + Math.cos(49249) * 69;
+acc += Math.sin(49249) + Math.cos(49250) * 70;
+acc += Math.sin(49250) + Math.cos(49251) * 71;
+acc += Math.sin(49251) + Math.cos(49252) * 72;
+acc += Math.sin(49252) + Math.cos(49253) * 73;
+acc += Math.sin(49253) + Math.cos(49254) * 74;
+acc += Math.sin(49254) + Math.cos(49255) * 75;
+acc += Math.sin(49255) + Math.cos(49256) * 76;
+acc += Math.sin(49256) + Math.cos(49257) * 77;
+acc += Math.sin(49257) + Math.cos(49258) * 78;
+acc += Math.sin(49258) + Math.cos(49259) * 79;
+acc += Math.sin(49259) + Math.cos(49260) * 80;
+acc += Math.sin(49260) + Math.cos(49261) * 81;
+acc += Math.sin(49261) + Math.cos(49262) * 82;
+acc += Math.sin(49262) + Math.cos(49263) * 83;
+acc += Math.sin(49263) + Math.cos(49264) * 84;
+acc += Math.sin(49264) + Math.cos(49265) * 85;
+acc += Math.sin(49265) + Math.cos(49266) * 86;
+acc += Math.sin(49266) + Math.cos(49267) * 87;
+acc += Math.sin(49267) + Math.cos(49268) * 88;
+acc += Math.sin(49268) + Math.cos(49269) * 89;
+acc += Math.sin(49269) + Math.cos(49270) * 90;
+acc += Math.sin(49270) + Math.cos(49271) * 91;
+acc += Math.sin(49271) + Math.cos(49272) * 92;
+acc += Math.sin(49272) + Math.cos(49273) * 93;
+acc += Math.sin(49273) + Math.cos(49274) * 94;
+acc += Math.sin(49274) + Math.cos(49275) * 95;
+acc += Math.sin(49275) + Math.cos(49276) * 96;
+acc += Math.sin(49276) + Math.cos(49277) * 0;
+acc += Math.sin(49277) + Math.cos(49278) * 1;
+acc += Math.sin(49278) + Math.cos(49279) * 2;
+acc += Math.sin(49279) + Math.cos(49280) * 3;
+acc += Math.sin(49280) + Math.cos(49281) * 4;
+acc += Math.sin(49281) + Math.cos(49282) * 5;
+acc += Math.sin(49282) + Math.cos(49283) * 6;
+acc += Math.sin(49283) + Math.cos(49284) * 7;
+acc += Math.sin(49284) + Math.cos(49285) * 8;
+acc += Math.sin(49285) + Math.cos(49286) * 9;
+acc += Math.sin(49286) + Math.cos(49287) * 10;
+acc += Math.sin(49287) + Math.cos(49288) * 11;
+acc += Math.sin(49288) + Math.cos(49289) * 12;
+acc += Math.sin(49289) + Math.cos(49290) * 13;
+acc += Math.sin(49290) + Math.cos(49291) * 14;
+acc += Math.sin(49291) + Math.cos(49292) * 15;
+acc += Math.sin(49292) + Math.cos(49293) * 16;
+acc += Math.sin(49293) + Math.cos(49294) * 17;
+acc += Math.sin(49294) + Math.cos(49295) * 18;
+acc += Math.sin(49295) + Math.cos(49296) * 19;
+acc += Math.sin(49296) + Math.cos(49297) * 20;
+acc += Math.sin(49297) + Math.cos(49298) * 21;
+acc += Math.sin(49298) + Math.cos(49299) * 22;
+acc += Math.sin(49299) + Math.cos(49300) * 23;
+acc += Math.sin(49300) + Math.cos(49301) * 24;
+acc += Math.sin(49301) + Math.cos(49302) * 25;
+acc += Math.sin(49302) + Math.cos(49303) * 26;
+acc += Math.sin(49303) + Math.cos(49304) * 27;
+acc += Math.sin(49304) + Math.cos(49305) * 28;
+acc += Math.sin(49305) + Math.cos(49306) * 29;
+acc += Math.sin(49306) + Math.cos(49307) * 30;
+acc += Math.sin(49307) + Math.cos(49308) * 31;
+acc += Math.sin(49308) + Math.cos(49309) * 32;
+acc += Math.sin(49309) + Math.cos(49310) * 33;
+acc += Math.sin(49310) + Math.cos(49311) * 34;
+acc += Math.sin(49311) + Math.cos(49312) * 35;
+acc += Math.sin(49312) + Math.cos(49313) * 36;
+acc += Math.sin(49313) + Math.cos(49314) * 37;
+acc += Math.sin(49314) + Math.cos(49315) * 38;
+acc += Math.sin(49315) + Math.cos(49316) * 39;
+acc += Math.sin(49316) + Math.cos(49317) * 40;
+acc += Math.sin(49317) + Math.cos(49318) * 41;
+acc += Math.sin(49318) + Math.cos(49319) * 42;
+acc += Math.sin(49319) + Math.cos(49320) * 43;
+acc += Math.sin(49320) + Math.cos(49321) * 44;
+acc += Math.sin(49321) + Math.cos(49322) * 45;
+acc += Math.sin(49322) + Math.cos(49323) * 46;
+acc += Math.sin(49323) + Math.cos(49324) * 47;
+acc += Math.sin(49324) + Math.cos(49325) * 48;
+acc += Math.sin(49325) + Math.cos(49326) * 49;
+acc += Math.sin(49326) + Math.cos(49327) * 50;
+acc += Math.sin(49327) + Math.cos(49328) * 51;
+acc += Math.sin(49328) + Math.cos(49329) * 52;
+acc += Math.sin(49329) + Math.cos(49330) * 53;
+acc += Math.sin(49330) + Math.cos(49331) * 54;
+acc += Math.sin(49331) + Math.cos(49332) * 55;
+acc += Math.sin(49332) + Math.cos(49333) * 56;
+acc += Math.sin(49333) + Math.cos(49334) * 57;
+acc += Math.sin(49334) + Math.cos(49335) * 58;
+acc += Math.sin(49335) + Math.cos(49336) * 59;
+acc += Math.sin(49336) + Math.cos(49337) * 60;
+acc += Math.sin(49337) + Math.cos(49338) * 61;
+acc += Math.sin(49338) + Math.cos(49339) * 62;
+acc += Math.sin(49339) + Math.cos(49340) * 63;
+acc += Math.sin(49340) + Math.cos(49341) * 64;
+acc += Math.sin(49341) + Math.cos(49342) * 65;
+acc += Math.sin(49342) + Math.cos(49343) * 66;
+acc += Math.sin(49343) + Math.cos(49344) * 67;
+acc += Math.sin(49344) + Math.cos(49345) * 68;
+acc += Math.sin(49345) + Math.cos(49346) * 69;
+acc += Math.sin(49346) + Math.cos(49347) * 70;
+acc += Math.sin(49347) + Math.cos(49348) * 71;
+acc += Math.sin(49348) + Math.cos(49349) * 72;
+acc += Math.sin(49349) + Math.cos(49350) * 73;
+acc += Math.sin(49350) + Math.cos(49351) * 74;
+acc += Math.sin(49351) + Math.cos(49352) * 75;
+acc += Math.sin(49352) + Math.cos(49353) * 76;
+acc += Math.sin(49353) + Math.cos(49354) * 77;
+acc += Math.sin(49354) + Math.cos(49355) * 78;
+acc += Math.sin(49355) + Math.cos(49356) * 79;
+acc += Math.sin(49356) + Math.cos(49357) * 80;
+acc += Math.sin(49357) + Math.cos(49358) * 81;
+acc += Math.sin(49358) + Math.cos(49359) * 82;
+acc += Math.sin(49359) + Math.cos(49360) * 83;
+acc += Math.sin(49360) + Math.cos(49361) * 84;
+acc += Math.sin(49361) + Math.cos(49362) * 85;
+acc += Math.sin(49362) + Math.cos(49363) * 86;
+acc += Math.sin(49363) + Math.cos(49364) * 87;
+acc += Math.sin(49364) + Math.cos(49365) * 88;
+acc += Math.sin(49365) + Math.cos(49366) * 89;
+acc += Math.sin(49366) + Math.cos(49367) * 90;
+acc += Math.sin(49367) + Math.cos(49368) * 91;
+acc += Math.sin(49368) + Math.cos(49369) * 92;
+acc += Math.sin(49369) + Math.cos(49370) * 93;
+acc += Math.sin(49370) + Math.cos(49371) * 94;
+acc += Math.sin(49371) + Math.cos(49372) * 95;
+acc += Math.sin(49372) + Math.cos(49373) * 96;
+acc += Math.sin(49373) + Math.cos(49374) * 0;
+acc += Math.sin(49374) + Math.cos(49375) * 1;
+acc += Math.sin(49375) + Math.cos(49376) * 2;
+acc += Math.sin(49376) + Math.cos(49377) * 3;
+acc += Math.sin(49377) + Math.cos(49378) * 4;
+acc += Math.sin(49378) + Math.cos(49379) * 5;
+acc += Math.sin(49379) + Math.cos(49380) * 6;
+acc += Math.sin(49380) + Math.cos(49381) * 7;
+acc += Math.sin(49381) + Math.cos(49382) * 8;
+acc += Math.sin(49382) + Math.cos(49383) * 9;
+acc += Math.sin(49383) + Math.cos(49384) * 10;
+acc += Math.sin(49384) + Math.cos(49385) * 11;
+acc += Math.sin(49385) + Math.cos(49386) * 12;
+acc += Math.sin(49386) + Math.cos(49387) * 13;
+acc += Math.sin(49387) + Math.cos(49388) * 14;
+acc += Math.sin(49388) + Math.cos(49389) * 15;
+acc += Math.sin(49389) + Math.cos(49390) * 16;
+acc += Math.sin(49390) + Math.cos(49391) * 17;
+acc += Math.sin(49391) + Math.cos(49392) * 18;
+acc += Math.sin(49392) + Math.cos(49393) * 19;
+acc += Math.sin(49393) + Math.cos(49394) * 20;
+acc += Math.sin(49394) + Math.cos(49395) * 21;
+acc += Math.sin(49395) + Math.cos(49396) * 22;
+acc += Math.sin(49396) + Math.cos(49397) * 23;
+acc += Math.sin(49397) + Math.cos(49398) * 24;
+acc += Math.sin(49398) + Math.cos(49399) * 25;
+acc += Math.sin(49399) + Math.cos(49400) * 26;
+acc += Math.sin(49400) + Math.cos(49401) * 27;
+acc += Math.sin(49401) + Math.cos(49402) * 28;
+acc += Math.sin(49402) + Math.cos(49403) * 29;
+acc += Math.sin(49403) + Math.cos(49404) * 30;
+acc += Math.sin(49404) + Math.cos(49405) * 31;
+acc += Math.sin(49405) + Math.cos(49406) * 32;
+acc += Math.sin(49406) + Math.cos(49407) * 33;
+acc += Math.sin(49407) + Math.cos(49408) * 34;
+acc += Math.sin(49408) + Math.cos(49409) * 35;
+acc += Math.sin(49409) + Math.cos(49410) * 36;
+acc += Math.sin(49410) + Math.cos(49411) * 37;
+acc += Math.sin(49411) + Math.cos(49412) * 38;
+acc += Math.sin(49412) + Math.cos(49413) * 39;
+acc += Math.sin(49413) + Math.cos(49414) * 40;
+acc += Math.sin(49414) + Math.cos(49415) * 41;
+acc += Math.sin(49415) + Math.cos(49416) * 42;
+acc += Math.sin(49416) + Math.cos(49417) * 43;
+acc += Math.sin(49417) + Math.cos(49418) * 44;
+acc += Math.sin(49418) + Math.cos(49419) * 45;
+acc += Math.sin(49419) + Math.cos(49420) * 46;
+acc += Math.sin(49420) + Math.cos(49421) * 47;
+acc += Math.sin(49421) + Math.cos(49422) * 48;
+acc += Math.sin(49422) + Math.cos(49423) * 49;
+acc += Math.sin(49423) + Math.cos(49424) * 50;
+acc += Math.sin(49424) + Math.cos(49425) * 51;
+acc += Math.sin(49425) + Math.cos(49426) * 52;
+acc += Math.sin(49426) + Math.cos(49427) * 53;
+acc += Math.sin(49427) + Math.cos(49428) * 54;
+acc += Math.sin(49428) + Math.cos(49429) * 55;
+acc += Math.sin(49429) + Math.cos(49430) * 56;
+acc += Math.sin(49430) + Math.cos(49431) * 57;
+acc += Math.sin(49431) + Math.cos(49432) * 58;
+acc += Math.sin(49432) + Math.cos(49433) * 59;
+acc += Math.sin(49433) + Math.cos(49434) * 60;
+acc += Math.sin(49434) + Math.cos(49435) * 61;
+acc += Math.sin(49435) + Math.cos(49436) * 62;
+acc += Math.sin(49436) + Math.cos(49437) * 63;
+acc += Math.sin(49437) + Math.cos(49438) * 64;
+acc += Math.sin(49438) + Math.cos(49439) * 65;
+acc += Math.sin(49439) + Math.cos(49440) * 66;
+acc += Math.sin(49440) + Math.cos(49441) * 67;
+acc += Math.sin(49441) + Math.cos(49442) * 68;
+acc += Math.sin(49442) + Math.cos(49443) * 69;
+acc += Math.sin(49443) + Math.cos(49444) * 70;
+acc += Math.sin(49444) + Math.cos(49445) * 71;
+acc += Math.sin(49445) + Math.cos(49446) * 72;
+acc += Math.sin(49446) + Math.cos(49447) * 73;
+acc += Math.sin(49447) + Math.cos(49448) * 74;
+acc += Math.sin(49448) + Math.cos(49449) * 75;
+acc += Math.sin(49449) + Math.cos(49450) * 76;
+acc += Math.sin(49450) + Math.cos(49451) * 77;
+acc += Math.sin(49451) + Math.cos(49452) * 78;
+acc += Math.sin(49452) + Math.cos(49453) * 79;
+acc += Math.sin(49453) + Math.cos(49454) * 80;
+acc += Math.sin(49454) + Math.cos(49455) * 81;
+acc += Math.sin(49455) + Math.cos(49456) * 82;
+acc += Math.sin(49456) + Math.cos(49457) * 83;
+acc += Math.sin(49457) + Math.cos(49458) * 84;
+acc += Math.sin(49458) + Math.cos(49459) * 85;
+acc += Math.sin(49459) + Math.cos(49460) * 86;
+acc += Math.sin(49460) + Math.cos(49461) * 87;
+acc += Math.sin(49461) + Math.cos(49462) * 88;
+acc += Math.sin(49462) + Math.cos(49463) * 89;
+acc += Math.sin(49463) + Math.cos(49464) * 90;
+acc += Math.sin(49464) + Math.cos(49465) * 91;
+acc += Math.sin(49465) + Math.cos(49466) * 92;
+acc += Math.sin(49466) + Math.cos(49467) * 93;
+acc += Math.sin(49467) + Math.cos(49468) * 94;
+acc += Math.sin(49468) + Math.cos(49469) * 95;
+acc += Math.sin(49469) + Math.cos(49470) * 96;
+acc += Math.sin(49470) + Math.cos(49471) * 0;
+acc += Math.sin(49471) + Math.cos(49472) * 1;
+acc += Math.sin(49472) + Math.cos(49473) * 2;
+acc += Math.sin(49473) + Math.cos(49474) * 3;
+acc += Math.sin(49474) + Math.cos(49475) * 4;
+acc += Math.sin(49475) + Math.cos(49476) * 5;
+acc += Math.sin(49476) + Math.cos(49477) * 6;
+acc += Math.sin(49477) + Math.cos(49478) * 7;
+acc += Math.sin(49478) + Math.cos(49479) * 8;
+acc += Math.sin(49479) + Math.cos(49480) * 9;
+acc += Math.sin(49480) + Math.cos(49481) * 10;
+acc += Math.sin(49481) + Math.cos(49482) * 11;
+acc += Math.sin(49482) + Math.cos(49483) * 12;
+acc += Math.sin(49483) + Math.cos(49484) * 13;
+acc += Math.sin(49484) + Math.cos(49485) * 14;
+acc += Math.sin(49485) + Math.cos(49486) * 15;
+acc += Math.sin(49486) + Math.cos(49487) * 16;
+acc += Math.sin(49487) + Math.cos(49488) * 17;
+acc += Math.sin(49488) + Math.cos(49489) * 18;
+acc += Math.sin(49489) + Math.cos(49490) * 19;
+acc += Math.sin(49490) + Math.cos(49491) * 20;
+acc += Math.sin(49491) + Math.cos(49492) * 21;
+acc += Math.sin(49492) + Math.cos(49493) * 22;
+acc += Math.sin(49493) + Math.cos(49494) * 23;
+acc += Math.sin(49494) + Math.cos(49495) * 24;
+acc += Math.sin(49495) + Math.cos(49496) * 25;
+acc += Math.sin(49496) + Math.cos(49497) * 26;
+acc += Math.sin(49497) + Math.cos(49498) * 27;
+acc += Math.sin(49498) + Math.cos(49499) * 28;
+acc += Math.sin(49499) + Math.cos(49500) * 29;
+acc += Math.sin(49500) + Math.cos(49501) * 30;
+acc += Math.sin(49501) + Math.cos(49502) * 31;
+acc += Math.sin(49502) + Math.cos(49503) * 32;
+acc += Math.sin(49503) + Math.cos(49504) * 33;
+acc += Math.sin(49504) + Math.cos(49505) * 34;
+acc += Math.sin(49505) + Math.cos(49506) * 35;
+acc += Math.sin(49506) + Math.cos(49507) * 36;
+acc += Math.sin(49507) + Math.cos(49508) * 37;
+acc += Math.sin(49508) + Math.cos(49509) * 38;
+acc += Math.sin(49509) + Math.cos(49510) * 39;
+acc += Math.sin(49510) + Math.cos(49511) * 40;
+acc += Math.sin(49511) + Math.cos(49512) * 41;
+acc += Math.sin(49512) + Math.cos(49513) * 42;
+acc += Math.sin(49513) + Math.cos(49514) * 43;
+acc += Math.sin(49514) + Math.cos(49515) * 44;
+acc += Math.sin(49515) + Math.cos(49516) * 45;
+acc += Math.sin(49516) + Math.cos(49517) * 46;
+acc += Math.sin(49517) + Math.cos(49518) * 47;
+acc += Math.sin(49518) + Math.cos(49519) * 48;
+acc += Math.sin(49519) + Math.cos(49520) * 49;
+acc += Math.sin(49520) + Math.cos(49521) * 50;
+acc += Math.sin(49521) + Math.cos(49522) * 51;
+acc += Math.sin(49522) + Math.cos(49523) * 52;
+acc += Math.sin(49523) + Math.cos(49524) * 53;
+acc += Math.sin(49524) + Math.cos(49525) * 54;
+acc += Math.sin(49525) + Math.cos(49526) * 55;
+acc += Math.sin(49526) + Math.cos(49527) * 56;
+acc += Math.sin(49527) + Math.cos(49528) * 57;
+acc += Math.sin(49528) + Math.cos(49529) * 58;
+acc += Math.sin(49529) + Math.cos(49530) * 59;
+acc += Math.sin(49530) + Math.cos(49531) * 60;
+acc += Math.sin(49531) + Math.cos(49532) * 61;
+acc += Math.sin(49532) + Math.cos(49533) * 62;
+acc += Math.sin(49533) + Math.cos(49534) * 63;
+acc += Math.sin(49534) + Math.cos(49535) * 64;
+acc += Math.sin(49535) + Math.cos(49536) * 65;
+acc += Math.sin(49536) + Math.cos(49537) * 66;
+acc += Math.sin(49537) + Math.cos(49538) * 67;
+acc += Math.sin(49538) + Math.cos(49539) * 68;
+acc += Math.sin(49539) + Math.cos(49540) * 69;
+acc += Math.sin(49540) + Math.cos(49541) * 70;
+acc += Math.sin(49541) + Math.cos(49542) * 71;
+acc += Math.sin(49542) + Math.cos(49543) * 72;
+acc += Math.sin(49543) + Math.cos(49544) * 73;
+acc += Math.sin(49544) + Math.cos(49545) * 74;
+acc += Math.sin(49545) + Math.cos(49546) * 75;
+acc += Math.sin(49546) + Math.cos(49547) * 76;
+acc += Math.sin(49547) + Math.cos(49548) * 77;
+acc += Math.sin(49548) + Math.cos(49549) * 78;
+acc += Math.sin(49549) + Math.cos(49550) * 79;
+acc += Math.sin(49550) + Math.cos(49551) * 80;
+acc += Math.sin(49551) + Math.cos(49552) * 81;
+acc += Math.sin(49552) + Math.cos(49553) * 82;
+acc += Math.sin(49553) + Math.cos(49554) * 83;
+acc += Math.sin(49554) + Math.cos(49555) * 84;
+acc += Math.sin(49555) + Math.cos(49556) * 85;
+acc += Math.sin(49556) + Math.cos(49557) * 86;
+acc += Math.sin(49557) + Math.cos(49558) * 87;
+acc += Math.sin(49558) + Math.cos(49559) * 88;
+acc += Math.sin(49559) + Math.cos(49560) * 89;
+acc += Math.sin(49560) + Math.cos(49561) * 90;
+acc += Math.sin(49561) + Math.cos(49562) * 91;
+acc += Math.sin(49562) + Math.cos(49563) * 92;
+acc += Math.sin(49563) + Math.cos(49564) * 93;
+acc += Math.sin(49564) + Math.cos(49565) * 94;
+acc += Math.sin(49565) + Math.cos(49566) * 95;
+acc += Math.sin(49566) + Math.cos(49567) * 96;
+acc += Math.sin(49567) + Math.cos(49568) * 0;
+acc += Math.sin(49568) + Math.cos(49569) * 1;
+acc += Math.sin(49569) + Math.cos(49570) * 2;
+acc += Math.sin(49570) + Math.cos(49571) * 3;
+acc += Math.sin(49571) + Math.cos(49572) * 4;
+acc += Math.sin(49572) + Math.cos(49573) * 5;
+acc += Math.sin(49573) + Math.cos(49574) * 6;
+acc += Math.sin(49574) + Math.cos(49575) * 7;
+acc += Math.sin(49575) + Math.cos(49576) * 8;
+acc += Math.sin(49576) + Math.cos(49577) * 9;
+acc += Math.sin(49577) + Math.cos(49578) * 10;
+acc += Math.sin(49578) + Math.cos(49579) * 11;
+acc += Math.sin(49579) + Math.cos(49580) * 12;
+acc += Math.sin(49580) + Math.cos(49581) * 13;
+acc += Math.sin(49581) + Math.cos(49582) * 14;
+acc += Math.sin(49582) + Math.cos(49583) * 15;
+acc += Math.sin(49583) + Math.cos(49584) * 16;
+acc += Math.sin(49584) + Math.cos(49585) * 17;
+acc += Math.sin(49585) + Math.cos(49586) * 18;
+acc += Math.sin(49586) + Math.cos(49587) * 19;
+acc += Math.sin(49587) + Math.cos(49588) * 20;
+acc += Math.sin(49588) + Math.cos(49589) * 21;
+acc += Math.sin(49589) + Math.cos(49590) * 22;
+acc += Math.sin(49590) + Math.cos(49591) * 23;
+acc += Math.sin(49591) + Math.cos(49592) * 24;
+acc += Math.sin(49592) + Math.cos(49593) * 25;
+acc += Math.sin(49593) + Math.cos(49594) * 26;
+acc += Math.sin(49594) + Math.cos(49595) * 27;
+acc += Math.sin(49595) + Math.cos(49596) * 28;
+acc += Math.sin(49596) + Math.cos(49597) * 29;
+acc += Math.sin(49597) + Math.cos(49598) * 30;
+acc += Math.sin(49598) + Math.cos(49599) * 31;
+acc += Math.sin(49599) + Math.cos(49600) * 32;
+acc += Math.sin(49600) + Math.cos(49601) * 33;
+acc += Math.sin(49601) + Math.cos(49602) * 34;
+acc += Math.sin(49602) + Math.cos(49603) * 35;
+acc += Math.sin(49603) + Math.cos(49604) * 36;
+acc += Math.sin(49604) + Math.cos(49605) * 37;
+acc += Math.sin(49605) + Math.cos(49606) * 38;
+acc += Math.sin(49606) + Math.cos(49607) * 39;
+acc += Math.sin(49607) + Math.cos(49608) * 40;
+acc += Math.sin(49608) + Math.cos(49609) * 41;
+acc += Math.sin(49609) + Math.cos(49610) * 42;
+acc += Math.sin(49610) + Math.cos(49611) * 43;
+acc += Math.sin(49611) + Math.cos(49612) * 44;
+acc += Math.sin(49612) + Math.cos(49613) * 45;
+acc += Math.sin(49613) + Math.cos(49614) * 46;
+acc += Math.sin(49614) + Math.cos(49615) * 47;
+acc += Math.sin(49615) + Math.cos(49616) * 48;
+acc += Math.sin(49616) + Math.cos(49617) * 49;
+acc += Math.sin(49617) + Math.cos(49618) * 50;
+acc += Math.sin(49618) + Math.cos(49619) * 51;
+acc += Math.sin(49619) + Math.cos(49620) * 52;
+acc += Math.sin(49620) + Math.cos(49621) * 53;
+acc += Math.sin(49621) + Math.cos(49622) * 54;
+acc += Math.sin(49622) + Math.cos(49623) * 55;
+acc += Math.sin(49623) + Math.cos(49624) * 56;
+acc += Math.sin(49624) + Math.cos(49625) * 57;
+acc += Math.sin(49625) + Math.cos(49626) * 58;
+acc += Math.sin(49626) + Math.cos(49627) * 59;
+acc += Math.sin(49627) + Math.cos(49628) * 60;
+acc += Math.sin(49628) + Math.cos(49629) * 61;
+acc += Math.sin(49629) + Math.cos(49630) * 62;
+acc += Math.sin(49630) + Math.cos(49631) * 63;
+acc += Math.sin(49631) + Math.cos(49632) * 64;
+acc += Math.sin(49632) + Math.cos(49633) * 65;
+acc += Math.sin(49633) + Math.cos(49634) * 66;
+acc += Math.sin(49634) + Math.cos(49635) * 67;
+acc += Math.sin(49635) + Math.cos(49636) * 68;
+acc += Math.sin(49636) + Math.cos(49637) * 69;
+acc += Math.sin(49637) + Math.cos(49638) * 70;
+acc += Math.sin(49638) + Math.cos(49639) * 71;
+acc += Math.sin(49639) + Math.cos(49640) * 72;
+acc += Math.sin(49640) + Math.cos(49641) * 73;
+acc += Math.sin(49641) + Math.cos(49642) * 74;
+acc += Math.sin(49642) + Math.cos(49643) * 75;
+acc += Math.sin(49643) + Math.cos(49644) * 76;
+acc += Math.sin(49644) + Math.cos(49645) * 77;
+acc += Math.sin(49645) + Math.cos(49646) * 78;
+acc += Math.sin(49646) + Math.cos(49647) * 79;
+acc += Math.sin(49647) + Math.cos(49648) * 80;
+acc += Math.sin(49648) + Math.cos(49649) * 81;
+acc += Math.sin(49649) + Math.cos(49650) * 82;
+acc += Math.sin(49650) + Math.cos(49651) * 83;
+acc += Math.sin(49651) + Math.cos(49652) * 84;
+acc += Math.sin(49652) + Math.cos(49653) * 85;
+acc += Math.sin(49653) + Math.cos(49654) * 86;
+acc += Math.sin(49654) + Math.cos(49655) * 87;
+acc += Math.sin(49655) + Math.cos(49656) * 88;
+acc += Math.sin(49656) + Math.cos(49657) * 89;
+acc += Math.sin(49657) + Math.cos(49658) * 90;
+acc += Math.sin(49658) + Math.cos(49659) * 91;
+acc += Math.sin(49659) + Math.cos(49660) * 92;
+acc += Math.sin(49660) + Math.cos(49661) * 93;
+acc += Math.sin(49661) + Math.cos(49662) * 94;
+acc += Math.sin(49662) + Math.cos(49663) * 95;
+acc += Math.sin(49663) + Math.cos(49664) * 96;
+acc += Math.sin(49664) + Math.cos(49665) * 0;
+acc += Math.sin(49665) + Math.cos(49666) * 1;
+acc += Math.sin(49666) + Math.cos(49667) * 2;
+acc += Math.sin(49667) + Math.cos(49668) * 3;
+acc += Math.sin(49668) + Math.cos(49669) * 4;
+acc += Math.sin(49669) + Math.cos(49670) * 5;
+acc += Math.sin(49670) + Math.cos(49671) * 6;
+acc += Math.sin(49671) + Math.cos(49672) * 7;
+acc += Math.sin(49672) + Math.cos(49673) * 8;
+acc += Math.sin(49673) + Math.cos(49674) * 9;
+acc += Math.sin(49674) + Math.cos(49675) * 10;
+acc += Math.sin(49675) + Math.cos(49676) * 11;
+acc += Math.sin(49676) + Math.cos(49677) * 12;
+acc += Math.sin(49677) + Math.cos(49678) * 13;
+acc += Math.sin(49678) + Math.cos(49679) * 14;
+acc += Math.sin(49679) + Math.cos(49680) * 15;
+acc += Math.sin(49680) + Math.cos(49681) * 16;
+acc += Math.sin(49681) + Math.cos(49682) * 17;
+acc += Math.sin(49682) + Math.cos(49683) * 18;
+acc += Math.sin(49683) + Math.cos(49684) * 19;
+acc += Math.sin(49684) + Math.cos(49685) * 20;
+acc += Math.sin(49685) + Math.cos(49686) * 21;
+acc += Math.sin(49686) + Math.cos(49687) * 22;
+acc += Math.sin(49687) + Math.cos(49688) * 23;
+acc += Math.sin(49688) + Math.cos(49689) * 24;
+acc += Math.sin(49689) + Math.cos(49690) * 25;
+acc += Math.sin(49690) + Math.cos(49691) * 26;
+acc += Math.sin(49691) + Math.cos(49692) * 27;
+acc += Math.sin(49692) + Math.cos(49693) * 28;
+acc += Math.sin(49693) + Math.cos(49694) * 29;
+acc += Math.sin(49694) + Math.cos(49695) * 30;
+acc += Math.sin(49695) + Math.cos(49696) * 31;
+acc += Math.sin(49696) + Math.cos(49697) * 32;
+acc += Math.sin(49697) + Math.cos(49698) * 33;
+acc += Math.sin(49698) + Math.cos(49699) * 34;
+acc += Math.sin(49699) + Math.cos(49700) * 35;
+acc += Math.sin(49700) + Math.cos(49701) * 36;
+acc += Math.sin(49701) + Math.cos(49702) * 37;
+acc += Math.sin(49702) + Math.cos(49703) * 38;
+acc += Math.sin(49703) + Math.cos(49704) * 39;
+acc += Math.sin(49704) + Math.cos(49705) * 40;
+acc += Math.sin(49705) + Math.cos(49706) * 41;
+acc += Math.sin(49706) + Math.cos(49707) * 42;
+acc += Math.sin(49707) + Math.cos(49708) * 43;
+acc += Math.sin(49708) + Math.cos(49709) * 44;
+acc += Math.sin(49709) + Math.cos(49710) * 45;
+acc += Math.sin(49710) + Math.cos(49711) * 46;
+acc += Math.sin(49711) + Math.cos(49712) * 47;
+acc += Math.sin(49712) + Math.cos(49713) * 48;
+acc += Math.sin(49713) + Math.cos(49714) * 49;
+acc += Math.sin(49714) + Math.cos(49715) * 50;
+acc += Math.sin(49715) + Math.cos(49716) * 51;
+acc += Math.sin(49716) + Math.cos(49717) * 52;
+acc += Math.sin(49717) + Math.cos(49718) * 53;
+acc += Math.sin(49718) + Math.cos(49719) * 54;
+acc += Math.sin(49719) + Math.cos(49720) * 55;
+acc += Math.sin(49720) + Math.cos(49721) * 56;
+acc += Math.sin(49721) + Math.cos(49722) * 57;
+acc += Math.sin(49722) + Math.cos(49723) * 58;
+acc += Math.sin(49723) + Math.cos(49724) * 59;
+acc += Math.sin(49724) + Math.cos(49725) * 60;
+acc += Math.sin(49725) + Math.cos(49726) * 61;
+acc += Math.sin(49726) + Math.cos(49727) * 62;
+acc += Math.sin(49727) + Math.cos(49728) * 63;
+acc += Math.sin(49728) + Math.cos(49729) * 64;
+acc += Math.sin(49729) + Math.cos(49730) * 65;
+acc += Math.sin(49730) + Math.cos(49731) * 66;
+acc += Math.sin(49731) + Math.cos(49732) * 67;
+acc += Math.sin(49732) + Math.cos(49733) * 68;
+acc += Math.sin(49733) + Math.cos(49734) * 69;
+acc += Math.sin(49734) + Math.cos(49735) * 70;
+acc += Math.sin(49735) + Math.cos(49736) * 71;
+acc += Math.sin(49736) + Math.cos(49737) * 72;
+acc += Math.sin(49737) + Math.cos(49738) * 73;
+acc += Math.sin(49738) + Math.cos(49739) * 74;
+acc += Math.sin(49739) + Math.cos(49740) * 75;
+acc += Math.sin(49740) + Math.cos(49741) * 76;
+acc += Math.sin(49741) + Math.cos(49742) * 77;
+acc += Math.sin(49742) + Math.cos(49743) * 78;
+acc += Math.sin(49743) + Math.cos(49744) * 79;
+acc += Math.sin(49744) + Math.cos(49745) * 80;
+acc += Math.sin(49745) + Math.cos(49746) * 81;
+acc += Math.sin(49746) + Math.cos(49747) * 82;
+acc += Math.sin(49747) + Math.cos(49748) * 83;
+acc += Math.sin(49748) + Math.cos(49749) * 84;
+acc += Math.sin(49749) + Math.cos(49750) * 85;
+acc += Math.sin(49750) + Math.cos(49751) * 86;
+acc += Math.sin(49751) + Math.cos(49752) * 87;
+acc += Math.sin(49752) + Math.cos(49753) * 88;
+acc += Math.sin(49753) + Math.cos(49754) * 89;
+acc += Math.sin(49754) + Math.cos(49755) * 90;
+acc += Math.sin(49755) + Math.cos(49756) * 91;
+acc += Math.sin(49756) + Math.cos(49757) * 92;
+acc += Math.sin(49757) + Math.cos(49758) * 93;
+acc += Math.sin(49758) + Math.cos(49759) * 94;
+acc += Math.sin(49759) + Math.cos(49760) * 95;
+acc += Math.sin(49760) + Math.cos(49761) * 96;
+acc += Math.sin(49761) + Math.cos(49762) * 0;
+acc += Math.sin(49762) + Math.cos(49763) * 1;
+acc += Math.sin(49763) + Math.cos(49764) * 2;
+acc += Math.sin(49764) + Math.cos(49765) * 3;
+acc += Math.sin(49765) + Math.cos(49766) * 4;
+acc += Math.sin(49766) + Math.cos(49767) * 5;
+acc += Math.sin(49767) + Math.cos(49768) * 6;
+acc += Math.sin(49768) + Math.cos(49769) * 7;
+acc += Math.sin(49769) + Math.cos(49770) * 8;
+acc += Math.sin(49770) + Math.cos(49771) * 9;
+acc += Math.sin(49771) + Math.cos(49772) * 10;
+acc += Math.sin(49772) + Math.cos(49773) * 11;
+acc += Math.sin(49773) + Math.cos(49774) * 12;
+acc += Math.sin(49774) + Math.cos(49775) * 13;
+acc += Math.sin(49775) + Math.cos(49776) * 14;
+acc += Math.sin(49776) + Math.cos(49777) * 15;
+acc += Math.sin(49777) + Math.cos(49778) * 16;
+acc += Math.sin(49778) + Math.cos(49779) * 17;
+acc += Math.sin(49779) + Math.cos(49780) * 18;
+acc += Math.sin(49780) + Math.cos(49781) * 19;
+acc += Math.sin(49781) + Math.cos(49782) * 20;
+acc += Math.sin(49782) + Math.cos(49783) * 21;
+acc += Math.sin(49783) + Math.cos(49784) * 22;
+acc += Math.sin(49784) + Math.cos(49785) * 23;
+acc += Math.sin(49785) + Math.cos(49786) * 24;
+acc += Math.sin(49786) + Math.cos(49787) * 25;
+acc += Math.sin(49787) + Math.cos(49788) * 26;
+acc += Math.sin(49788) + Math.cos(49789) * 27;
+acc += Math.sin(49789) + Math.cos(49790) * 28;
+acc += Math.sin(49790) + Math.cos(49791) * 29;
+acc += Math.sin(49791) + Math.cos(49792) * 30;
+acc += Math.sin(49792) + Math.cos(49793) * 31;
+acc += Math.sin(49793) + Math.cos(49794) * 32;
+acc += Math.sin(49794) + Math.cos(49795) * 33;
+acc += Math.sin(49795) + Math.cos(49796) * 34;
+acc += Math.sin(49796) + Math.cos(49797) * 35;
+acc += Math.sin(49797) + Math.cos(49798) * 36;
+acc += Math.sin(49798) + Math.cos(49799) * 37;
+acc += Math.sin(49799) + Math.cos(49800) * 38;
+acc += Math.sin(49800) + Math.cos(49801) * 39;
+acc += Math.sin(49801) + Math.cos(49802) * 40;
+acc += Math.sin(49802) + Math.cos(49803) * 41;
+acc += Math.sin(49803) + Math.cos(49804) * 42;
+acc += Math.sin(49804) + Math.cos(49805) * 43;
+acc += Math.sin(49805) + Math.cos(49806) * 44;
+acc += Math.sin(49806) + Math.cos(49807) * 45;
+acc += Math.sin(49807) + Math.cos(49808) * 46;
+acc += Math.sin(49808) + Math.cos(49809) * 47;
+acc += Math.sin(49809) + Math.cos(49810) * 48;
+acc += Math.sin(49810) + Math.cos(49811) * 49;
+acc += Math.sin(49811) + Math.cos(49812) * 50;
+acc += Math.sin(49812) + Math.cos(49813) * 51;
+acc += Math.sin(49813) + Math.cos(49814) * 52;
+acc += Math.sin(49814) + Math.cos(49815) * 53;
+acc += Math.sin(49815) + Math.cos(49816) * 54;
+acc += Math.sin(49816) + Math.cos(49817) * 55;
+acc += Math.sin(49817) + Math.cos(49818) * 56;
+acc += Math.sin(49818) + Math.cos(49819) * 57;
+acc += Math.sin(49819) + Math.cos(49820) * 58;
+acc += Math.sin(49820) + Math.cos(49821) * 59;
+acc += Math.sin(49821) + Math.cos(49822) * 60;
+acc += Math.sin(49822) + Math.cos(49823) * 61;
+acc += Math.sin(49823) + Math.cos(49824) * 62;
+acc += Math.sin(49824) + Math.cos(49825) * 63;
+acc += Math.sin(49825) + Math.cos(49826) * 64;
+acc += Math.sin(49826) + Math.cos(49827) * 65;
+acc += Math.sin(49827) + Math.cos(49828) * 66;
+acc += Math.sin(49828) + Math.cos(49829) * 67;
+acc += Math.sin(49829) + Math.cos(49830) * 68;
+acc += Math.sin(49830) + Math.cos(49831) * 69;
+acc += Math.sin(49831) + Math.cos(49832) * 70;
+acc += Math.sin(49832) + Math.cos(49833) * 71;
+acc += Math.sin(49833) + Math.cos(49834) * 72;
+acc += Math.sin(49834) + Math.cos(49835) * 73;
+acc += Math.sin(49835) + Math.cos(49836) * 74;
+acc += Math.sin(49836) + Math.cos(49837) * 75;
+acc += Math.sin(49837) + Math.cos(49838) * 76;
+acc += Math.sin(49838) + Math.cos(49839) * 77;
+acc += Math.sin(49839) + Math.cos(49840) * 78;
+acc += Math.sin(49840) + Math.cos(49841) * 79;
+acc += Math.sin(49841) + Math.cos(49842) * 80;
+acc += Math.sin(49842) + Math.cos(49843) * 81;
+acc += Math.sin(49843) + Math.cos(49844) * 82;
+acc += Math.sin(49844) + Math.cos(49845) * 83;
+acc += Math.sin(49845) + Math.cos(49846) * 84;
+acc += Math.sin(49846) + Math.cos(49847) * 85;
+acc += Math.sin(49847) + Math.cos(49848) * 86;
+acc += Math.sin(49848) + Math.cos(49849) * 87;
+acc += Math.sin(49849) + Math.cos(49850) * 88;
+acc += Math.sin(49850) + Math.cos(49851) * 89;
+acc += Math.sin(49851) + Math.cos(49852) * 90;
+acc += Math.sin(49852) + Math.cos(49853) * 91;
+acc += Math.sin(49853) + Math.cos(49854) * 92;
+acc += Math.sin(49854) + Math.cos(49855) * 93;
+acc += Math.sin(49855) + Math.cos(49856) * 94;
+acc += Math.sin(49856) + Math.cos(49857) * 95;
+acc += Math.sin(49857) + Math.cos(49858) * 96;
+acc += Math.sin(49858) + Math.cos(49859) * 0;
+acc += Math.sin(49859) + Math.cos(49860) * 1;
+acc += Math.sin(49860) + Math.cos(49861) * 2;
+acc += Math.sin(49861) + Math.cos(49862) * 3;
+acc += Math.sin(49862) + Math.cos(49863) * 4;
+acc += Math.sin(49863) + Math.cos(49864) * 5;
+acc += Math.sin(49864) + Math.cos(49865) * 6;
+acc += Math.sin(49865) + Math.cos(49866) * 7;
+acc += Math.sin(49866) + Math.cos(49867) * 8;
+acc += Math.sin(49867) + Math.cos(49868) * 9;
+acc += Math.sin(49868) + Math.cos(49869) * 10;
+acc += Math.sin(49869) + Math.cos(49870) * 11;
+acc += Math.sin(49870) + Math.cos(49871) * 12;
+acc += Math.sin(49871) + Math.cos(49872) * 13;
+acc += Math.sin(49872) + Math.cos(49873) * 14;
+acc += Math.sin(49873) + Math.cos(49874) * 15;
+acc += Math.sin(49874) + Math.cos(49875) * 16;
+acc += Math.sin(49875) + Math.cos(49876) * 17;
+acc += Math.sin(49876) + Math.cos(49877) * 18;
+acc += Math.sin(49877) + Math.cos(49878) * 19;
+acc += Math.sin(49878) + Math.cos(49879) * 20;
+acc += Math.sin(49879) + Math.cos(49880) * 21;
+acc += Math.sin(49880) + Math.cos(49881) * 22;
+acc += Math.sin(49881) + Math.cos(49882) * 23;
+acc += Math.sin(49882) + Math.cos(49883) * 24;
+acc += Math.sin(49883) + Math.cos(49884) * 25;
+acc += Math.sin(49884) + Math.cos(49885) * 26;
+acc += Math.sin(49885) + Math.cos(49886) * 27;
+acc += Math.sin(49886) + Math.cos(49887) * 28;
+acc += Math.sin(49887) + Math.cos(49888) * 29;
+acc += Math.sin(49888) + Math.cos(49889) * 30;
+acc += Math.sin(49889) + Math.cos(49890) * 31;
+acc += Math.sin(49890) + Math.cos(49891) * 32;
+acc += Math.sin(49891) + Math.cos(49892) * 33;
+acc += Math.sin(49892) + Math.cos(49893) * 34;
+acc += Math.sin(49893) + Math.cos(49894) * 35;
+acc += Math.sin(49894) + Math.cos(49895) * 36;
+acc += Math.sin(49895) + Math.cos(49896) * 37;
+acc += Math.sin(49896) + Math.cos(49897) * 38;
+acc += Math.sin(49897) + Math.cos(49898) * 39;
+acc += Math.sin(49898) + Math.cos(49899) * 40;
+acc += Math.sin(49899) + Math.cos(49900) * 41;
+acc += Math.sin(49900) + Math.cos(49901) * 42;
+acc += Math.sin(49901) + Math.cos(49902) * 43;
+acc += Math.sin(49902) + Math.cos(49903) * 44;
+acc += Math.sin(49903) + Math.cos(49904) * 45;
+acc += Math.sin(49904) + Math.cos(49905) * 46;
+acc += Math.sin(49905) + Math.cos(49906) * 47;
+acc += Math.sin(49906) + Math.cos(49907) * 48;
+acc += Math.sin(49907) + Math.cos(49908) * 49;
+acc += Math.sin(49908) + Math.cos(49909) * 50;
+acc += Math.sin(49909) + Math.cos(49910) * 51;
+acc += Math.sin(49910) + Math.cos(49911) * 52;
+acc += Math.sin(49911) + Math.cos(49912) * 53;
+acc += Math.sin(49912) + Math.cos(49913) * 54;
+acc += Math.sin(49913) + Math.cos(49914) * 55;
+acc += Math.sin(49914) + Math.cos(49915) * 56;
+acc += Math.sin(49915) + Math.cos(49916) * 57;
+acc += Math.sin(49916) + Math.cos(49917) * 58;
+acc += Math.sin(49917) + Math.cos(49918) * 59;
+acc += Math.sin(49918) + Math.cos(49919) * 60;
+acc += Math.sin(49919) + Math.cos(49920) * 61;
+acc += Math.sin(49920) + Math.cos(49921) * 62;
+acc += Math.sin(49921) + Math.cos(49922) * 63;
+acc += Math.sin(49922) + Math.cos(49923) * 64;
+acc += Math.sin(49923) + Math.cos(49924) * 65;
+acc += Math.sin(49924) + Math.cos(49925) * 66;
+acc += Math.sin(49925) + Math.cos(49926) * 67;
+acc += Math.sin(49926) + Math.cos(49927) * 68;
+acc += Math.sin(49927) + Math.cos(49928) * 69;
+acc += Math.sin(49928) + Math.cos(49929) * 70;
+acc += Math.sin(49929) + Math.cos(49930) * 71;
+acc += Math.sin(49930) + Math.cos(49931) * 72;
+acc += Math.sin(49931) + Math.cos(49932) * 73;
+acc += Math.sin(49932) + Math.cos(49933) * 74;
+acc += Math.sin(49933) + Math.cos(49934) * 75;
+acc += Math.sin(49934) + Math.cos(49935) * 76;
+acc += Math.sin(49935) + Math.cos(49936) * 77;
+acc += Math.sin(49936) + Math.cos(49937) * 78;
+acc += Math.sin(49937) + Math.cos(49938) * 79;
+acc += Math.sin(49938) + Math.cos(49939) * 80;
+acc += Math.sin(49939) + Math.cos(49940) * 81;
+acc += Math.sin(49940) + Math.cos(49941) * 82;
+acc += Math.sin(49941) + Math.cos(49942) * 83;
+acc += Math.sin(49942) + Math.cos(49943) * 84;
+acc += Math.sin(49943) + Math.cos(49944) * 85;
+acc += Math.sin(49944) + Math.cos(49945) * 86;
+acc += Math.sin(49945) + Math.cos(49946) * 87;
+acc += Math.sin(49946) + Math.cos(49947) * 88;
+acc += Math.sin(49947) + Math.cos(49948) * 89;
+acc += Math.sin(49948) + Math.cos(49949) * 90;
+acc += Math.sin(49949) + Math.cos(49950) * 91;
+acc += Math.sin(49950) + Math.cos(49951) * 92;
+acc += Math.sin(49951) + Math.cos(49952) * 93;
+acc += Math.sin(49952) + Math.cos(49953) * 94;
+acc += Math.sin(49953) + Math.cos(49954) * 95;
+acc += Math.sin(49954) + Math.cos(49955) * 96;
+acc += Math.sin(49955) + Math.cos(49956) * 0;
+acc += Math.sin(49956) + Math.cos(49957) * 1;
+acc += Math.sin(49957) + Math.cos(49958) * 2;
+acc += Math.sin(49958) + Math.cos(49959) * 3;
+acc += Math.sin(49959) + Math.cos(49960) * 4;
+acc += Math.sin(49960) + Math.cos(49961) * 5;
+acc += Math.sin(49961) + Math.cos(49962) * 6;
+acc += Math.sin(49962) + Math.cos(49963) * 7;
+acc += Math.sin(49963) + Math.cos(49964) * 8;
+acc += Math.sin(49964) + Math.cos(49965) * 9;
+acc += Math.sin(49965) + Math.cos(49966) * 10;
+acc += Math.sin(49966) + Math.cos(49967) * 11;
+acc += Math.sin(49967) + Math.cos(49968) * 12;
+acc += Math.sin(49968) + Math.cos(49969) * 13;
+acc += Math.sin(49969) + Math.cos(49970) * 14;
+acc += Math.sin(49970) + Math.cos(49971) * 15;
+acc += Math.sin(49971) + Math.cos(49972) * 16;
+acc += Math.sin(49972) + Math.cos(49973) * 17;
+acc += Math.sin(49973) + Math.cos(49974) * 18;
+acc += Math.sin(49974) + Math.cos(49975) * 19;
+acc += Math.sin(49975) + Math.cos(49976) * 20;
+acc += Math.sin(49976) + Math.cos(49977) * 21;
+acc += Math.sin(49977) + Math.cos(49978) * 22;
+acc += Math.sin(49978) + Math.cos(49979) * 23;
+acc += Math.sin(49979) + Math.cos(49980) * 24;
+acc += Math.sin(49980) + Math.cos(49981) * 25;
+acc += Math.sin(49981) + Math.cos(49982) * 26;
+acc += Math.sin(49982) + Math.cos(49983) * 27;
+acc += Math.sin(49983) + Math.cos(49984) * 28;
+acc += Math.sin(49984) + Math.cos(49985) * 29;
+acc += Math.sin(49985) + Math.cos(49986) * 30;
+acc += Math.sin(49986) + Math.cos(49987) * 31;
+acc += Math.sin(49987) + Math.cos(49988) * 32;
+acc += Math.sin(49988) + Math.cos(49989) * 33;
+acc += Math.sin(49989) + Math.cos(49990) * 34;
+acc += Math.sin(49990) + Math.cos(49991) * 35;
+acc += Math.sin(49991) + Math.cos(49992) * 36;
+acc += Math.sin(49992) + Math.cos(49993) * 37;
+acc += Math.sin(49993) + Math.cos(49994) * 38;
+acc += Math.sin(49994) + Math.cos(49995) * 39;
+acc += Math.sin(49995) + Math.cos(49996) * 40;
+acc += Math.sin(49996) + Math.cos(49997) * 41;
+acc += Math.sin(49997) + Math.cos(49998) * 42;
+acc += Math.sin(49998) + Math.cos(49999) * 43;
+acc += Math.sin(49999) + Math.cos(50000) * 44;
+if (acc === 0) throw new Error("unreachable");
diff --git a/test/js/node/test/fixtures/wpt/LICENSE.md b/test/js/node/test/fixtures/wpt/LICENSE.md
new file mode 100644
index 000000000000..39c46d03ac29
--- /dev/null
+++ b/test/js/node/test/fixtures/wpt/LICENSE.md
@@ -0,0 +1,11 @@
+# The 3-Clause BSD License
+
+Copyright © web-platform-tests contributors
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/test/js/node/test/fixtures/wpt/README.md b/test/js/node/test/fixtures/wpt/README.md
new file mode 100644
index 000000000000..70301e54da3e
--- /dev/null
+++ b/test/js/node/test/fixtures/wpt/README.md
@@ -0,0 +1,11 @@
+# Web Platform Test Fixtures
+
+The files in this folder are a subset of the [Web Platform Tests][] fixtures
+vendored by Node.js in `test/fixtures/wpt`, copied verbatim for the vendored
+Node.js test suite in `test/js/node/test`.
+
+Last update:
+
+- url/resources: https://github.com/web-platform-tests/wpt/tree/9504a83e01/url/resources
+
+[Web Platform Tests]: https://github.com/web-platform-tests/wpt
diff --git a/test/js/node/test/fixtures/wpt/url/resources/toascii.json b/test/js/node/test/fixtures/wpt/url/resources/toascii.json
new file mode 100644
index 000000000000..588ef150f9ce
--- /dev/null
+++ b/test/js/node/test/fixtures/wpt/url/resources/toascii.json
@@ -0,0 +1,378 @@
+[
+  "This contains assorted IDNA tests that IdnaTestV2 might not cover.",
+  "Feel free to deduplicate with a clear commit message.",
+  "",
+  "If the test only applies to the URL Standard's 'domain to ASCII', ",
+  "and not to TR46's ToASCII, then tag it with `urlStandardOnly`",
+  {
+    "comment": "Label with hyphens in 3rd and 4th position",
+    "input": "aa--",
+    "output": "aa--"
+  },
+  {
+    "input": "a†--",
+    "output": "xn--a---kp0a"
+  },
+  {
+    "input": "ab--c",
+    "output": "ab--c"
+  },
+  {
+    "comment": "Label with leading hyphen",
+    "input": "-x",
+    "output": "-x"
+  },
+  {
+    "input": "-†",
+    "output": "xn----xhn"
+  },
+  {
+    "input": "-x.xn--zca",
+    "output": "-x.xn--zca"
+  },
+  {
+    "input": "-x.ß",
+    "output": "-x.xn--zca"
+  },
+  {
+    "comment": "Label with trailing hyphen",
+    "input": "x-.xn--zca",
+    "output": "x-.xn--zca"
+  },
+  {
+    "input": "x-.ß",
+    "output": "x-.xn--zca"
+  },
+  {
+    "comment": "Empty labels",
+    "input": "x..xn--zca",
+    "output": "x..xn--zca"
+  },
+  {
+    "input": "x..ß",
+    "output": "x..xn--zca"
+  },
+  {
+    "comment": "Invalid Punycode",
+    "input": "xn--a",
+    "output": null
+  },
+  {
+    "input": "xn--a.xn--zca",
+    "output": null
+  },
+  {
+    "input": "xn--a.ß",
+    "output": null
+  },
+  {
+    "input": "xn--ls8h=",
+    "output": null
+  },
+  {
+    "comment": "Invalid Punycode (contains non-ASCII character)",
+    "input": "xn--tešla",
+    "output": null
+  },
+  {
+    "comment": "Valid Punycode",
+    "input": "xn--zca.xn--zca",
+    "output": "xn--zca.xn--zca"
+  },
+  {
+    "comment": "Mixed",
+    "input": "xn--zca.ß",
+    "output": "xn--zca.xn--zca"
+  },
+  {
+    "input": "ab--c.xn--zca",
+    "output": "ab--c.xn--zca"
+  },
+  {
+    "input": "ab--c.ß",
+    "output": "ab--c.xn--zca"
+  },
+  {
+    "comment": "CheckJoiners is true",
+    "input": "\u200D.example",
+    "output": null
+  },
+  {
+    "input": "xn--1ug.example",
+    "output": null
+  },
+  {
+    "comment": "CheckBidi is true",
+    "input": "يa",
+    "output": null
+  },
+  {
+    "input": "xn--a-yoc",
+    "output": null
+  },
+  {
+    "comment": "processing_option is Nontransitional_Processing",
+    "input": "ශ්‍රී",
+    "output": "xn--10cl1a0b660p"
+  },
+  {
+    "input": "نامه‌ای",
+    "output": "xn--mgba3gch31f060k"
+  },
+  {
+    "comment": "U+FFFD",
+    "input": "\uFFFD.com",
+    "output": null
+  },
+  {
+    "comment": "U+FFFD character encoded in Punycode",
+    "input": "xn--zn7c.com",
+    "output": null
+  },
+  {
+    "comment": "Label longer than 63 code points",
+    "input": "x01234567890123456789012345678901234567890123456789012345678901x",
+    "output": "x01234567890123456789012345678901234567890123456789012345678901x"
+  },
+  {
+    "input": "x01234567890123456789012345678901234567890123456789012345678901†",
+    "output": "xn--x01234567890123456789012345678901234567890123456789012345678901-6963b"
+  },
+  {
+    "input": "x01234567890123456789012345678901234567890123456789012345678901x.xn--zca",
+    "output": "x01234567890123456789012345678901234567890123456789012345678901x.xn--zca"
+  },
+  {
+    "input": "x01234567890123456789012345678901234567890123456789012345678901x.ß",
+    "output": "x01234567890123456789012345678901234567890123456789012345678901x.xn--zca"
+  },
+  {
+    "comment": "Domain excluding TLD longer than 253 code points",
+    "input": "01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.0123456789012345678901234567890123456789012345678.x",
+    "output": "01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.0123456789012345678901234567890123456789012345678.x"
+  },
+  {
+    "input": "01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.0123456789012345678901234567890123456789012345678.xn--zca",
+    "output": "01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.0123456789012345678901234567890123456789012345678.xn--zca"
+  },
+  {
+    "input": "01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.0123456789012345678901234567890123456789012345678.ß",
+    "output": "01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.01234567890123456789012345678901234567890123456789.0123456789012345678901234567890123456789012345678.xn--zca"
+  },
+  {
+    "comment": "IDNA ignored code points",
+    "input": "a\u00ADb",
+    "output": "ab"
+  },
+  {
+    "comment": "Interesting UseSTD3ASCIIRules=false cases",
+    "input": "≠",
+    "output": "xn--1ch"
+  },
+  {
+    "input": "≮",
+    "output": "xn--gdh"
+  },
+  {
+    "input": "≯",
+    "output": "xn--hdh"
+  },
+  {
+    "comment": "NFC normalization (forbidden < and > characters are normalized to valid ones)",
+    "input": "=\u0338",
+    "output": "xn--1ch"
+  },
+  {
+    "input": "<\u0338",
+    "output": "xn--gdh"
+  },
+  {
+    "input": ">\u0338",
+    "output": "xn--hdh"
+  },
+  {
+    "comment": "Same with inserted IDNA ignored code point",
+    "input": "=\u00AD\u0338",
+    "output": "xn--1ch"
+  },
+  {
+    "input": "<\u00AD\u0338",
+    "output": "xn--gdh"
+  },
+  {
+    "input": ">\u00AD\u0338",
+    "output": "xn--hdh"
+  },
+  "Tests below are from WebKit (fast/url/idna2003.html & fast/url/idna2008.html; contributed by Chris Weber back in 2011).",
+  {
+    "input": "fa\u00DF.de",
+    "output": "xn--fa-hia.de"
+  },
+  {
+    "input": "\u03B2\u03CC\u03BB\u03BF\u03C2.com",
+    "output": "xn--nxasmm1c.com"
+  },
+  {
+    "input": "\u0DC1\u0DCA\u200D\u0DBB\u0DD3.com",
+    "output": "xn--10cl1a0b660p.com"
+  },
+  {
+    "input": "\u0646\u0627\u0645\u0647\u200C\u0627\u06CC.com",
+    "output": "xn--mgba3gch31f060k.com"
+  },
+  {
+    "input": "www.loo\u0138out.net",
+    "output": "www.xn--looout-5bb.net"
+  },
+  {
+    "input": "\u15EF\u15EF\u15EF.lookout.net",
+    "output": "xn--1qeaa.lookout.net"
+  },
+  {
+    "input": "www.lookout.\u0441\u043E\u043C",
+    "output": "www.lookout.xn--l1adi"
+  },
+  {
+    "input": "www\u2025lookout.net",
+    "output": null
+  },
+  {
+    "input": "www.lookout\u2027net",
+    "output": "www.xn--lookoutnet-406e"
+  },
+  {
+    "input": "www.lookout.net\u2A7480",
+    "output": null,
+    "urlStandardOnly": true
+  },
+  {
+    "input": "www\u00A0.lookout.net",
+    "output": null,
+    "urlStandardOnly": true
+  },
+  {
+    "input": "\u1680lookout.net",
+    "output": null
+  },
+  {
+    "input": "\u001flookout.net",
+    "output": null,
+    "urlStandardOnly": true
+  },
+  {
+    "input": "look\u06DDout.net",
+    "output": null
+  },
+  {
+    "input": "look\u180Eout.net",
+    "output": "lookout.net"
+  },
+  {
+    "input": "look\u2060out.net",
+    "output": "lookout.net"
+  },
+  {
+    "input": "look\uFEFFout.net",
+    "output": "lookout.net"
+  },
+  {
+    "input": "look\uD83F\uDFFEout.net",
+    "output": null
+  },
+  {
+    "input": "look\uFFFAout.net",
+    "output": null
+  },
+  {
+    "input": "look\u2FF0out.net",
+    "output": null
+  },
+  {
+    "input": "look\u0341out.net",
+    "output": "xn--looout-kp7b.net"
+  },
+  {
+    "input": "look\u202Eout.net",
+    "output": null
+  },
+  {
+    "input": "look\u206Bout.net",
+    "output": "lookout.net"
+  },
+  {
+    "input": "look\uDB40\uDC01out.net",
+    "output": null
+  },
+  {
+    "input": "look\uDB40\uDC20out.net",
+    "output": null
+  },
+  {
+    "input": "look\u05BEout.net",
+    "output": null
+  },
+  {
+    "input": "B\u00FCcher.de",
+    "output": "xn--bcher-kva.de"
+  },
+  {
+    "input": "\u2665.net",
+    "output": "xn--g6h.net"
+  },
+  {
+    "input": "\u0378.net",
+    "output": null
+  },
+  {
+    "input": "\u04C0.com",
+    "output": "xn--s5a.com"
+  },
+  {
+    "input": "\uD87E\uDC68.com",
+    "output": "xn--snl.com"
+  },
+  {
+    "input": "\u2183.com",
+    "output": "xn--r5g.com"
+  },
+  {
+    "input": "look\u034Fout.net",
+    "output": "lookout.net"
+  },
+  {
+    "input": "gOoGle.com",
+    "output": "google.com"
+  },
+  {
+    "input": "\u09dc.com",
+    "output": "xn--15b8c.com"
+  },
+  {
+    "input": "\u1E9E.com",
+    "output": "xn--zca.com"
+  },
+  {
+    "input": "\u1E9E.foo.com",
+    "output": "xn--zca.foo.com"
+  },
+  {
+    "input": "-foo.bar.com",
+    "output": "-foo.bar.com"
+  },
+  {
+    "input": "foo-.bar.com",
+    "output": "foo-.bar.com"
+  },
+  {
+    "input": "ab--cd.com",
+    "output": "ab--cd.com"
+  },
+  {
+    "input": "xn--0.com",
+    "output": null
+  },
+  {
+    "input": "foo\u0300.bar.com",
+    "output": "xn--fo-3ja.bar.com"
+  }
+]
diff --git a/test/js/node/test/fixtures/wpt/url/resources/urltestdata.json b/test/js/node/test/fixtures/wpt/url/resources/urltestdata.json
new file mode 100644
index 000000000000..d1a06f6319d1
--- /dev/null
+++ b/test/js/node/test/fixtures/wpt/url/resources/urltestdata.json
@@ -0,0 +1,10242 @@
+[
+  "See ../README.md for a description of the format.",
+  {
+    "input": "http://example\t.\norg",
+    "base": "http://example.org/foo/bar",
+    "href": "http://example.org/",
+    "origin": "http://example.org",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://user:pass@foo:21/bar;par?b#c",
+    "base": "http://example.org/foo/bar",
+    "href": "http://user:pass@foo:21/bar;par?b#c",
+    "origin": "http://foo:21",
+    "protocol": "http:",
+    "username": "user",
+    "password": "pass",
+    "host": "foo:21",
+    "hostname": "foo",
+    "port": "21",
+    "pathname": "/bar;par",
+    "search": "?b",
+    "hash": "#c"
+  },
+  {
+    "input": "https://test:@test",
+    "base": null,
+    "href": "https://test@test/",
+    "origin": "https://test",
+    "protocol": "https:",
+    "username": "test",
+    "password": "",
+    "host": "test",
+    "hostname": "test",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "https://:@test",
+    "base": null,
+    "href": "https://test/",
+    "origin": "https://test",
+    "protocol": "https:",
+    "username": "",
+    "password": "",
+    "host": "test",
+    "hostname": "test",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "non-special://test:@test/x",
+    "base": null,
+    "href": "non-special://test@test/x",
+    "origin": "null",
+    "protocol": "non-special:",
+    "username": "test",
+    "password": "",
+    "host": "test",
+    "hostname": "test",
+    "port": "",
+    "pathname": "/x",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "non-special://:@test/x",
+    "base": null,
+    "href": "non-special://test/x",
+    "origin": "null",
+    "protocol": "non-special:",
+    "username": "",
+    "password": "",
+    "host": "test",
+    "hostname": "test",
+    "port": "",
+    "pathname": "/x",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http:foo.com",
+    "base": "http://example.org/foo/bar",
+    "href": "http://example.org/foo/foo.com",
+    "origin": "http://example.org",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/foo/foo.com",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "\t   :foo.com   \n",
+    "base": "http://example.org/foo/bar",
+    "href": "http://example.org/foo/:foo.com",
+    "origin": "http://example.org",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/foo/:foo.com",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": " foo.com  ",
+    "base": "http://example.org/foo/bar",
+    "href": "http://example.org/foo/foo.com",
+    "origin": "http://example.org",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/foo/foo.com",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "a:\t foo.com",
+    "base": "http://example.org/foo/bar",
+    "href": "a: foo.com",
+    "origin": "null",
+    "protocol": "a:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": " foo.com",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://f:21/ b ? d # e ",
+    "base": "http://example.org/foo/bar",
+    "href": "http://f:21/%20b%20?%20d%20#%20e",
+    "origin": "http://f:21",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "f:21",
+    "hostname": "f",
+    "port": "21",
+    "pathname": "/%20b%20",
+    "search": "?%20d%20",
+    "hash": "#%20e"
+  },
+  {
+    "input": "lolscheme:x x#x x",
+    "base": null,
+    "href": "lolscheme:x x#x%20x",
+    "protocol": "lolscheme:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "x x",
+    "search": "",
+    "hash": "#x%20x"
+  },
+  {
+    "input": "http://f:/c",
+    "base": "http://example.org/foo/bar",
+    "href": "http://f/c",
+    "origin": "http://f",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "f",
+    "hostname": "f",
+    "port": "",
+    "pathname": "/c",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://f:0/c",
+    "base": "http://example.org/foo/bar",
+    "href": "http://f:0/c",
+    "origin": "http://f:0",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "f:0",
+    "hostname": "f",
+    "port": "0",
+    "pathname": "/c",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://f:00000000000000/c",
+    "base": "http://example.org/foo/bar",
+    "href": "http://f:0/c",
+    "origin": "http://f:0",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "f:0",
+    "hostname": "f",
+    "port": "0",
+    "pathname": "/c",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://f:00000000000000000000080/c",
+    "base": "http://example.org/foo/bar",
+    "href": "http://f/c",
+    "origin": "http://f",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "f",
+    "hostname": "f",
+    "port": "",
+    "pathname": "/c",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://f:b/c",
+    "base": "http://example.org/foo/bar",
+    "failure": true
+  },
+  {
+    "input": "http://f: /c",
+    "base": "http://example.org/foo/bar",
+    "failure": true
+  },
+  {
+    "input": "http://f:\n/c",
+    "base": "http://example.org/foo/bar",
+    "href": "http://f/c",
+    "origin": "http://f",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "f",
+    "hostname": "f",
+    "port": "",
+    "pathname": "/c",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://f:fifty-two/c",
+    "base": "http://example.org/foo/bar",
+    "failure": true
+  },
+  {
+    "input": "http://f:999999/c",
+    "base": "http://example.org/foo/bar",
+    "failure": true
+  },
+  {
+    "input": "non-special://f:999999/c",
+    "base": "http://example.org/foo/bar",
+    "failure": true
+  },
+  {
+    "input": "http://f: 21 / b ? d # e ",
+    "base": "http://example.org/foo/bar",
+    "failure": true
+  },
+  {
+    "input": "",
+    "base": "http://example.org/foo/bar",
+    "href": "http://example.org/foo/bar",
+    "origin": "http://example.org",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/foo/bar",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "  \t",
+    "base": "http://example.org/foo/bar",
+    "href": "http://example.org/foo/bar",
+    "origin": "http://example.org",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/foo/bar",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": ":foo.com/",
+    "base": "http://example.org/foo/bar",
+    "href": "http://example.org/foo/:foo.com/",
+    "origin": "http://example.org",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/foo/:foo.com/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": ":foo.com\\",
+    "base": "http://example.org/foo/bar",
+    "href": "http://example.org/foo/:foo.com/",
+    "origin": "http://example.org",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/foo/:foo.com/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": ":",
+    "base": "http://example.org/foo/bar",
+    "href": "http://example.org/foo/:",
+    "origin": "http://example.org",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/foo/:",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": ":a",
+    "base": "http://example.org/foo/bar",
+    "href": "http://example.org/foo/:a",
+    "origin": "http://example.org",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/foo/:a",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": ":/",
+    "base": "http://example.org/foo/bar",
+    "href": "http://example.org/foo/:/",
+    "origin": "http://example.org",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/foo/:/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": ":\\",
+    "base": "http://example.org/foo/bar",
+    "href": "http://example.org/foo/:/",
+    "origin": "http://example.org",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/foo/:/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": ":#",
+    "base": "http://example.org/foo/bar",
+    "href": "http://example.org/foo/:#",
+    "origin": "http://example.org",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/foo/:",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "#",
+    "base": "http://example.org/foo/bar",
+    "href": "http://example.org/foo/bar#",
+    "origin": "http://example.org",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/foo/bar",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "#/",
+    "base": "http://example.org/foo/bar",
+    "href": "http://example.org/foo/bar#/",
+    "origin": "http://example.org",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/foo/bar",
+    "search": "",
+    "hash": "#/"
+  },
+  {
+    "input": "#\\",
+    "base": "http://example.org/foo/bar",
+    "href": "http://example.org/foo/bar#\\",
+    "origin": "http://example.org",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/foo/bar",
+    "search": "",
+    "hash": "#\\"
+  },
+  {
+    "input": "#;?",
+    "base": "http://example.org/foo/bar",
+    "href": "http://example.org/foo/bar#;?",
+    "origin": "http://example.org",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/foo/bar",
+    "search": "",
+    "hash": "#;?"
+  },
+  {
+    "input": "?",
+    "base": "http://example.org/foo/bar",
+    "href": "http://example.org/foo/bar?",
+    "origin": "http://example.org",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/foo/bar",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "/",
+    "base": "http://example.org/foo/bar",
+    "href": "http://example.org/",
+    "origin": "http://example.org",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": ":23",
+    "base": "http://example.org/foo/bar",
+    "href": "http://example.org/foo/:23",
+    "origin": "http://example.org",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/foo/:23",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "/:23",
+    "base": "http://example.org/foo/bar",
+    "href": "http://example.org/:23",
+    "origin": "http://example.org",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/:23",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "\\x",
+    "base": "http://example.org/foo/bar",
+    "href": "http://example.org/x",
+    "origin": "http://example.org",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/x",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "\\\\x\\hello",
+    "base": "http://example.org/foo/bar",
+    "href": "http://x/hello",
+    "origin": "http://x",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "x",
+    "hostname": "x",
+    "port": "",
+    "pathname": "/hello",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "::",
+    "base": "http://example.org/foo/bar",
+    "href": "http://example.org/foo/::",
+    "origin": "http://example.org",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/foo/::",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "::23",
+    "base": "http://example.org/foo/bar",
+    "href": "http://example.org/foo/::23",
+    "origin": "http://example.org",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/foo/::23",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "foo://",
+    "base": "http://example.org/foo/bar",
+    "href": "foo://",
+    "origin": "null",
+    "protocol": "foo:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://a:b@c:29/d",
+    "base": "http://example.org/foo/bar",
+    "href": "http://a:b@c:29/d",
+    "origin": "http://c:29",
+    "protocol": "http:",
+    "username": "a",
+    "password": "b",
+    "host": "c:29",
+    "hostname": "c",
+    "port": "29",
+    "pathname": "/d",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http::@c:29",
+    "base": "http://example.org/foo/bar",
+    "href": "http://example.org/foo/:@c:29",
+    "origin": "http://example.org",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/foo/:@c:29",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://&a:foo(b]c@d:2/",
+    "base": "http://example.org/foo/bar",
+    "href": "http://&a:foo(b%5Dc@d:2/",
+    "origin": "http://d:2",
+    "protocol": "http:",
+    "username": "&a",
+    "password": "foo(b%5Dc",
+    "host": "d:2",
+    "hostname": "d",
+    "port": "2",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://::@c@d:2",
+    "base": "http://example.org/foo/bar",
+    "href": "http://:%3A%40c@d:2/",
+    "origin": "http://d:2",
+    "protocol": "http:",
+    "username": "",
+    "password": "%3A%40c",
+    "host": "d:2",
+    "hostname": "d",
+    "port": "2",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://foo.com:b@d/",
+    "base": "http://example.org/foo/bar",
+    "href": "http://foo.com:b@d/",
+    "origin": "http://d",
+    "protocol": "http:",
+    "username": "foo.com",
+    "password": "b",
+    "host": "d",
+    "hostname": "d",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://foo.com/\\@",
+    "base": "http://example.org/foo/bar",
+    "href": "http://foo.com//@",
+    "origin": "http://foo.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "foo.com",
+    "hostname": "foo.com",
+    "port": "",
+    "pathname": "//@",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http:\\\\foo.com\\",
+    "base": "http://example.org/foo/bar",
+    "href": "http://foo.com/",
+    "origin": "http://foo.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "foo.com",
+    "hostname": "foo.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http:\\\\a\\b:c\\d@foo.com\\",
+    "base": "http://example.org/foo/bar",
+    "href": "http://a/b:c/d@foo.com/",
+    "origin": "http://a",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "a",
+    "hostname": "a",
+    "port": "",
+    "pathname": "/b:c/d@foo.com/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://a:b@c\\",
+    "base": null,
+    "href": "http://a:b@c/",
+    "origin": "http://c",
+    "protocol": "http:",
+    "username": "a",
+    "password": "b",
+    "host": "c",
+    "hostname": "c",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "ws://a@b\\c",
+    "base": null,
+    "href": "ws://a@b/c",
+    "origin": "ws://b",
+    "protocol": "ws:",
+    "username": "a",
+    "password": "",
+    "host": "b",
+    "hostname": "b",
+    "port": "",
+    "pathname": "/c",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "foo:/",
+    "base": "http://example.org/foo/bar",
+    "href": "foo:/",
+    "origin": "null",
+    "protocol": "foo:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "foo:/bar.com/",
+    "base": "http://example.org/foo/bar",
+    "href": "foo:/bar.com/",
+    "origin": "null",
+    "protocol": "foo:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/bar.com/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "foo://///////",
+    "base": "http://example.org/foo/bar",
+    "href": "foo://///////",
+    "origin": "null",
+    "protocol": "foo:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "///////",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "foo://///////bar.com/",
+    "base": "http://example.org/foo/bar",
+    "href": "foo://///////bar.com/",
+    "origin": "null",
+    "protocol": "foo:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "///////bar.com/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "foo:////://///",
+    "base": "http://example.org/foo/bar",
+    "href": "foo:////://///",
+    "origin": "null",
+    "protocol": "foo:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "//://///",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "c:/foo",
+    "base": "http://example.org/foo/bar",
+    "href": "c:/foo",
+    "origin": "null",
+    "protocol": "c:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/foo",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "//foo/bar",
+    "base": "http://example.org/foo/bar",
+    "href": "http://foo/bar",
+    "origin": "http://foo",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "foo",
+    "hostname": "foo",
+    "port": "",
+    "pathname": "/bar",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://foo/path;a??e#f#g",
+    "base": "http://example.org/foo/bar",
+    "href": "http://foo/path;a??e#f#g",
+    "origin": "http://foo",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "foo",
+    "hostname": "foo",
+    "port": "",
+    "pathname": "/path;a",
+    "search": "??e",
+    "hash": "#f#g"
+  },
+  {
+    "input": "http://foo/abcd?efgh?ijkl",
+    "base": "http://example.org/foo/bar",
+    "href": "http://foo/abcd?efgh?ijkl",
+    "origin": "http://foo",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "foo",
+    "hostname": "foo",
+    "port": "",
+    "pathname": "/abcd",
+    "search": "?efgh?ijkl",
+    "hash": ""
+  },
+  {
+    "input": "http://foo/abcd#foo?bar",
+    "base": "http://example.org/foo/bar",
+    "href": "http://foo/abcd#foo?bar",
+    "origin": "http://foo",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "foo",
+    "hostname": "foo",
+    "port": "",
+    "pathname": "/abcd",
+    "search": "",
+    "hash": "#foo?bar"
+  },
+  {
+    "input": "[61:24:74]:98",
+    "base": "http://example.org/foo/bar",
+    "href": "http://example.org/foo/[61:24:74]:98",
+    "origin": "http://example.org",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/foo/[61:24:74]:98",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http:[61:27]/:foo",
+    "base": "http://example.org/foo/bar",
+    "href": "http://example.org/foo/[61:27]/:foo",
+    "origin": "http://example.org",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/foo/[61:27]/:foo",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://[1::2]:3:4",
+    "base": "http://example.org/foo/bar",
+    "failure": true
+  },
+  {
+    "input": "http://2001::1",
+    "base": "http://example.org/foo/bar",
+    "failure": true
+  },
+  {
+    "input": "http://2001::1]",
+    "base": "http://example.org/foo/bar",
+    "failure": true
+  },
+  {
+    "input": "http://2001::1]:80",
+    "base": "http://example.org/foo/bar",
+    "failure": true
+  },
+  {
+    "input": "http://[2001::1]",
+    "base": "http://example.org/foo/bar",
+    "href": "http://[2001::1]/",
+    "origin": "http://[2001::1]",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "[2001::1]",
+    "hostname": "[2001::1]",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://[::127.0.0.1]",
+    "base": "http://example.org/foo/bar",
+    "href": "http://[::7f00:1]/",
+    "origin": "http://[::7f00:1]",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "[::7f00:1]",
+    "hostname": "[::7f00:1]",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://[::127.0.0.1.]",
+    "base": "http://example.org/foo/bar",
+    "failure": true
+  },
+  {
+    "input": "http://[0:0:0:0:0:0:13.1.68.3]",
+    "base": "http://example.org/foo/bar",
+    "href": "http://[::d01:4403]/",
+    "origin": "http://[::d01:4403]",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "[::d01:4403]",
+    "hostname": "[::d01:4403]",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://[2001::1]:80",
+    "base": "http://example.org/foo/bar",
+    "href": "http://[2001::1]/",
+    "origin": "http://[2001::1]",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "[2001::1]",
+    "hostname": "[2001::1]",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http:/example.com/",
+    "base": "http://example.org/foo/bar",
+    "href": "http://example.org/example.com/",
+    "origin": "http://example.org",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/example.com/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "ftp:/example.com/",
+    "base": "http://example.org/foo/bar",
+    "href": "ftp://example.com/",
+    "origin": "ftp://example.com",
+    "protocol": "ftp:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "https:/example.com/",
+    "base": "http://example.org/foo/bar",
+    "href": "https://example.com/",
+    "origin": "https://example.com",
+    "protocol": "https:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "madeupscheme:/example.com/",
+    "base": "http://example.org/foo/bar",
+    "href": "madeupscheme:/example.com/",
+    "origin": "null",
+    "protocol": "madeupscheme:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/example.com/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file:/example.com/",
+    "base": "http://example.org/foo/bar",
+    "href": "file:///example.com/",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/example.com/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file://example:1/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "file://example:test/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "file://example%/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "file://[example]/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "ftps:/example.com/",
+    "base": "http://example.org/foo/bar",
+    "href": "ftps:/example.com/",
+    "origin": "null",
+    "protocol": "ftps:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/example.com/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "gopher:/example.com/",
+    "base": "http://example.org/foo/bar",
+    "href": "gopher:/example.com/",
+    "origin": "null",
+    "protocol": "gopher:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/example.com/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "ws:/example.com/",
+    "base": "http://example.org/foo/bar",
+    "href": "ws://example.com/",
+    "origin": "ws://example.com",
+    "protocol": "ws:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "wss:/example.com/",
+    "base": "http://example.org/foo/bar",
+    "href": "wss://example.com/",
+    "origin": "wss://example.com",
+    "protocol": "wss:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "data:/example.com/",
+    "base": "http://example.org/foo/bar",
+    "href": "data:/example.com/",
+    "origin": "null",
+    "protocol": "data:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/example.com/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "javascript:/example.com/",
+    "base": "http://example.org/foo/bar",
+    "href": "javascript:/example.com/",
+    "origin": "null",
+    "protocol": "javascript:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/example.com/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "mailto:/example.com/",
+    "base": "http://example.org/foo/bar",
+    "href": "mailto:/example.com/",
+    "origin": "null",
+    "protocol": "mailto:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/example.com/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http:example.com/",
+    "base": "http://example.org/foo/bar",
+    "href": "http://example.org/foo/example.com/",
+    "origin": "http://example.org",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/foo/example.com/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "ftp:example.com/",
+    "base": "http://example.org/foo/bar",
+    "href": "ftp://example.com/",
+    "origin": "ftp://example.com",
+    "protocol": "ftp:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "https:example.com/",
+    "base": "http://example.org/foo/bar",
+    "href": "https://example.com/",
+    "origin": "https://example.com",
+    "protocol": "https:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "madeupscheme:example.com/",
+    "base": "http://example.org/foo/bar",
+    "href": "madeupscheme:example.com/",
+    "origin": "null",
+    "protocol": "madeupscheme:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "example.com/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "ftps:example.com/",
+    "base": "http://example.org/foo/bar",
+    "href": "ftps:example.com/",
+    "origin": "null",
+    "protocol": "ftps:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "example.com/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "gopher:example.com/",
+    "base": "http://example.org/foo/bar",
+    "href": "gopher:example.com/",
+    "origin": "null",
+    "protocol": "gopher:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "example.com/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "ws:example.com/",
+    "base": "http://example.org/foo/bar",
+    "href": "ws://example.com/",
+    "origin": "ws://example.com",
+    "protocol": "ws:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "wss:example.com/",
+    "base": "http://example.org/foo/bar",
+    "href": "wss://example.com/",
+    "origin": "wss://example.com",
+    "protocol": "wss:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "data:example.com/",
+    "base": "http://example.org/foo/bar",
+    "href": "data:example.com/",
+    "origin": "null",
+    "protocol": "data:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "example.com/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "javascript:example.com/",
+    "base": "http://example.org/foo/bar",
+    "href": "javascript:example.com/",
+    "origin": "null",
+    "protocol": "javascript:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "example.com/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "mailto:example.com/",
+    "base": "http://example.org/foo/bar",
+    "href": "mailto:example.com/",
+    "origin": "null",
+    "protocol": "mailto:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "example.com/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "/a/b/c",
+    "base": "http://example.org/foo/bar",
+    "href": "http://example.org/a/b/c",
+    "origin": "http://example.org",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/a/b/c",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "/a/ /c",
+    "base": "http://example.org/foo/bar",
+    "href": "http://example.org/a/%20/c",
+    "origin": "http://example.org",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/a/%20/c",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "/a%2fc",
+    "base": "http://example.org/foo/bar",
+    "href": "http://example.org/a%2fc",
+    "origin": "http://example.org",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/a%2fc",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "/a/%2f/c",
+    "base": "http://example.org/foo/bar",
+    "href": "http://example.org/a/%2f/c",
+    "origin": "http://example.org",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/a/%2f/c",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "#β",
+    "base": "http://example.org/foo/bar",
+    "href": "http://example.org/foo/bar#%CE%B2",
+    "origin": "http://example.org",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/foo/bar",
+    "search": "",
+    "hash": "#%CE%B2"
+  },
+  {
+    "input": "data:text/html,test#test",
+    "base": "http://example.org/foo/bar",
+    "href": "data:text/html,test#test",
+    "origin": "null",
+    "protocol": "data:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "text/html,test",
+    "search": "",
+    "hash": "#test"
+  },
+  {
+    "input": "tel:1234567890",
+    "base": "http://example.org/foo/bar",
+    "href": "tel:1234567890",
+    "origin": "null",
+    "protocol": "tel:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "1234567890",
+    "search": "",
+    "hash": ""
+  },
+  "# Based on https://felixfbecker.github.io/whatwg-url-custom-host-repro/",
+  {
+    "input": "ssh://example.com/foo/bar.git",
+    "base": "http://example.org/",
+    "href": "ssh://example.com/foo/bar.git",
+    "origin": "null",
+    "protocol": "ssh:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/foo/bar.git",
+    "search": "",
+    "hash": ""
+  },
+  "# Based on http://trac.webkit.org/browser/trunk/LayoutTests/fast/url/file.html",
+  {
+    "input": "file:c:\\foo\\bar.html",
+    "base": "file:///tmp/mock/path",
+    "href": "file:///c:/foo/bar.html",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/c:/foo/bar.html",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "  File:c|////foo\\bar.html",
+    "base": "file:///tmp/mock/path",
+    "href": "file:///c:////foo/bar.html",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/c:////foo/bar.html",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "C|/foo/bar",
+    "base": "file:///tmp/mock/path",
+    "href": "file:///C:/foo/bar",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/C:/foo/bar",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "/C|\\foo\\bar",
+    "base": "file:///tmp/mock/path",
+    "href": "file:///C:/foo/bar",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/C:/foo/bar",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "//C|/foo/bar",
+    "base": "file:///tmp/mock/path",
+    "href": "file:///C:/foo/bar",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/C:/foo/bar",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "//server/file",
+    "base": "file:///tmp/mock/path",
+    "href": "file://server/file",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "server",
+    "hostname": "server",
+    "port": "",
+    "pathname": "/file",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "\\\\server\\file",
+    "base": "file:///tmp/mock/path",
+    "href": "file://server/file",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "server",
+    "hostname": "server",
+    "port": "",
+    "pathname": "/file",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "/\\server/file",
+    "base": "file:///tmp/mock/path",
+    "href": "file://server/file",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "server",
+    "hostname": "server",
+    "port": "",
+    "pathname": "/file",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file:///foo/bar.txt",
+    "base": "file:///tmp/mock/path",
+    "href": "file:///foo/bar.txt",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/foo/bar.txt",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file:///home/me",
+    "base": "file:///tmp/mock/path",
+    "href": "file:///home/me",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/home/me",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "//",
+    "base": "file:///tmp/mock/path",
+    "href": "file:///",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "///",
+    "base": "file:///tmp/mock/path",
+    "href": "file:///",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "///test",
+    "base": "file:///tmp/mock/path",
+    "href": "file:///test",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/test",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file://test",
+    "base": "file:///tmp/mock/path",
+    "href": "file://test/",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "test",
+    "hostname": "test",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file://localhost",
+    "base": "file:///tmp/mock/path",
+    "href": "file:///",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file://localhost/",
+    "base": "file:///tmp/mock/path",
+    "href": "file:///",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file://localhost/test",
+    "base": "file:///tmp/mock/path",
+    "href": "file:///test",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/test",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "test",
+    "base": "file:///tmp/mock/path",
+    "href": "file:///tmp/mock/test",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/tmp/mock/test",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file:test",
+    "base": "file:///tmp/mock/path",
+    "href": "file:///tmp/mock/test",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/tmp/mock/test",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file:///w|m",
+    "base": null,
+    "href": "file:///w|m",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/w|m",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file:///w||m",
+    "base": null,
+    "href": "file:///w||m",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/w||m",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file:///w|/m",
+    "base": null,
+    "href": "file:///w:/m",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/w:/m",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file:C|/m/",
+    "base": null,
+    "href": "file:///C:/m/",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/C:/m/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file:C||/m/",
+    "base": null,
+    "href": "file:///C||/m/",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/C||/m/",
+    "search": "",
+    "hash": ""
+  },
+  "# Based on http://trac.webkit.org/browser/trunk/LayoutTests/fast/url/script-tests/path.js",
+  {
+    "input": "http://example.com/././foo",
+    "base": null,
+    "href": "http://example.com/foo",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/foo",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://example.com/./.foo",
+    "base": null,
+    "href": "http://example.com/.foo",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/.foo",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://example.com/foo/.",
+    "base": null,
+    "href": "http://example.com/foo/",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/foo/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://example.com/foo/./",
+    "base": null,
+    "href": "http://example.com/foo/",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/foo/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://example.com/foo/bar/..",
+    "base": null,
+    "href": "http://example.com/foo/",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/foo/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://example.com/foo/bar/../",
+    "base": null,
+    "href": "http://example.com/foo/",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/foo/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://example.com/foo/..bar",
+    "base": null,
+    "href": "http://example.com/foo/..bar",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/foo/..bar",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://example.com/foo/bar/../ton",
+    "base": null,
+    "href": "http://example.com/foo/ton",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/foo/ton",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://example.com/foo/bar/../ton/../../a",
+    "base": null,
+    "href": "http://example.com/a",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/a",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://example.com/foo/../../..",
+    "base": null,
+    "href": "http://example.com/",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://example.com/foo/../../../ton",
+    "base": null,
+    "href": "http://example.com/ton",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/ton",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://example.com/foo/%2e",
+    "base": null,
+    "href": "http://example.com/foo/",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/foo/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://example.com/foo/%2e%2",
+    "base": null,
+    "href": "http://example.com/foo/%2e%2",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/foo/%2e%2",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://example.com/foo/%2e./%2e%2e/.%2e/%2e.bar",
+    "base": null,
+    "href": "http://example.com/%2e.bar",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/%2e.bar",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://example.com////../..",
+    "base": null,
+    "href": "http://example.com//",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "//",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://example.com/foo/bar//../..",
+    "base": null,
+    "href": "http://example.com/foo/",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/foo/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://example.com/foo/bar//..",
+    "base": null,
+    "href": "http://example.com/foo/bar/",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/foo/bar/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://example.com/foo",
+    "base": null,
+    "href": "http://example.com/foo",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/foo",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://example.com/%20foo",
+    "base": null,
+    "href": "http://example.com/%20foo",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/%20foo",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://example.com/foo%",
+    "base": null,
+    "href": "http://example.com/foo%",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/foo%",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://example.com/foo%2",
+    "base": null,
+    "href": "http://example.com/foo%2",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/foo%2",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://example.com/foo%2zbar",
+    "base": null,
+    "href": "http://example.com/foo%2zbar",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/foo%2zbar",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://example.com/foo%2©zbar",
+    "base": null,
+    "href": "http://example.com/foo%2%C3%82%C2%A9zbar",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/foo%2%C3%82%C2%A9zbar",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://example.com/foo%41%7a",
+    "base": null,
+    "href": "http://example.com/foo%41%7a",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/foo%41%7a",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://example.com/foo\t\u0091%91",
+    "base": null,
+    "href": "http://example.com/foo%C2%91%91",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/foo%C2%91%91",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://example.com/foo%00%51",
+    "base": null,
+    "href": "http://example.com/foo%00%51",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/foo%00%51",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://example.com/(%28:%3A%29)",
+    "base": null,
+    "href": "http://example.com/(%28:%3A%29)",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/(%28:%3A%29)",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://example.com/%3A%3a%3C%3c",
+    "base": null,
+    "href": "http://example.com/%3A%3a%3C%3c",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/%3A%3a%3C%3c",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://example.com/foo\tbar",
+    "base": null,
+    "href": "http://example.com/foobar",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/foobar",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://example.com\\\\foo\\\\bar",
+    "base": null,
+    "href": "http://example.com//foo//bar",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "//foo//bar",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://example.com/%7Ffp3%3Eju%3Dduvgw%3Dd",
+    "base": null,
+    "href": "http://example.com/%7Ffp3%3Eju%3Dduvgw%3Dd",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/%7Ffp3%3Eju%3Dduvgw%3Dd",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://example.com/@asdf%40",
+    "base": null,
+    "href": "http://example.com/@asdf%40",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/@asdf%40",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://example.com/你好你好",
+    "base": null,
+    "href": "http://example.com/%E4%BD%A0%E5%A5%BD%E4%BD%A0%E5%A5%BD",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/%E4%BD%A0%E5%A5%BD%E4%BD%A0%E5%A5%BD",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://example.com/‥/foo",
+    "base": null,
+    "href": "http://example.com/%E2%80%A5/foo",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/%E2%80%A5/foo",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://example.com//foo",
+    "base": null,
+    "href": "http://example.com/%EF%BB%BF/foo",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/%EF%BB%BF/foo",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://example.com/‮/foo/‭/bar",
+    "base": null,
+    "href": "http://example.com/%E2%80%AE/foo/%E2%80%AD/bar",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/%E2%80%AE/foo/%E2%80%AD/bar",
+    "search": "",
+    "hash": ""
+  },
+  "# Based on http://trac.webkit.org/browser/trunk/LayoutTests/fast/url/script-tests/relative.js",
+  {
+    "input": "http://www.google.com/foo?bar=baz#",
+    "base": null,
+    "href": "http://www.google.com/foo?bar=baz#",
+    "origin": "http://www.google.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "www.google.com",
+    "hostname": "www.google.com",
+    "port": "",
+    "pathname": "/foo",
+    "search": "?bar=baz",
+    "hash": ""
+  },
+  {
+    "input": "http://www.google.com/foo?bar=baz# »",
+    "base": null,
+    "href": "http://www.google.com/foo?bar=baz#%20%C2%BB",
+    "origin": "http://www.google.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "www.google.com",
+    "hostname": "www.google.com",
+    "port": "",
+    "pathname": "/foo",
+    "search": "?bar=baz",
+    "hash": "#%20%C2%BB"
+  },
+  {
+    "input": "data:test# »",
+    "base": null,
+    "href": "data:test#%20%C2%BB",
+    "origin": "null",
+    "protocol": "data:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "test",
+    "search": "",
+    "hash": "#%20%C2%BB"
+  },
+  {
+    "input": "http://www.google.com",
+    "base": null,
+    "href": "http://www.google.com/",
+    "origin": "http://www.google.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "www.google.com",
+    "hostname": "www.google.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://192.0x00A80001",
+    "base": null,
+    "href": "http://192.168.0.1/",
+    "origin": "http://192.168.0.1",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "192.168.0.1",
+    "hostname": "192.168.0.1",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://www/foo%2Ehtml",
+    "base": null,
+    "href": "http://www/foo%2Ehtml",
+    "origin": "http://www",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "www",
+    "hostname": "www",
+    "port": "",
+    "pathname": "/foo%2Ehtml",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://www/foo/%2E/html",
+    "base": null,
+    "href": "http://www/foo/html",
+    "origin": "http://www",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "www",
+    "hostname": "www",
+    "port": "",
+    "pathname": "/foo/html",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://user:pass@/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://%25DOMAIN:foobar@foodomain.com/",
+    "base": null,
+    "href": "http://%25DOMAIN:foobar@foodomain.com/",
+    "origin": "http://foodomain.com",
+    "protocol": "http:",
+    "username": "%25DOMAIN",
+    "password": "foobar",
+    "host": "foodomain.com",
+    "hostname": "foodomain.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http:\\\\www.google.com\\foo",
+    "base": null,
+    "href": "http://www.google.com/foo",
+    "origin": "http://www.google.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "www.google.com",
+    "hostname": "www.google.com",
+    "port": "",
+    "pathname": "/foo",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://foo:80/",
+    "base": null,
+    "href": "http://foo/",
+    "origin": "http://foo",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "foo",
+    "hostname": "foo",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://foo:81/",
+    "base": null,
+    "href": "http://foo:81/",
+    "origin": "http://foo:81",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "foo:81",
+    "hostname": "foo",
+    "port": "81",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "httpa://foo:80/",
+    "base": null,
+    "href": "httpa://foo:80/",
+    "origin": "null",
+    "protocol": "httpa:",
+    "username": "",
+    "password": "",
+    "host": "foo:80",
+    "hostname": "foo",
+    "port": "80",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://foo:-80/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "https://foo:443/",
+    "base": null,
+    "href": "https://foo/",
+    "origin": "https://foo",
+    "protocol": "https:",
+    "username": "",
+    "password": "",
+    "host": "foo",
+    "hostname": "foo",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "https://foo:80/",
+    "base": null,
+    "href": "https://foo:80/",
+    "origin": "https://foo:80",
+    "protocol": "https:",
+    "username": "",
+    "password": "",
+    "host": "foo:80",
+    "hostname": "foo",
+    "port": "80",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "ftp://foo:21/",
+    "base": null,
+    "href": "ftp://foo/",
+    "origin": "ftp://foo",
+    "protocol": "ftp:",
+    "username": "",
+    "password": "",
+    "host": "foo",
+    "hostname": "foo",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "ftp://foo:80/",
+    "base": null,
+    "href": "ftp://foo:80/",
+    "origin": "ftp://foo:80",
+    "protocol": "ftp:",
+    "username": "",
+    "password": "",
+    "host": "foo:80",
+    "hostname": "foo",
+    "port": "80",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "gopher://foo:70/",
+    "base": null,
+    "href": "gopher://foo:70/",
+    "origin": "null",
+    "protocol": "gopher:",
+    "username": "",
+    "password": "",
+    "host": "foo:70",
+    "hostname": "foo",
+    "port": "70",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "gopher://foo:443/",
+    "base": null,
+    "href": "gopher://foo:443/",
+    "origin": "null",
+    "protocol": "gopher:",
+    "username": "",
+    "password": "",
+    "host": "foo:443",
+    "hostname": "foo",
+    "port": "443",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "ws://foo:80/",
+    "base": null,
+    "href": "ws://foo/",
+    "origin": "ws://foo",
+    "protocol": "ws:",
+    "username": "",
+    "password": "",
+    "host": "foo",
+    "hostname": "foo",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "ws://foo:81/",
+    "base": null,
+    "href": "ws://foo:81/",
+    "origin": "ws://foo:81",
+    "protocol": "ws:",
+    "username": "",
+    "password": "",
+    "host": "foo:81",
+    "hostname": "foo",
+    "port": "81",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "ws://foo:443/",
+    "base": null,
+    "href": "ws://foo:443/",
+    "origin": "ws://foo:443",
+    "protocol": "ws:",
+    "username": "",
+    "password": "",
+    "host": "foo:443",
+    "hostname": "foo",
+    "port": "443",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "ws://foo:815/",
+    "base": null,
+    "href": "ws://foo:815/",
+    "origin": "ws://foo:815",
+    "protocol": "ws:",
+    "username": "",
+    "password": "",
+    "host": "foo:815",
+    "hostname": "foo",
+    "port": "815",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "wss://foo:80/",
+    "base": null,
+    "href": "wss://foo:80/",
+    "origin": "wss://foo:80",
+    "protocol": "wss:",
+    "username": "",
+    "password": "",
+    "host": "foo:80",
+    "hostname": "foo",
+    "port": "80",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "wss://foo:81/",
+    "base": null,
+    "href": "wss://foo:81/",
+    "origin": "wss://foo:81",
+    "protocol": "wss:",
+    "username": "",
+    "password": "",
+    "host": "foo:81",
+    "hostname": "foo",
+    "port": "81",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "wss://foo:443/",
+    "base": null,
+    "href": "wss://foo/",
+    "origin": "wss://foo",
+    "protocol": "wss:",
+    "username": "",
+    "password": "",
+    "host": "foo",
+    "hostname": "foo",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "wss://foo:815/",
+    "base": null,
+    "href": "wss://foo:815/",
+    "origin": "wss://foo:815",
+    "protocol": "wss:",
+    "username": "",
+    "password": "",
+    "host": "foo:815",
+    "hostname": "foo",
+    "port": "815",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http:/example.com/",
+    "base": null,
+    "href": "http://example.com/",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "ftp:/example.com/",
+    "base": null,
+    "href": "ftp://example.com/",
+    "origin": "ftp://example.com",
+    "protocol": "ftp:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "https:/example.com/",
+    "base": null,
+    "href": "https://example.com/",
+    "origin": "https://example.com",
+    "protocol": "https:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "madeupscheme:/example.com/",
+    "base": null,
+    "href": "madeupscheme:/example.com/",
+    "origin": "null",
+    "protocol": "madeupscheme:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/example.com/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file:/example.com/",
+    "base": null,
+    "href": "file:///example.com/",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/example.com/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "ftps:/example.com/",
+    "base": null,
+    "href": "ftps:/example.com/",
+    "origin": "null",
+    "protocol": "ftps:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/example.com/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "gopher:/example.com/",
+    "base": null,
+    "href": "gopher:/example.com/",
+    "origin": "null",
+    "protocol": "gopher:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/example.com/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "ws:/example.com/",
+    "base": null,
+    "href": "ws://example.com/",
+    "origin": "ws://example.com",
+    "protocol": "ws:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "wss:/example.com/",
+    "base": null,
+    "href": "wss://example.com/",
+    "origin": "wss://example.com",
+    "protocol": "wss:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "data:/example.com/",
+    "base": null,
+    "href": "data:/example.com/",
+    "origin": "null",
+    "protocol": "data:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/example.com/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "javascript:/example.com/",
+    "base": null,
+    "href": "javascript:/example.com/",
+    "origin": "null",
+    "protocol": "javascript:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/example.com/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "mailto:/example.com/",
+    "base": null,
+    "href": "mailto:/example.com/",
+    "origin": "null",
+    "protocol": "mailto:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/example.com/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http:example.com/",
+    "base": null,
+    "href": "http://example.com/",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "ftp:example.com/",
+    "base": null,
+    "href": "ftp://example.com/",
+    "origin": "ftp://example.com",
+    "protocol": "ftp:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "https:example.com/",
+    "base": null,
+    "href": "https://example.com/",
+    "origin": "https://example.com",
+    "protocol": "https:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "madeupscheme:example.com/",
+    "base": null,
+    "href": "madeupscheme:example.com/",
+    "origin": "null",
+    "protocol": "madeupscheme:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "example.com/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "ftps:example.com/",
+    "base": null,
+    "href": "ftps:example.com/",
+    "origin": "null",
+    "protocol": "ftps:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "example.com/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "gopher:example.com/",
+    "base": null,
+    "href": "gopher:example.com/",
+    "origin": "null",
+    "protocol": "gopher:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "example.com/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "ws:example.com/",
+    "base": null,
+    "href": "ws://example.com/",
+    "origin": "ws://example.com",
+    "protocol": "ws:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "wss:example.com/",
+    "base": null,
+    "href": "wss://example.com/",
+    "origin": "wss://example.com",
+    "protocol": "wss:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "data:example.com/",
+    "base": null,
+    "href": "data:example.com/",
+    "origin": "null",
+    "protocol": "data:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "example.com/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "javascript:example.com/",
+    "base": null,
+    "href": "javascript:example.com/",
+    "origin": "null",
+    "protocol": "javascript:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "example.com/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "mailto:example.com/",
+    "base": null,
+    "href": "mailto:example.com/",
+    "origin": "null",
+    "protocol": "mailto:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "example.com/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "https://example.com/aaa/bbb/%2e%2e?query",
+    "base": null,
+    "href": "https://example.com/aaa/?query",
+    "origin": "https://example.com",
+    "protocol": "https:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/aaa/",
+    "search": "?query",
+    "hash": ""
+  },
+  "# Based on http://trac.webkit.org/browser/trunk/LayoutTests/fast/url/segments-userinfo-vs-host.html",
+  {
+    "input": "http:@www.example.com",
+    "base": null,
+    "href": "http://www.example.com/",
+    "origin": "http://www.example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "www.example.com",
+    "hostname": "www.example.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http:/@www.example.com",
+    "base": null,
+    "href": "http://www.example.com/",
+    "origin": "http://www.example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "www.example.com",
+    "hostname": "www.example.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://@www.example.com",
+    "base": null,
+    "href": "http://www.example.com/",
+    "origin": "http://www.example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "www.example.com",
+    "hostname": "www.example.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http:a:b@www.example.com",
+    "base": null,
+    "href": "http://a:b@www.example.com/",
+    "origin": "http://www.example.com",
+    "protocol": "http:",
+    "username": "a",
+    "password": "b",
+    "host": "www.example.com",
+    "hostname": "www.example.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http:/a:b@www.example.com",
+    "base": null,
+    "href": "http://a:b@www.example.com/",
+    "origin": "http://www.example.com",
+    "protocol": "http:",
+    "username": "a",
+    "password": "b",
+    "host": "www.example.com",
+    "hostname": "www.example.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://a:b@www.example.com",
+    "base": null,
+    "href": "http://a:b@www.example.com/",
+    "origin": "http://www.example.com",
+    "protocol": "http:",
+    "username": "a",
+    "password": "b",
+    "host": "www.example.com",
+    "hostname": "www.example.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://@pple.com",
+    "base": null,
+    "href": "http://pple.com/",
+    "origin": "http://pple.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "pple.com",
+    "hostname": "pple.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http::b@www.example.com",
+    "base": null,
+    "href": "http://:b@www.example.com/",
+    "origin": "http://www.example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "b",
+    "host": "www.example.com",
+    "hostname": "www.example.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http:/:b@www.example.com",
+    "base": null,
+    "href": "http://:b@www.example.com/",
+    "origin": "http://www.example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "b",
+    "host": "www.example.com",
+    "hostname": "www.example.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://:b@www.example.com",
+    "base": null,
+    "href": "http://:b@www.example.com/",
+    "origin": "http://www.example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "b",
+    "host": "www.example.com",
+    "hostname": "www.example.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http:/:@/www.example.com",
+    "base": null,
+    "failure": true,
+    "relativeTo": "non-opaque-path-base"
+  },
+  {
+    "input": "http://user@/www.example.com",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http:@/www.example.com",
+    "base": null,
+    "failure": true,
+    "relativeTo": "non-opaque-path-base"
+  },
+  {
+    "input": "http:/@/www.example.com",
+    "base": null,
+    "failure": true,
+    "relativeTo": "non-opaque-path-base"
+  },
+  {
+    "input": "http://@/www.example.com",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "https:@/www.example.com",
+    "base": null,
+    "failure": true,
+    "relativeTo": "non-opaque-path-base"
+  },
+  {
+    "input": "http:a:b@/www.example.com",
+    "base": null,
+    "failure": true,
+    "relativeTo": "non-opaque-path-base"
+  },
+  {
+    "input": "http:/a:b@/www.example.com",
+    "base": null,
+    "failure": true,
+    "relativeTo": "non-opaque-path-base"
+  },
+  {
+    "input": "http://a:b@/www.example.com",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http::@/www.example.com",
+    "base": null,
+    "failure": true,
+    "relativeTo": "non-opaque-path-base"
+  },
+  {
+    "input": "http:a:@www.example.com",
+    "base": null,
+    "href": "http://a@www.example.com/",
+    "origin": "http://www.example.com",
+    "protocol": "http:",
+    "username": "a",
+    "password": "",
+    "host": "www.example.com",
+    "hostname": "www.example.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http:/a:@www.example.com",
+    "base": null,
+    "href": "http://a@www.example.com/",
+    "origin": "http://www.example.com",
+    "protocol": "http:",
+    "username": "a",
+    "password": "",
+    "host": "www.example.com",
+    "hostname": "www.example.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://a:@www.example.com",
+    "base": null,
+    "href": "http://a@www.example.com/",
+    "origin": "http://www.example.com",
+    "protocol": "http:",
+    "username": "a",
+    "password": "",
+    "host": "www.example.com",
+    "hostname": "www.example.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://www.@pple.com",
+    "base": null,
+    "href": "http://www.@pple.com/",
+    "origin": "http://pple.com",
+    "protocol": "http:",
+    "username": "www.",
+    "password": "",
+    "host": "pple.com",
+    "hostname": "pple.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http:@:www.example.com",
+    "base": null,
+    "failure": true,
+    "relativeTo": "non-opaque-path-base"
+  },
+  {
+    "input": "http:/@:www.example.com",
+    "base": null,
+    "failure": true,
+    "relativeTo": "non-opaque-path-base"
+  },
+  {
+    "input": "http://@:www.example.com",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://:@www.example.com",
+    "base": null,
+    "href": "http://www.example.com/",
+    "origin": "http://www.example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "www.example.com",
+    "hostname": "www.example.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  "# Others",
+  {
+    "input": "/",
+    "base": "http://www.example.com/test",
+    "href": "http://www.example.com/",
+    "origin": "http://www.example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "www.example.com",
+    "hostname": "www.example.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "/test.txt",
+    "base": "http://www.example.com/test",
+    "href": "http://www.example.com/test.txt",
+    "origin": "http://www.example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "www.example.com",
+    "hostname": "www.example.com",
+    "port": "",
+    "pathname": "/test.txt",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": ".",
+    "base": "http://www.example.com/test",
+    "href": "http://www.example.com/",
+    "origin": "http://www.example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "www.example.com",
+    "hostname": "www.example.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "..",
+    "base": "http://www.example.com/test",
+    "href": "http://www.example.com/",
+    "origin": "http://www.example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "www.example.com",
+    "hostname": "www.example.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "test.txt",
+    "base": "http://www.example.com/test",
+    "href": "http://www.example.com/test.txt",
+    "origin": "http://www.example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "www.example.com",
+    "hostname": "www.example.com",
+    "port": "",
+    "pathname": "/test.txt",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "./test.txt",
+    "base": "http://www.example.com/test",
+    "href": "http://www.example.com/test.txt",
+    "origin": "http://www.example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "www.example.com",
+    "hostname": "www.example.com",
+    "port": "",
+    "pathname": "/test.txt",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "../test.txt",
+    "base": "http://www.example.com/test",
+    "href": "http://www.example.com/test.txt",
+    "origin": "http://www.example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "www.example.com",
+    "hostname": "www.example.com",
+    "port": "",
+    "pathname": "/test.txt",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "../aaa/test.txt",
+    "base": "http://www.example.com/test",
+    "href": "http://www.example.com/aaa/test.txt",
+    "origin": "http://www.example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "www.example.com",
+    "hostname": "www.example.com",
+    "port": "",
+    "pathname": "/aaa/test.txt",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "../../test.txt",
+    "base": "http://www.example.com/test",
+    "href": "http://www.example.com/test.txt",
+    "origin": "http://www.example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "www.example.com",
+    "hostname": "www.example.com",
+    "port": "",
+    "pathname": "/test.txt",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "中/test.txt",
+    "base": "http://www.example.com/test",
+    "href": "http://www.example.com/%E4%B8%AD/test.txt",
+    "origin": "http://www.example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "www.example.com",
+    "hostname": "www.example.com",
+    "port": "",
+    "pathname": "/%E4%B8%AD/test.txt",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://www.example2.com",
+    "base": "http://www.example.com/test",
+    "href": "http://www.example2.com/",
+    "origin": "http://www.example2.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "www.example2.com",
+    "hostname": "www.example2.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "//www.example2.com",
+    "base": "http://www.example.com/test",
+    "href": "http://www.example2.com/",
+    "origin": "http://www.example2.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "www.example2.com",
+    "hostname": "www.example2.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file:...",
+    "base": "http://www.example.com/test",
+    "href": "file:///...",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/...",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file:..",
+    "base": "http://www.example.com/test",
+    "href": "file:///",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file:a",
+    "base": "http://www.example.com/test",
+    "href": "file:///a",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/a",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file:.",
+    "base": null,
+    "href": "file:///",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file:.",
+    "base": "http://www.example.com/test",
+    "href": "file:///",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  "# Based on http://trac.webkit.org/browser/trunk/LayoutTests/fast/url/host.html",
+  "Basic canonicalization, uppercase should be converted to lowercase",
+  {
+    "input": "http://ExAmPlE.CoM",
+    "base": "http://other.com/",
+    "href": "http://example.com/",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://example example.com",
+    "base": "http://other.com/",
+    "failure": true
+  },
+  {
+    "input": "http://Goo%20 goo%7C|.com",
+    "base": "http://other.com/",
+    "failure": true
+  },
+  {
+    "input": "http://[]",
+    "base": "http://other.com/",
+    "failure": true
+  },
+  {
+    "input": "http://[:]",
+    "base": "http://other.com/",
+    "failure": true
+  },
+  "U+3000 is mapped to U+0020 (space) which is disallowed",
+  {
+    "input": "http://GOO\u00a0\u3000goo.com",
+    "base": "http://other.com/",
+    "failure": true
+  },
+  "Other types of space (no-break, zero-width, zero-width-no-break) are name-prepped away to nothing. U+200B, U+2060, and U+FEFF, are ignored",
+  {
+    "input": "http://GOO\u200b\u2060\ufeffgoo.com",
+    "base": "http://other.com/",
+    "href": "http://googoo.com/",
+    "origin": "http://googoo.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "googoo.com",
+    "hostname": "googoo.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  "Leading and trailing C0 control or space",
+  {
+    "input": "\u0000\u001b\u0004\u0012 http://example.com/\u001f \u000d ",
+    "base": null,
+    "href": "http://example.com/",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "non-special:opaque  ",
+    "base": null,
+    "href": "non-special:opaque",
+    "origin": "null",
+    "protocol": "non-special:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "opaque",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "non-special:opaque  ?hi",
+    "base": null,
+    "href": "non-special:opaque %20?hi",
+    "origin": "null",
+    "protocol": "non-special:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "opaque %20",
+    "search": "?hi",
+    "hash": ""
+  },
+  {
+    "input": "non-special:opaque  #hi",
+    "base": null,
+    "href": "non-special:opaque %20#hi",
+    "origin": "null",
+    "protocol": "non-special:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "opaque %20",
+    "search": "",
+    "hash": "#hi"
+  },
+  {
+    "input": "non-special:opaque  x?hi",
+    "base": null,
+    "href": "non-special:opaque  x?hi",
+    "origin": "null",
+    "protocol": "non-special:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "opaque  x",
+    "search": "?hi",
+    "hash": ""
+  },
+  {
+    "input": "non-special:opaque  x#hi",
+    "base": null,
+    "href": "non-special:opaque  x#hi",
+    "origin": "null",
+    "protocol": "non-special:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "opaque  x",
+    "search": "",
+    "hash": "#hi"
+  },
+  {
+    "input": "non-special:opaque \t\t  \t#hi",
+    "base": null,
+    "href": "non-special:opaque  %20#hi",
+    "origin": "null",
+    "protocol": "non-special:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "opaque  %20",
+    "search": "",
+    "hash": "#hi"
+  },
+  {
+    "input": "non-special:opaque \t\t  #hi",
+    "base": null,
+    "href": "non-special:opaque  %20#hi",
+    "origin": "null",
+    "protocol": "non-special:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "opaque  %20",
+    "search": "",
+    "hash": "#hi"
+  },
+  {
+    "input": "non-special:opaque\t\t  \r #hi",
+    "base": null,
+    "href": "non-special:opaque  %20#hi",
+    "origin": "null",
+    "protocol": "non-special:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "opaque  %20",
+    "search": "",
+    "hash": "#hi"
+  },
+  "Ideographic full stop (full-width period for Chinese, etc.) should be treated as a dot. U+3002 is mapped to U+002E (dot)",
+  {
+    "input": "http://www.foo。bar.com",
+    "base": "http://other.com/",
+    "href": "http://www.foo.bar.com/",
+    "origin": "http://www.foo.bar.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "www.foo.bar.com",
+    "hostname": "www.foo.bar.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  "Invalid unicode characters should fail... U+FDD0 is disallowed; %ef%b7%90 is U+FDD0",
+  {
+    "input": "http://\ufdd0zyx.com",
+    "base": "http://other.com/",
+    "failure": true
+  },
+  "This is the same as previous but escaped",
+  {
+    "input": "http://%ef%b7%90zyx.com",
+    "base": "http://other.com/",
+    "failure": true
+  },
+  "U+FFFD",
+  {
+    "input": "https://\ufffd",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "https://%EF%BF%BD",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "https://x/\ufffd?\ufffd#\ufffd",
+    "base": null,
+    "href": "https://x/%EF%BF%BD?%EF%BF%BD#%EF%BF%BD",
+    "origin": "https://x",
+    "protocol": "https:",
+    "username": "",
+    "password": "",
+    "host": "x",
+    "hostname": "x",
+    "port": "",
+    "pathname": "/%EF%BF%BD",
+    "search": "?%EF%BF%BD",
+    "hash": "#%EF%BF%BD"
+  },
+  "Domain is ASCII, but a label is invalid IDNA",
+  {
+    "input": "http://a.b.c.xn--pokxncvks",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://10.0.0.xn--pokxncvks",
+    "base": null,
+    "failure": true
+  },
+  "IDNA labels should be matched case-insensitively",
+  {
+    "input": "http://a.b.c.XN--pokxncvks",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://a.b.c.Xn--pokxncvks",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://10.0.0.XN--pokxncvks",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://10.0.0.xN--pokxncvks",
+    "base": null,
+    "failure": true
+  },
+  "Test name prepping, fullwidth input should be converted to ASCII and NOT IDN-ized. This is 'Go' in fullwidth UTF-8/UTF-16.",
+  {
+    "input": "http://Ｇｏ.com",
+    "base": "http://other.com/",
+    "href": "http://go.com/",
+    "origin": "http://go.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "go.com",
+    "hostname": "go.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  "URL spec forbids the following. https://www.w3.org/Bugs/Public/show_bug.cgi?id=24257",
+  {
+    "input": "http://％４１.com",
+    "base": "http://other.com/",
+    "failure": true
+  },
+  {
+    "input": "http://%ef%bc%85%ef%bc%94%ef%bc%91.com",
+    "base": "http://other.com/",
+    "failure": true
+  },
+  "...%00 in fullwidth should fail (also as escaped UTF-8 input)",
+  {
+    "input": "http://％００.com",
+    "base": "http://other.com/",
+    "failure": true
+  },
+  {
+    "input": "http://%ef%bc%85%ef%bc%90%ef%bc%90.com",
+    "base": "http://other.com/",
+    "failure": true
+  },
+  "Basic IDN support, UTF-8 and UTF-16 input should be converted to IDN",
+  {
+    "input": "http://你好你好",
+    "base": "http://other.com/",
+    "href": "http://xn--6qqa088eba/",
+    "origin": "http://xn--6qqa088eba",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "xn--6qqa088eba",
+    "hostname": "xn--6qqa088eba",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "https://faß.ExAmPlE/",
+    "base": null,
+    "href": "https://xn--fa-hia.example/",
+    "origin": "https://xn--fa-hia.example",
+    "protocol": "https:",
+    "username": "",
+    "password": "",
+    "host": "xn--fa-hia.example",
+    "hostname": "xn--fa-hia.example",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "sc://faß.ExAmPlE/",
+    "base": null,
+    "href": "sc://fa%C3%9F.ExAmPlE/",
+    "origin": "null",
+    "protocol": "sc:",
+    "username": "",
+    "password": "",
+    "host": "fa%C3%9F.ExAmPlE",
+    "hostname": "fa%C3%9F.ExAmPlE",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  "Invalid escaped characters should fail and the percents should be escaped. https://www.w3.org/Bugs/Public/show_bug.cgi?id=24191",
+  {
+    "input": "http://%zz%66%a.com",
+    "base": "http://other.com/",
+    "failure": true
+  },
+  "If we get an invalid character that has been escaped.",
+  {
+    "input": "http://%25",
+    "base": "http://other.com/",
+    "failure": true
+  },
+  {
+    "input": "http://hello%00",
+    "base": "http://other.com/",
+    "failure": true
+  },
+  "Escaped numbers should be treated like IP addresses if they are.",
+  {
+    "input": "http://%30%78%63%30%2e%30%32%35%30.01",
+    "base": "http://other.com/",
+    "href": "http://192.168.0.1/",
+    "origin": "http://192.168.0.1",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "192.168.0.1",
+    "hostname": "192.168.0.1",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://%30%78%63%30%2e%30%32%35%30.01%2e",
+    "base": "http://other.com/",
+    "href": "http://192.168.0.1/",
+    "origin": "http://192.168.0.1",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "192.168.0.1",
+    "hostname": "192.168.0.1",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://192.168.0.257",
+    "base": "http://other.com/",
+    "failure": true
+  },
+  "Invalid escaping in hosts causes failure",
+  {
+    "input": "http://%3g%78%63%30%2e%30%32%35%30%2E.01",
+    "base": "http://other.com/",
+    "failure": true
+  },
+  "A space in a host causes failure",
+  {
+    "input": "http://192.168.0.1 hello",
+    "base": "http://other.com/",
+    "failure": true
+  },
+  {
+    "input": "https://x x:12",
+    "base": null,
+    "failure": true
+  },
+  "Fullwidth and escaped UTF-8 fullwidth should still be treated as IP",
+  {
+    "input": "http://０Ｘｃ０．０２５０．０１",
+    "base": "http://other.com/",
+    "href": "http://192.168.0.1/",
+    "origin": "http://192.168.0.1",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "192.168.0.1",
+    "hostname": "192.168.0.1",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  "Domains with empty labels",
+  {
+    "input": "http://./",
+    "base": null,
+    "href": "http://./",
+    "origin": "http://.",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": ".",
+    "hostname": ".",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://../",
+    "base": null,
+    "href": "http://../",
+    "origin": "http://..",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "..",
+    "hostname": "..",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  "Non-special domains with empty labels",
+  {
+    "input": "h://.",
+    "base": null,
+    "href": "h://.",
+    "origin": "null",
+    "protocol": "h:",
+    "username": "",
+    "password": "",
+    "host": ".",
+    "hostname": ".",
+    "port": "",
+    "pathname": "",
+    "search": "",
+    "hash": ""
+  },
+  "Broken IPv6",
+  {
+    "input": "http://[www.google.com]/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://[google.com]",
+    "base": "http://other.com/",
+    "failure": true
+  },
+  {
+    "input": "http://[::1.2.3.4x]",
+    "base": "http://other.com/",
+    "failure": true
+  },
+  {
+    "input": "http://[::1.2.3.]",
+    "base": "http://other.com/",
+    "failure": true
+  },
+  {
+    "input": "http://[::1.2.]",
+    "base": "http://other.com/",
+    "failure": true
+  },
+  {
+    "input": "http://[::.1.2]",
+    "base": "http://other.com/",
+    "failure": true
+  },
+  {
+    "input": "http://[::1.]",
+    "base": "http://other.com/",
+    "failure": true
+  },
+  {
+    "input": "http://[::.1]",
+    "base": "http://other.com/",
+    "failure": true
+  },
+  {
+    "input": "http://[::%31]",
+    "base": "http://other.com/",
+    "failure": true
+  },
+  {
+    "input": "http://%5B::1]",
+    "base": "http://other.com/",
+    "failure": true
+  },
+  "Misc Unicode",
+  {
+    "input": "http://foo:💩@example.com/bar",
+    "base": "http://other.com/",
+    "href": "http://foo:%F0%9F%92%A9@example.com/bar",
+    "origin": "http://example.com",
+    "protocol": "http:",
+    "username": "foo",
+    "password": "%F0%9F%92%A9",
+    "host": "example.com",
+    "hostname": "example.com",
+    "port": "",
+    "pathname": "/bar",
+    "search": "",
+    "hash": ""
+  },
+  "# resolving a fragment against any scheme succeeds",
+  {
+    "input": "#",
+    "base": "test:test",
+    "href": "test:test#",
+    "origin": "null",
+    "protocol": "test:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "test",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "#x",
+    "base": "mailto:x@x.com",
+    "href": "mailto:x@x.com#x",
+    "origin": "null",
+    "protocol": "mailto:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "x@x.com",
+    "search": "",
+    "hash": "#x"
+  },
+  {
+    "input": "#x",
+    "base": "data:,",
+    "href": "data:,#x",
+    "origin": "null",
+    "protocol": "data:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": ",",
+    "search": "",
+    "hash": "#x"
+  },
+  {
+    "input": "#x",
+    "base": "about:blank",
+    "href": "about:blank#x",
+    "origin": "null",
+    "protocol": "about:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "blank",
+    "search": "",
+    "hash": "#x"
+  },
+  {
+    "input": "#x:y",
+    "base": "about:blank",
+    "href": "about:blank#x:y",
+    "origin": "null",
+    "protocol": "about:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "blank",
+    "search": "",
+    "hash": "#x:y"
+  },
+  {
+    "input": "#",
+    "base": "test:test?test",
+    "href": "test:test?test#",
+    "origin": "null",
+    "protocol": "test:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "test",
+    "search": "?test",
+    "hash": ""
+  },
+  "# multiple @ in authority state",
+  {
+    "input": "https://@test@test@example:800/",
+    "base": "http://doesnotmatter/",
+    "href": "https://%40test%40test@example:800/",
+    "origin": "https://example:800",
+    "protocol": "https:",
+    "username": "%40test%40test",
+    "password": "",
+    "host": "example:800",
+    "hostname": "example",
+    "port": "800",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "https://@@@example",
+    "base": "http://doesnotmatter/",
+    "href": "https://%40%40@example/",
+    "origin": "https://example",
+    "protocol": "https:",
+    "username": "%40%40",
+    "password": "",
+    "host": "example",
+    "hostname": "example",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  "non-az-09 characters",
+  {
+    "input": "http://`{}:`{}@h/`{}?`{}",
+    "base": "http://doesnotmatter/",
+    "href": "http://%60%7B%7D:%60%7B%7D@h/%60%7B%7D?`{}",
+    "origin": "http://h",
+    "protocol": "http:",
+    "username": "%60%7B%7D",
+    "password": "%60%7B%7D",
+    "host": "h",
+    "hostname": "h",
+    "port": "",
+    "pathname": "/%60%7B%7D",
+    "search": "?`{}",
+    "hash": ""
+  },
+  "byte is ' and url is special",
+  {
+    "input": "http://host/?'",
+    "base": null,
+    "href": "http://host/?%27",
+    "origin": "http://host",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "host",
+    "hostname": "host",
+    "port": "",
+    "pathname": "/",
+    "search": "?%27",
+    "hash": ""
+  },
+  {
+    "input": "notspecial://host/?'",
+    "base": null,
+    "href": "notspecial://host/?'",
+    "origin": "null",
+    "protocol": "notspecial:",
+    "username": "",
+    "password": "",
+    "host": "host",
+    "hostname": "host",
+    "port": "",
+    "pathname": "/",
+    "search": "?'",
+    "hash": ""
+  },
+  "# Credentials in base",
+  {
+    "input": "/some/path",
+    "base": "http://user@example.org/smth",
+    "href": "http://user@example.org/some/path",
+    "origin": "http://example.org",
+    "protocol": "http:",
+    "username": "user",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/some/path",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "",
+    "base": "http://user:pass@example.org:21/smth",
+    "href": "http://user:pass@example.org:21/smth",
+    "origin": "http://example.org:21",
+    "protocol": "http:",
+    "username": "user",
+    "password": "pass",
+    "host": "example.org:21",
+    "hostname": "example.org",
+    "port": "21",
+    "pathname": "/smth",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "/some/path",
+    "base": "http://user:pass@example.org:21/smth",
+    "href": "http://user:pass@example.org:21/some/path",
+    "origin": "http://example.org:21",
+    "protocol": "http:",
+    "username": "user",
+    "password": "pass",
+    "host": "example.org:21",
+    "hostname": "example.org",
+    "port": "21",
+    "pathname": "/some/path",
+    "search": "",
+    "hash": ""
+  },
+  "# a set of tests designed by zcorpan for relative URLs with unknown schemes",
+  {
+    "input": "i",
+    "base": "sc:sd",
+    "failure": true
+  },
+  {
+    "input": "i",
+    "base": "sc:sd/sd",
+    "failure": true
+  },
+  {
+    "input": "i",
+    "base": "sc:/pa/pa",
+    "href": "sc:/pa/i",
+    "origin": "null",
+    "protocol": "sc:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/pa/i",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "i",
+    "base": "sc://ho/pa",
+    "href": "sc://ho/i",
+    "origin": "null",
+    "protocol": "sc:",
+    "username": "",
+    "password": "",
+    "host": "ho",
+    "hostname": "ho",
+    "port": "",
+    "pathname": "/i",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "i",
+    "base": "sc:///pa/pa",
+    "href": "sc:///pa/i",
+    "origin": "null",
+    "protocol": "sc:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/pa/i",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "../i",
+    "base": "sc:sd",
+    "failure": true
+  },
+  {
+    "input": "../i",
+    "base": "sc:sd/sd",
+    "failure": true
+  },
+  {
+    "input": "../i",
+    "base": "sc:/pa/pa",
+    "href": "sc:/i",
+    "origin": "null",
+    "protocol": "sc:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/i",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "../i",
+    "base": "sc://ho/pa",
+    "href": "sc://ho/i",
+    "origin": "null",
+    "protocol": "sc:",
+    "username": "",
+    "password": "",
+    "host": "ho",
+    "hostname": "ho",
+    "port": "",
+    "pathname": "/i",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "../i",
+    "base": "sc:///pa/pa",
+    "href": "sc:///i",
+    "origin": "null",
+    "protocol": "sc:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/i",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "/i",
+    "base": "sc:sd",
+    "failure": true
+  },
+  {
+    "input": "/i",
+    "base": "sc:sd/sd",
+    "failure": true
+  },
+  {
+    "input": "/i",
+    "base": "sc:/pa/pa",
+    "href": "sc:/i",
+    "origin": "null",
+    "protocol": "sc:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/i",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "/i",
+    "base": "sc://ho/pa",
+    "href": "sc://ho/i",
+    "origin": "null",
+    "protocol": "sc:",
+    "username": "",
+    "password": "",
+    "host": "ho",
+    "hostname": "ho",
+    "port": "",
+    "pathname": "/i",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "/i",
+    "base": "sc:///pa/pa",
+    "href": "sc:///i",
+    "origin": "null",
+    "protocol": "sc:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/i",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "?i",
+    "base": "sc:sd",
+    "failure": true
+  },
+  {
+    "input": "?i",
+    "base": "sc:sd/sd",
+    "failure": true
+  },
+  {
+    "input": "?i",
+    "base": "sc:/pa/pa",
+    "href": "sc:/pa/pa?i",
+    "origin": "null",
+    "protocol": "sc:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/pa/pa",
+    "search": "?i",
+    "hash": ""
+  },
+  {
+    "input": "?i",
+    "base": "sc://ho/pa",
+    "href": "sc://ho/pa?i",
+    "origin": "null",
+    "protocol": "sc:",
+    "username": "",
+    "password": "",
+    "host": "ho",
+    "hostname": "ho",
+    "port": "",
+    "pathname": "/pa",
+    "search": "?i",
+    "hash": ""
+  },
+  {
+    "input": "?i",
+    "base": "sc:///pa/pa",
+    "href": "sc:///pa/pa?i",
+    "origin": "null",
+    "protocol": "sc:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/pa/pa",
+    "search": "?i",
+    "hash": ""
+  },
+  {
+    "input": "#i",
+    "base": "sc:sd",
+    "href": "sc:sd#i",
+    "origin": "null",
+    "protocol": "sc:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "sd",
+    "search": "",
+    "hash": "#i"
+  },
+  {
+    "input": "#i",
+    "base": "sc:sd/sd",
+    "href": "sc:sd/sd#i",
+    "origin": "null",
+    "protocol": "sc:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "sd/sd",
+    "search": "",
+    "hash": "#i"
+  },
+  {
+    "input": "#i",
+    "base": "sc:/pa/pa",
+    "href": "sc:/pa/pa#i",
+    "origin": "null",
+    "protocol": "sc:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/pa/pa",
+    "search": "",
+    "hash": "#i"
+  },
+  {
+    "input": "#i",
+    "base": "sc://ho/pa",
+    "href": "sc://ho/pa#i",
+    "origin": "null",
+    "protocol": "sc:",
+    "username": "",
+    "password": "",
+    "host": "ho",
+    "hostname": "ho",
+    "port": "",
+    "pathname": "/pa",
+    "search": "",
+    "hash": "#i"
+  },
+  {
+    "input": "#i",
+    "base": "sc:///pa/pa",
+    "href": "sc:///pa/pa#i",
+    "origin": "null",
+    "protocol": "sc:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/pa/pa",
+    "search": "",
+    "hash": "#i"
+  },
+  "# make sure that relative URL logic works on known typically non-relative schemes too",
+  {
+    "input": "about:/../",
+    "base": null,
+    "href": "about:/",
+    "origin": "null",
+    "protocol": "about:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "data:/../",
+    "base": null,
+    "href": "data:/",
+    "origin": "null",
+    "protocol": "data:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "javascript:/../",
+    "base": null,
+    "href": "javascript:/",
+    "origin": "null",
+    "protocol": "javascript:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "mailto:/../",
+    "base": null,
+    "href": "mailto:/",
+    "origin": "null",
+    "protocol": "mailto:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  "# unknown schemes and their hosts",
+  {
+    "input": "sc://ñ.test/",
+    "base": null,
+    "href": "sc://%C3%B1.test/",
+    "origin": "null",
+    "protocol": "sc:",
+    "username": "",
+    "password": "",
+    "host": "%C3%B1.test",
+    "hostname": "%C3%B1.test",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "sc://%/",
+    "base": null,
+    "href": "sc://%/",
+    "protocol": "sc:",
+    "username": "",
+    "password": "",
+    "host": "%",
+    "hostname": "%",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "sc://@/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "sc://te@s:t@/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "sc://:/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "sc://:12/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "x",
+    "base": "sc://ñ",
+    "href": "sc://%C3%B1/x",
+    "origin": "null",
+    "protocol": "sc:",
+    "username": "",
+    "password": "",
+    "host": "%C3%B1",
+    "hostname": "%C3%B1",
+    "port": "",
+    "pathname": "/x",
+    "search": "",
+    "hash": ""
+  },
+  "# unknown schemes and backslashes",
+  {
+    "input": "sc:\\../",
+    "base": null,
+    "href": "sc:\\../",
+    "origin": "null",
+    "protocol": "sc:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "\\../",
+    "search": "",
+    "hash": ""
+  },
+  "# unknown scheme with path looking like a password",
+  {
+    "input": "sc::a@example.net",
+    "base": null,
+    "href": "sc::a@example.net",
+    "origin": "null",
+    "protocol": "sc:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": ":a@example.net",
+    "search": "",
+    "hash": ""
+  },
+  "# unknown scheme with bogus percent-encoding",
+  {
+    "input": "wow:%NBD",
+    "base": null,
+    "href": "wow:%NBD",
+    "origin": "null",
+    "protocol": "wow:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "%NBD",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "wow:%1G",
+    "base": null,
+    "href": "wow:%1G",
+    "origin": "null",
+    "protocol": "wow:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "%1G",
+    "search": "",
+    "hash": ""
+  },
+  "# unknown scheme with non-URL characters",
+  {
+    "input": "wow:\uFFFF",
+    "base": null,
+    "href": "wow:%EF%BF%BF",
+    "origin": "null",
+    "protocol": "wow:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "%EF%BF%BF",
+    "search": "",
+    "hash": ""
+  },
+  "Forbidden host code points",
+  {
+    "input": "sc://a\u0000b/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "sc://a b/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "sc://a<b",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "sc://a>b",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "sc://a[b/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "sc://a\\b/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "sc://a]b/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "sc://a^b",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "sc://a|b/",
+    "base": null,
+    "failure": true
+  },
+  "Forbidden host codepoints: tabs and newlines are removed during preprocessing",
+  {
+    "input": "foo://ho\u0009st/",
+    "base": null,
+    "hash": "",
+    "host": "host",
+    "hostname": "host",
+    "href":"foo://host/",
+    "password": "",
+    "pathname": "/",
+    "port":"",
+    "protocol": "foo:",
+    "search": "",
+    "username": ""
+  },
+  {
+    "input": "foo://ho\u000Ast/",
+    "base": null,
+    "hash": "",
+    "host": "host",
+    "hostname": "host",
+    "href":"foo://host/",
+    "password": "",
+    "pathname": "/",
+    "port":"",
+    "protocol": "foo:",
+    "search": "",
+    "username": ""
+  },
+  {
+    "input": "foo://ho\u000Dst/",
+    "base": null,
+    "hash": "",
+    "host": "host",
+    "hostname": "host",
+    "href":"foo://host/",
+    "password": "",
+    "pathname": "/",
+    "port":"",
+    "protocol": "foo:",
+    "search": "",
+    "username": ""
+  },
+  "Forbidden domain code-points",
+  {
+    "input": "http://a\u0000b/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://a\u0001b/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://a\u0002b/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://a\u0003b/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://a\u0004b/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://a\u0005b/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://a\u0006b/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://a\u0007b/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://a\u0008b/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://a\u000Bb/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://a\u000Cb/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://a\u000Eb/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://a\u000Fb/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://a\u0010b/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://a\u0011b/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://a\u0012b/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://a\u0013b/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://a\u0014b/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://a\u0015b/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://a\u0016b/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://a\u0017b/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://a\u0018b/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://a\u0019b/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://a\u001Ab/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://a\u001Bb/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://a\u001Cb/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://a\u001Db/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://a\u001Eb/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://a\u001Fb/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://a b/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://a%b/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://a<b",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://a>b",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://a[b/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://a]b/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://a^b",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://a|b/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://a\u007Fb/",
+    "base": null,
+    "failure": true
+  },
+  "Forbidden domain codepoints: tabs and newlines are removed during preprocessing",
+  {
+    "input": "http://ho\u0009st/",
+    "base": null,
+    "hash": "",
+    "host": "host",
+    "hostname": "host",
+    "href":"http://host/",
+    "password": "",
+    "pathname": "/",
+    "port":"",
+    "protocol": "http:",
+    "search": "",
+    "username": ""
+  },
+  {
+    "input": "http://ho\u000Ast/",
+    "base": null,
+    "hash": "",
+    "host": "host",
+    "hostname": "host",
+    "href":"http://host/",
+    "password": "",
+    "pathname": "/",
+    "port":"",
+    "protocol": "http:",
+    "search": "",
+    "username": ""
+  },
+  {
+    "input": "http://ho\u000Dst/",
+    "base": null,
+    "hash": "",
+    "host": "host",
+    "hostname": "host",
+    "href":"http://host/",
+    "password": "",
+    "pathname": "/",
+    "port":"",
+    "protocol": "http:",
+    "search": "",
+    "username": ""
+  },
+  "Encoded forbidden domain codepoints in special URLs",
+  {
+    "input": "http://ho%00st/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%01st/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%02st/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%03st/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%04st/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%05st/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%06st/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%07st/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%08st/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%09st/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%0Ast/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%0Bst/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%0Cst/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%0Dst/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%0Est/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%0Fst/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%10st/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%11st/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%12st/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%13st/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%14st/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%15st/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%16st/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%17st/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%18st/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%19st/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%1Ast/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%1Bst/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%1Cst/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%1Dst/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%1Est/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%1Fst/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%20st/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%23st/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%25st/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%2Fst/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%3Ast/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%3Cst/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%3Est/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%3Fst/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%40st/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%5Bst/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%5Cst/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%5Dst/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%7Cst/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://ho%7Fst/",
+    "base": null,
+    "failure": true
+  },
+  "Allowed host/domain code points",
+  {
+    "input": "http://!\"$&'()*+,-.;=_`{}~/",
+    "base": null,
+    "href": "http://!\"$&'()*+,-.;=_`{}~/",
+    "origin": "http://!\"$&'()*+,-.;=_`{}~",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "!\"$&'()*+,-.;=_`{}~",
+    "hostname": "!\"$&'()*+,-.;=_`{}~",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "sc://\u0001\u0002\u0003\u0004\u0005\u0006\u0007\u0008\u000B\u000C\u000E\u000F\u0010\u0011\u0012\u0013\u0014\u0015\u0016\u0017\u0018\u0019\u001A\u001B\u001C\u001D\u001E\u001F\u007F!\"$%&'()*+,-.;=_`{}~/",
+    "base": null,
+    "href": "sc://%01%02%03%04%05%06%07%08%0B%0C%0E%0F%10%11%12%13%14%15%16%17%18%19%1A%1B%1C%1D%1E%1F%7F!\"$%&'()*+,-.;=_`{}~/",
+    "origin": "null",
+    "protocol": "sc:",
+    "username": "",
+    "password": "",
+    "host": "%01%02%03%04%05%06%07%08%0B%0C%0E%0F%10%11%12%13%14%15%16%17%18%19%1A%1B%1C%1D%1E%1F%7F!\"$%&'()*+,-.;=_`{}~",
+    "hostname": "%01%02%03%04%05%06%07%08%0B%0C%0E%0F%10%11%12%13%14%15%16%17%18%19%1A%1B%1C%1D%1E%1F%7F!\"$%&'()*+,-.;=_`{}~",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  "# Hosts and percent-encoding",
+  {
+    "input": "ftp://example.com%80/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "ftp://example.com%A0/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "https://example.com%80/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "https://example.com%A0/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "ftp://%e2%98%83",
+    "base": null,
+    "href": "ftp://xn--n3h/",
+    "origin": "ftp://xn--n3h",
+    "protocol": "ftp:",
+    "username": "",
+    "password": "",
+    "host": "xn--n3h",
+    "hostname": "xn--n3h",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "https://%e2%98%83",
+    "base": null,
+    "href": "https://xn--n3h/",
+    "origin": "https://xn--n3h",
+    "protocol": "https:",
+    "username": "",
+    "password": "",
+    "host": "xn--n3h",
+    "hostname": "xn--n3h",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  "# tests from jsdom/whatwg-url designed for code coverage",
+  {
+    "input": "http://127.0.0.1:10100/relative_import.html",
+    "base": null,
+    "href": "http://127.0.0.1:10100/relative_import.html",
+    "origin": "http://127.0.0.1:10100",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "127.0.0.1:10100",
+    "hostname": "127.0.0.1",
+    "port": "10100",
+    "pathname": "/relative_import.html",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://facebook.com/?foo=%7B%22abc%22",
+    "base": null,
+    "href": "http://facebook.com/?foo=%7B%22abc%22",
+    "origin": "http://facebook.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "facebook.com",
+    "hostname": "facebook.com",
+    "port": "",
+    "pathname": "/",
+    "search": "?foo=%7B%22abc%22",
+    "hash": ""
+  },
+  {
+    "input": "https://localhost:3000/jqueryui@1.2.3",
+    "base": null,
+    "href": "https://localhost:3000/jqueryui@1.2.3",
+    "origin": "https://localhost:3000",
+    "protocol": "https:",
+    "username": "",
+    "password": "",
+    "host": "localhost:3000",
+    "hostname": "localhost",
+    "port": "3000",
+    "pathname": "/jqueryui@1.2.3",
+    "search": "",
+    "hash": ""
+  },
+  "# tab/LF/CR",
+  {
+    "input": "h\tt\nt\rp://h\to\ns\rt:9\t0\n0\r0/p\ta\nt\rh?q\tu\ne\rry#f\tr\na\rg",
+    "base": null,
+    "href": "http://host:9000/path?query#frag",
+    "origin": "http://host:9000",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "host:9000",
+    "hostname": "host",
+    "port": "9000",
+    "pathname": "/path",
+    "search": "?query",
+    "hash": "#frag"
+  },
+  "# Stringification of URL.searchParams",
+  {
+    "input": "?a=b&c=d",
+    "base": "http://example.org/foo/bar",
+    "href": "http://example.org/foo/bar?a=b&c=d",
+    "origin": "http://example.org",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/foo/bar",
+    "search": "?a=b&c=d",
+    "searchParams": "a=b&c=d",
+    "hash": ""
+  },
+  {
+    "input": "??a=b&c=d",
+    "base": "http://example.org/foo/bar",
+    "href": "http://example.org/foo/bar??a=b&c=d",
+    "origin": "http://example.org",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/foo/bar",
+    "search": "??a=b&c=d",
+    "searchParams": "%3Fa=b&c=d",
+    "hash": ""
+  },
+  "# Scheme only",
+  {
+    "input": "http:",
+    "base": "http://example.org/foo/bar",
+    "href": "http://example.org/foo/bar",
+    "origin": "http://example.org",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/foo/bar",
+    "search": "",
+    "searchParams": "",
+    "hash": ""
+  },
+  {
+    "input": "http:",
+    "base": "https://example.org/foo/bar",
+    "failure": true
+  },
+  {
+    "input": "sc:",
+    "base": "https://example.org/foo/bar",
+    "href": "sc:",
+    "origin": "null",
+    "protocol": "sc:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "",
+    "search": "",
+    "searchParams": "",
+    "hash": ""
+  },
+  "# Percent encoding of fragments",
+  {
+    "input": "http://foo.bar/baz?qux#foo\bbar",
+    "base": null,
+    "href": "http://foo.bar/baz?qux#foo%08bar",
+    "origin": "http://foo.bar",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "foo.bar",
+    "hostname": "foo.bar",
+    "port": "",
+    "pathname": "/baz",
+    "search": "?qux",
+    "searchParams": "qux=",
+    "hash": "#foo%08bar"
+  },
+  {
+    "input": "http://foo.bar/baz?qux#foo\"bar",
+    "base": null,
+    "href": "http://foo.bar/baz?qux#foo%22bar",
+    "origin": "http://foo.bar",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "foo.bar",
+    "hostname": "foo.bar",
+    "port": "",
+    "pathname": "/baz",
+    "search": "?qux",
+    "searchParams": "qux=",
+    "hash": "#foo%22bar"
+  },
+  {
+    "input": "http://foo.bar/baz?qux#foo<bar",
+    "base": null,
+    "href": "http://foo.bar/baz?qux#foo%3Cbar",
+    "origin": "http://foo.bar",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "foo.bar",
+    "hostname": "foo.bar",
+    "port": "",
+    "pathname": "/baz",
+    "search": "?qux",
+    "searchParams": "qux=",
+    "hash": "#foo%3Cbar"
+  },
+  {
+    "input": "http://foo.bar/baz?qux#foo>bar",
+    "base": null,
+    "href": "http://foo.bar/baz?qux#foo%3Ebar",
+    "origin": "http://foo.bar",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "foo.bar",
+    "hostname": "foo.bar",
+    "port": "",
+    "pathname": "/baz",
+    "search": "?qux",
+    "searchParams": "qux=",
+    "hash": "#foo%3Ebar"
+  },
+  {
+    "input": "http://foo.bar/baz?qux#foo`bar",
+    "base": null,
+    "href": "http://foo.bar/baz?qux#foo%60bar",
+    "origin": "http://foo.bar",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "foo.bar",
+    "hostname": "foo.bar",
+    "port": "",
+    "pathname": "/baz",
+    "search": "?qux",
+    "searchParams": "qux=",
+    "hash": "#foo%60bar"
+  },
+  "# IPv4 parsing (via https://github.com/nodejs/node/pull/10317)",
+  {
+    "input": "http://1.2.3.4/",
+    "base": "http://other.com/",
+    "href": "http://1.2.3.4/",
+    "origin": "http://1.2.3.4",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "1.2.3.4",
+    "hostname": "1.2.3.4",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://1.2.3.4./",
+    "base": "http://other.com/",
+    "href": "http://1.2.3.4/",
+    "origin": "http://1.2.3.4",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "1.2.3.4",
+    "hostname": "1.2.3.4",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://192.168.257",
+    "base": "http://other.com/",
+    "href": "http://192.168.1.1/",
+    "origin": "http://192.168.1.1",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "192.168.1.1",
+    "hostname": "192.168.1.1",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://192.168.257.",
+    "base": "http://other.com/",
+    "href": "http://192.168.1.1/",
+    "origin": "http://192.168.1.1",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "192.168.1.1",
+    "hostname": "192.168.1.1",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://192.168.257.com",
+    "base": "http://other.com/",
+    "href": "http://192.168.257.com/",
+    "origin": "http://192.168.257.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "192.168.257.com",
+    "hostname": "192.168.257.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://256",
+    "base": "http://other.com/",
+    "href": "http://0.0.1.0/",
+    "origin": "http://0.0.1.0",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "0.0.1.0",
+    "hostname": "0.0.1.0",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://256.com",
+    "base": "http://other.com/",
+    "href": "http://256.com/",
+    "origin": "http://256.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "256.com",
+    "hostname": "256.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://999999999",
+    "base": "http://other.com/",
+    "href": "http://59.154.201.255/",
+    "origin": "http://59.154.201.255",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "59.154.201.255",
+    "hostname": "59.154.201.255",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://999999999.",
+    "base": "http://other.com/",
+    "href": "http://59.154.201.255/",
+    "origin": "http://59.154.201.255",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "59.154.201.255",
+    "hostname": "59.154.201.255",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://999999999.com",
+    "base": "http://other.com/",
+    "href": "http://999999999.com/",
+    "origin": "http://999999999.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "999999999.com",
+    "hostname": "999999999.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://10000000000",
+    "base": "http://other.com/",
+    "failure": true
+  },
+  {
+    "input": "http://10000000000.com",
+    "base": "http://other.com/",
+    "href": "http://10000000000.com/",
+    "origin": "http://10000000000.com",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "10000000000.com",
+    "hostname": "10000000000.com",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://4294967295",
+    "base": "http://other.com/",
+    "href": "http://255.255.255.255/",
+    "origin": "http://255.255.255.255",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "255.255.255.255",
+    "hostname": "255.255.255.255",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://4294967296",
+    "base": "http://other.com/",
+    "failure": true
+  },
+  {
+    "input": "http://0xffffffff",
+    "base": "http://other.com/",
+    "href": "http://255.255.255.255/",
+    "origin": "http://255.255.255.255",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "255.255.255.255",
+    "hostname": "255.255.255.255",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://0xffffffff1",
+    "base": "http://other.com/",
+    "failure": true
+  },
+  {
+    "input": "http://256.256.256.256",
+    "base": "http://other.com/",
+    "failure": true
+  },
+  {
+    "input": "https://0x.0x.0",
+    "base": null,
+    "href": "https://0.0.0.0/",
+    "origin": "https://0.0.0.0",
+    "protocol": "https:",
+    "username": "",
+    "password": "",
+    "host": "0.0.0.0",
+    "hostname": "0.0.0.0",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  "More IPv4 parsing (via https://github.com/jsdom/whatwg-url/issues/92)",
+  {
+    "input": "https://0x100000000/test",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "https://256.0.0.1/test",
+    "base": null,
+    "failure": true
+  },
+  "# file URLs containing percent-encoded Windows drive letters (shouldn't work)",
+  {
+    "input": "file:///C%3A/",
+    "base": null,
+    "href": "file:///C%3A/",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/C%3A/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file:///C%7C/",
+    "base": null,
+    "href": "file:///C%7C/",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/C%7C/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file://%43%3A",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "file://%43%7C",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "file://%43|",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "file://C%7C",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "file://%43%7C/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "https://%43%7C/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "asdf://%43|/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "asdf://%43%7C/",
+    "base": null,
+    "href": "asdf://%43%7C/",
+    "origin": "null",
+    "protocol": "asdf:",
+    "username": "",
+    "password": "",
+    "host": "%43%7C",
+    "hostname": "%43%7C",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  "# file URLs relative to other file URLs (via https://github.com/jsdom/whatwg-url/pull/60)",
+  {
+    "input": "pix/submit.gif",
+    "base": "file:///C:/Users/Domenic/Dropbox/GitHub/tmpvar/jsdom/test/level2/html/files/anchor.html",
+    "href": "file:///C:/Users/Domenic/Dropbox/GitHub/tmpvar/jsdom/test/level2/html/files/pix/submit.gif",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/C:/Users/Domenic/Dropbox/GitHub/tmpvar/jsdom/test/level2/html/files/pix/submit.gif",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "..",
+    "base": "file:///C:/",
+    "href": "file:///C:/",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/C:/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "..",
+    "base": "file:///",
+    "href": "file:///",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  "# More file URL tests by zcorpan and annevk",
+  {
+    "input": "/",
+    "base": "file:///C:/a/b",
+    "href": "file:///C:/",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/C:/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "/",
+    "base": "file://h/C:/a/b",
+    "href": "file://h/C:/",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "h",
+    "hostname": "h",
+    "port": "",
+    "pathname": "/C:/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "/",
+    "base": "file://h/a/b",
+    "href": "file://h/",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "h",
+    "hostname": "h",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "//d:",
+    "base": "file:///C:/a/b",
+    "href": "file:///d:",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/d:",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "//d:/..",
+    "base": "file:///C:/a/b",
+    "href": "file:///d:/",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/d:/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "..",
+    "base": "file:///ab:/",
+    "href": "file:///",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "..",
+    "base": "file:///1:/",
+    "href": "file:///",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "",
+    "base": "file:///test?test#test",
+    "href": "file:///test?test",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/test",
+    "search": "?test",
+    "hash": ""
+  },
+  {
+    "input": "file:",
+    "base": "file:///test?test#test",
+    "href": "file:///test?test",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/test",
+    "search": "?test",
+    "hash": ""
+  },
+  {
+    "input": "?x",
+    "base": "file:///test?test#test",
+    "href": "file:///test?x",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/test",
+    "search": "?x",
+    "hash": ""
+  },
+  {
+    "input": "file:?x",
+    "base": "file:///test?test#test",
+    "href": "file:///test?x",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/test",
+    "search": "?x",
+    "hash": ""
+  },
+  {
+    "input": "#x",
+    "base": "file:///test?test#test",
+    "href": "file:///test?test#x",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/test",
+    "search": "?test",
+    "hash": "#x"
+  },
+  {
+    "input": "file:#x",
+    "base": "file:///test?test#test",
+    "href": "file:///test?test#x",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/test",
+    "search": "?test",
+    "hash": "#x"
+  },
+  "# File URLs and many (back)slashes",
+  {
+    "input": "file:\\\\//",
+    "base": null,
+    "href": "file:////",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "//",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file:\\\\\\\\",
+    "base": null,
+    "href": "file:////",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "//",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file:\\\\\\\\?fox",
+    "base": null,
+    "href": "file:////?fox",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "//",
+    "search": "?fox",
+    "hash": ""
+  },
+  {
+    "input": "file:\\\\\\\\#guppy",
+    "base": null,
+    "href": "file:////#guppy",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "//",
+    "search": "",
+    "hash": "#guppy"
+  },
+  {
+    "input": "file://spider///",
+    "base": null,
+    "href": "file://spider///",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "spider",
+    "hostname": "spider",
+    "port": "",
+    "pathname": "///",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file:\\\\localhost//",
+    "base": null,
+    "href": "file:////",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "//",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file:///localhost//cat",
+    "base": null,
+    "href": "file:///localhost//cat",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/localhost//cat",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file://\\/localhost//cat",
+    "base": null,
+    "href": "file:////localhost//cat",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "//localhost//cat",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file://localhost//a//../..//",
+    "base": null,
+    "href": "file://///",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "///",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "/////mouse",
+    "base": "file:///elephant",
+    "href": "file://///mouse",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "///mouse",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "\\//pig",
+    "base": "file://lion/",
+    "href": "file:///pig",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/pig",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "\\/localhost//pig",
+    "base": "file://lion/",
+    "href": "file:////pig",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "//pig",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "//localhost//pig",
+    "base": "file://lion/",
+    "href": "file:////pig",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "//pig",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "/..//localhost//pig",
+    "base": "file://lion/",
+    "href": "file://lion//localhost//pig",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "lion",
+    "hostname": "lion",
+    "port": "",
+    "pathname": "//localhost//pig",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file://",
+    "base": "file://ape/",
+    "href": "file:///",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  "# File URLs with non-empty hosts",
+  {
+    "input": "/rooibos",
+    "base": "file://tea/",
+    "href": "file://tea/rooibos",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "tea",
+    "hostname": "tea",
+    "port": "",
+    "pathname": "/rooibos",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "/?chai",
+    "base": "file://tea/",
+    "href": "file://tea/?chai",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "tea",
+    "hostname": "tea",
+    "port": "",
+    "pathname": "/",
+    "search": "?chai",
+    "hash": ""
+  },
+  "# Windows drive letter handling with the 'file:' base URL",
+  {
+    "input": "C|",
+    "base": "file://host/dir/file",
+    "href": "file://host/C:",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "host",
+    "hostname": "host",
+    "port": "",
+    "pathname": "/C:",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "C|",
+    "base": "file://host/D:/dir1/dir2/file",
+    "href": "file://host/C:",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "host",
+    "hostname": "host",
+    "port": "",
+    "pathname": "/C:",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "C|#",
+    "base": "file://host/dir/file",
+    "href": "file://host/C:#",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "host",
+    "hostname": "host",
+    "port": "",
+    "pathname": "/C:",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "C|?",
+    "base": "file://host/dir/file",
+    "href": "file://host/C:?",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "host",
+    "hostname": "host",
+    "port": "",
+    "pathname": "/C:",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "C|/",
+    "base": "file://host/dir/file",
+    "href": "file://host/C:/",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "host",
+    "hostname": "host",
+    "port": "",
+    "pathname": "/C:/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "C|\n/",
+    "base": "file://host/dir/file",
+    "href": "file://host/C:/",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "host",
+    "hostname": "host",
+    "port": "",
+    "pathname": "/C:/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "C|\\",
+    "base": "file://host/dir/file",
+    "href": "file://host/C:/",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "host",
+    "hostname": "host",
+    "port": "",
+    "pathname": "/C:/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "C",
+    "base": "file://host/dir/file",
+    "href": "file://host/dir/C",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "host",
+    "hostname": "host",
+    "port": "",
+    "pathname": "/dir/C",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "C|a",
+    "base": "file://host/dir/file",
+    "href": "file://host/dir/C|a",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "host",
+    "hostname": "host",
+    "port": "",
+    "pathname": "/dir/C|a",
+    "search": "",
+    "hash": ""
+  },
+  "# Windows drive letter quirk in the file slash state",
+  {
+    "input": "/c:/foo/bar",
+    "base": "file:///c:/baz/qux",
+    "href": "file:///c:/foo/bar",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/c:/foo/bar",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "/c|/foo/bar",
+    "base": "file:///c:/baz/qux",
+    "href": "file:///c:/foo/bar",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/c:/foo/bar",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file:\\c:\\foo\\bar",
+    "base": "file:///c:/baz/qux",
+    "href": "file:///c:/foo/bar",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/c:/foo/bar",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "/c:/foo/bar",
+    "base": "file://host/path",
+    "href": "file://host/c:/foo/bar",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "host",
+    "hostname": "host",
+    "port": "",
+    "pathname": "/c:/foo/bar",
+    "search": "",
+    "hash": ""
+  },
+  "# Do not drop the host in the presence of a drive letter",
+  {
+    "input": "file://example.net/C:/",
+    "base": null,
+    "href": "file://example.net/C:/",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "example.net",
+    "hostname": "example.net",
+    "port": "",
+    "pathname": "/C:/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file://1.2.3.4/C:/",
+    "base": null,
+    "href": "file://1.2.3.4/C:/",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "1.2.3.4",
+    "hostname": "1.2.3.4",
+    "port": "",
+    "pathname": "/C:/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file://[1::8]/C:/",
+    "base": null,
+    "href": "file://[1::8]/C:/",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "[1::8]",
+    "hostname": "[1::8]",
+    "port": "",
+    "pathname": "/C:/",
+    "search": "",
+    "hash": ""
+  },
+  "# Copy the host from the base URL in the following cases",
+  {
+    "input": "C|/",
+    "base": "file://host/",
+    "href": "file://host/C:/",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "host",
+    "hostname": "host",
+    "port": "",
+    "pathname": "/C:/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "/C:/",
+    "base": "file://host/",
+    "href": "file://host/C:/",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "host",
+    "hostname": "host",
+    "port": "",
+    "pathname": "/C:/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file:C:/",
+    "base": "file://host/",
+    "href": "file://host/C:/",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "host",
+    "hostname": "host",
+    "port": "",
+    "pathname": "/C:/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file:/C:/",
+    "base": "file://host/",
+    "href": "file://host/C:/",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "host",
+    "hostname": "host",
+    "port": "",
+    "pathname": "/C:/",
+    "search": "",
+    "hash": ""
+  },
+  "# Copy the empty host from the input in the following cases",
+  {
+    "input": "//C:/",
+    "base": "file://host/",
+    "href": "file:///C:/",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/C:/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file://C:/",
+    "base": "file://host/",
+    "href": "file:///C:/",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/C:/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "///C:/",
+    "base": "file://host/",
+    "href": "file:///C:/",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/C:/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file:///C:/",
+    "base": "file://host/",
+    "href": "file:///C:/",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/C:/",
+    "search": "",
+    "hash": ""
+  },
+  "# Windows drive letter quirk (no host)",
+  {
+    "input": "file:/C|/",
+    "base": null,
+    "href": "file:///C:/",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/C:/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file://C|/",
+    "base": null,
+    "href": "file:///C:/",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/C:/",
+    "search": "",
+    "hash": ""
+  },
+  "# file URLs without base URL by Rimas Misevičius",
+  {
+    "input": "file:",
+    "base": null,
+    "href": "file:///",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file:?q=v",
+    "base": null,
+    "href": "file:///?q=v",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/",
+    "search": "?q=v",
+    "hash": ""
+  },
+  {
+    "input": "file:#frag",
+    "base": null,
+    "href": "file:///#frag",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": "#frag"
+  },
+  "# file: drive letter cases from https://crbug.com/1078698",
+  {
+    "input": "file:///Y:",
+    "base": null,
+    "href": "file:///Y:",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/Y:",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file:///Y:/",
+    "base": null,
+    "href": "file:///Y:/",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/Y:/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file:///./Y",
+    "base": null,
+    "href": "file:///Y",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/Y",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file:///./Y:",
+    "base": null,
+    "href": "file:///Y:",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/Y:",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "\\\\\\.\\Y:",
+    "base": null,
+    "failure": true,
+    "relativeTo": "non-opaque-path-base"
+  },
+  "# file: drive letter cases from https://crbug.com/1078698 but lowercased",
+  {
+    "input": "file:///y:",
+    "base": null,
+    "href": "file:///y:",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/y:",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file:///y:/",
+    "base": null,
+    "href": "file:///y:/",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/y:/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file:///./y",
+    "base": null,
+    "href": "file:///y",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/y",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file:///./y:",
+    "base": null,
+    "href": "file:///y:",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/y:",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "\\\\\\.\\y:",
+    "base": null,
+    "failure": true,
+    "relativeTo": "non-opaque-path-base"
+  },
+  "# Additional file URL tests for (https://github.com/whatwg/url/issues/405)",
+  {
+    "input": "file://localhost//a//../..//foo",
+    "base": null,
+    "href": "file://///foo",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "///foo",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file://localhost////foo",
+    "base": null,
+    "href": "file://////foo",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "////foo",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file:////foo",
+    "base": null,
+    "href": "file:////foo",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "//foo",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file:///one/two",
+    "base": "file:///",
+    "href": "file:///one/two",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/one/two",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file:////one/two",
+    "base": "file:///",
+    "href": "file:////one/two",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "//one/two",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "//one/two",
+    "base": "file:///",
+    "href": "file://one/two",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "one",
+    "hostname": "one",
+    "port": "",
+    "pathname": "/two",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "///one/two",
+    "base": "file:///",
+    "href": "file:///one/two",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/one/two",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "////one/two",
+    "base": "file:///",
+    "href": "file:////one/two",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "//one/two",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file:///.//",
+    "base": "file:////",
+    "href": "file:////",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "//",
+    "search": "",
+    "hash": ""
+  },
+  "File URL tests for https://github.com/whatwg/url/issues/549",
+  {
+    "input": "file:.//p",
+    "base": null,
+    "href": "file:////p",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "//p",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file:/.//p",
+    "base": null,
+    "href": "file:////p",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "//p",
+    "search": "",
+    "hash": ""
+  },
+  "# IPv6 tests",
+  {
+    "input": "http://[1:0::]",
+    "base": "http://example.net/",
+    "href": "http://[1::]/",
+    "origin": "http://[1::]",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "[1::]",
+    "hostname": "[1::]",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://[0:1:2:3:4:5:6:7:8]",
+    "base": "http://example.net/",
+    "failure": true
+  },
+  {
+    "input": "https://[0::0::0]",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "https://[0:.0]",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "https://[0:0:]",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "https://[0:1:2:3:4:5:6:7.0.0.0.1]",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "https://[0:1.00.0.0.0]",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "https://[0:1.290.0.0.0]",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "https://[0:1.23.23]",
+    "base": null,
+    "failure": true
+  },
+  "# Empty host",
+  {
+    "input": "http://?",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://#",
+    "base": null,
+    "failure": true
+  },
+  "Port overflow (2^32 + 81)",
+  {
+    "input": "http://f:4294967377/c",
+    "base": "http://example.org/",
+    "failure": true
+  },
+  "Port overflow (2^64 + 81)",
+  {
+    "input": "http://f:18446744073709551697/c",
+    "base": "http://example.org/",
+    "failure": true
+  },
+  "Port overflow (2^128 + 81)",
+  {
+    "input": "http://f:340282366920938463463374607431768211537/c",
+    "base": "http://example.org/",
+    "failure": true
+  },
+  "# Non-special-URL path tests",
+  {
+    "input": "sc://ñ",
+    "base": null,
+    "href": "sc://%C3%B1",
+    "origin": "null",
+    "protocol": "sc:",
+    "username": "",
+    "password": "",
+    "host": "%C3%B1",
+    "hostname": "%C3%B1",
+    "port": "",
+    "pathname": "",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "sc://ñ?x",
+    "base": null,
+    "href": "sc://%C3%B1?x",
+    "origin": "null",
+    "protocol": "sc:",
+    "username": "",
+    "password": "",
+    "host": "%C3%B1",
+    "hostname": "%C3%B1",
+    "port": "",
+    "pathname": "",
+    "search": "?x",
+    "hash": ""
+  },
+  {
+    "input": "sc://ñ#x",
+    "base": null,
+    "href": "sc://%C3%B1#x",
+    "origin": "null",
+    "protocol": "sc:",
+    "username": "",
+    "password": "",
+    "host": "%C3%B1",
+    "hostname": "%C3%B1",
+    "port": "",
+    "pathname": "",
+    "search": "",
+    "hash": "#x"
+  },
+  {
+    "input": "#x",
+    "base": "sc://ñ",
+    "href": "sc://%C3%B1#x",
+    "origin": "null",
+    "protocol": "sc:",
+    "username": "",
+    "password": "",
+    "host": "%C3%B1",
+    "hostname": "%C3%B1",
+    "port": "",
+    "pathname": "",
+    "search": "",
+    "hash": "#x"
+  },
+  {
+    "input": "?x",
+    "base": "sc://ñ",
+    "href": "sc://%C3%B1?x",
+    "origin": "null",
+    "protocol": "sc:",
+    "username": "",
+    "password": "",
+    "host": "%C3%B1",
+    "hostname": "%C3%B1",
+    "port": "",
+    "pathname": "",
+    "search": "?x",
+    "hash": ""
+  },
+  {
+    "input": "sc://?",
+    "base": null,
+    "href": "sc://?",
+    "protocol": "sc:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "sc://#",
+    "base": null,
+    "href": "sc://#",
+    "protocol": "sc:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "///",
+    "base": "sc://x/",
+    "href": "sc:///",
+    "protocol": "sc:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "////",
+    "base": "sc://x/",
+    "href": "sc:////",
+    "protocol": "sc:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "//",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "////x/",
+    "base": "sc://x/",
+    "href": "sc:////x/",
+    "protocol": "sc:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "//x/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "tftp://foobar.com/someconfig;mode=netascii",
+    "base": null,
+    "href": "tftp://foobar.com/someconfig;mode=netascii",
+    "origin": "null",
+    "protocol": "tftp:",
+    "username": "",
+    "password": "",
+    "host": "foobar.com",
+    "hostname": "foobar.com",
+    "port": "",
+    "pathname": "/someconfig;mode=netascii",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "telnet://user:pass@foobar.com:23/",
+    "base": null,
+    "href": "telnet://user:pass@foobar.com:23/",
+    "origin": "null",
+    "protocol": "telnet:",
+    "username": "user",
+    "password": "pass",
+    "host": "foobar.com:23",
+    "hostname": "foobar.com",
+    "port": "23",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "ut2004://10.10.10.10:7777/Index.ut2",
+    "base": null,
+    "href": "ut2004://10.10.10.10:7777/Index.ut2",
+    "origin": "null",
+    "protocol": "ut2004:",
+    "username": "",
+    "password": "",
+    "host": "10.10.10.10:7777",
+    "hostname": "10.10.10.10",
+    "port": "7777",
+    "pathname": "/Index.ut2",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "redis://foo:bar@somehost:6379/0?baz=bam&qux=baz",
+    "base": null,
+    "href": "redis://foo:bar@somehost:6379/0?baz=bam&qux=baz",
+    "origin": "null",
+    "protocol": "redis:",
+    "username": "foo",
+    "password": "bar",
+    "host": "somehost:6379",
+    "hostname": "somehost",
+    "port": "6379",
+    "pathname": "/0",
+    "search": "?baz=bam&qux=baz",
+    "hash": ""
+  },
+  {
+    "input": "rsync://foo@host:911/sup",
+    "base": null,
+    "href": "rsync://foo@host:911/sup",
+    "origin": "null",
+    "protocol": "rsync:",
+    "username": "foo",
+    "password": "",
+    "host": "host:911",
+    "hostname": "host",
+    "port": "911",
+    "pathname": "/sup",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "git://github.com/foo/bar.git",
+    "base": null,
+    "href": "git://github.com/foo/bar.git",
+    "origin": "null",
+    "protocol": "git:",
+    "username": "",
+    "password": "",
+    "host": "github.com",
+    "hostname": "github.com",
+    "port": "",
+    "pathname": "/foo/bar.git",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "irc://myserver.com:6999/channel?passwd",
+    "base": null,
+    "href": "irc://myserver.com:6999/channel?passwd",
+    "origin": "null",
+    "protocol": "irc:",
+    "username": "",
+    "password": "",
+    "host": "myserver.com:6999",
+    "hostname": "myserver.com",
+    "port": "6999",
+    "pathname": "/channel",
+    "search": "?passwd",
+    "hash": ""
+  },
+  {
+    "input": "dns://fw.example.org:9999/foo.bar.org?type=TXT",
+    "base": null,
+    "href": "dns://fw.example.org:9999/foo.bar.org?type=TXT",
+    "origin": "null",
+    "protocol": "dns:",
+    "username": "",
+    "password": "",
+    "host": "fw.example.org:9999",
+    "hostname": "fw.example.org",
+    "port": "9999",
+    "pathname": "/foo.bar.org",
+    "search": "?type=TXT",
+    "hash": ""
+  },
+  {
+    "input": "ldap://localhost:389/ou=People,o=JNDITutorial",
+    "base": null,
+    "href": "ldap://localhost:389/ou=People,o=JNDITutorial",
+    "origin": "null",
+    "protocol": "ldap:",
+    "username": "",
+    "password": "",
+    "host": "localhost:389",
+    "hostname": "localhost",
+    "port": "389",
+    "pathname": "/ou=People,o=JNDITutorial",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "git+https://github.com/foo/bar",
+    "base": null,
+    "href": "git+https://github.com/foo/bar",
+    "origin": "null",
+    "protocol": "git+https:",
+    "username": "",
+    "password": "",
+    "host": "github.com",
+    "hostname": "github.com",
+    "port": "",
+    "pathname": "/foo/bar",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "urn:ietf:rfc:2648",
+    "base": null,
+    "href": "urn:ietf:rfc:2648",
+    "origin": "null",
+    "protocol": "urn:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "ietf:rfc:2648",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "tag:joe@example.org,2001:foo/bar",
+    "base": null,
+    "href": "tag:joe@example.org,2001:foo/bar",
+    "origin": "null",
+    "protocol": "tag:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "joe@example.org,2001:foo/bar",
+    "search": "",
+    "hash": ""
+  },
+  "Serialize /. in path",
+  {
+    "input": "non-spec:/.//",
+    "base": null,
+    "href": "non-spec:/.//",
+    "protocol": "non-spec:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "//",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "non-spec:/..//",
+    "base": null,
+    "href": "non-spec:/.//",
+    "protocol": "non-spec:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "//",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "non-spec:/a/..//",
+    "base": null,
+    "href": "non-spec:/.//",
+    "protocol": "non-spec:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "//",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "non-spec:/.//path",
+    "base": null,
+    "href": "non-spec:/.//path",
+    "protocol": "non-spec:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "//path",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "non-spec:/..//path",
+    "base": null,
+    "href": "non-spec:/.//path",
+    "protocol": "non-spec:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "//path",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "non-spec:/a/..//path",
+    "base": null,
+    "href": "non-spec:/.//path",
+    "protocol": "non-spec:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "//path",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "/.//path",
+    "base": "non-spec:/p",
+    "href": "non-spec:/.//path",
+    "protocol": "non-spec:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "//path",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "/..//path",
+    "base": "non-spec:/p",
+    "href": "non-spec:/.//path",
+    "protocol": "non-spec:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "//path",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "..//path",
+    "base": "non-spec:/p",
+    "href": "non-spec:/.//path",
+    "protocol": "non-spec:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "//path",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "a/..//path",
+    "base": "non-spec:/p",
+    "href": "non-spec:/.//path",
+    "protocol": "non-spec:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "//path",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "",
+    "base": "non-spec:/..//p",
+    "href": "non-spec:/.//p",
+    "protocol": "non-spec:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "//p",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "path",
+    "base": "non-spec:/..//p",
+    "href": "non-spec:/.//path",
+    "protocol": "non-spec:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "//path",
+    "search": "",
+    "hash": ""
+  },
+  "Do not serialize /. in path",
+  {
+    "input": "../path",
+    "base": "non-spec:/.//p",
+    "href": "non-spec:/path",
+    "protocol": "non-spec:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/path",
+    "search": "",
+    "hash": ""
+  },
+  "# percent encoded hosts in non-special-URLs",
+  {
+    "input": "non-special://%E2%80%A0/",
+    "base": null,
+    "href": "non-special://%E2%80%A0/",
+    "protocol": "non-special:",
+    "username": "",
+    "password": "",
+    "host": "%E2%80%A0",
+    "hostname": "%E2%80%A0",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "non-special://H%4fSt/path",
+    "base": null,
+    "href": "non-special://H%4fSt/path",
+    "protocol": "non-special:",
+    "username": "",
+    "password": "",
+    "host": "H%4fSt",
+    "hostname": "H%4fSt",
+    "port": "",
+    "pathname": "/path",
+    "search": "",
+    "hash": ""
+  },
+  "# IPv6 in non-special-URLs",
+  {
+    "input": "non-special://[1:2:0:0:5:0:0:0]/",
+    "base": null,
+    "href": "non-special://[1:2:0:0:5::]/",
+    "protocol": "non-special:",
+    "username": "",
+    "password": "",
+    "host": "[1:2:0:0:5::]",
+    "hostname": "[1:2:0:0:5::]",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "non-special://[1:2:0:0:0:0:0:3]/",
+    "base": null,
+    "href": "non-special://[1:2::3]/",
+    "protocol": "non-special:",
+    "username": "",
+    "password": "",
+    "host": "[1:2::3]",
+    "hostname": "[1:2::3]",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "non-special://[1:2::3]:80/",
+    "base": null,
+    "href": "non-special://[1:2::3]:80/",
+    "protocol": "non-special:",
+    "username": "",
+    "password": "",
+    "host": "[1:2::3]:80",
+    "hostname": "[1:2::3]",
+    "port": "80",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "non-special://[:80/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "blob:https://example.com:443/",
+    "base": null,
+    "href": "blob:https://example.com:443/",
+    "origin": "https://example.com",
+    "protocol": "blob:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "https://example.com:443/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "blob:http://example.org:88/",
+    "base": null,
+    "href": "blob:http://example.org:88/",
+    "origin": "http://example.org:88",
+    "protocol": "blob:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "http://example.org:88/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "blob:d3958f5c-0777-0845-9dcf-2cb28783acaf",
+    "base": null,
+    "href": "blob:d3958f5c-0777-0845-9dcf-2cb28783acaf",
+    "origin": "null",
+    "protocol": "blob:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "d3958f5c-0777-0845-9dcf-2cb28783acaf",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "blob:",
+    "base": null,
+    "href": "blob:",
+    "origin": "null",
+    "protocol": "blob:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "",
+    "search": "",
+    "hash": ""
+  },
+  "blob: in blob:",
+  {
+    "input": "blob:blob:",
+    "base": null,
+    "href": "blob:blob:",
+    "origin": "null",
+    "protocol": "blob:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "blob:",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "blob:blob:https://example.org/",
+    "base": null,
+    "href": "blob:blob:https://example.org/",
+    "origin": "null",
+    "protocol": "blob:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "blob:https://example.org/",
+    "search": "",
+    "hash": ""
+  },
+  "Non-http(s): in blob:",
+  {
+    "input": "blob:about:blank",
+    "base": null,
+    "href": "blob:about:blank",
+    "origin": "null",
+    "protocol": "blob:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "about:blank",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "blob:file://host/path",
+    "base": null,
+    "href": "blob:file://host/path",
+    "protocol": "blob:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "file://host/path",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "blob:ftp://host/path",
+    "base": null,
+    "href": "blob:ftp://host/path",
+    "origin": "null",
+    "protocol": "blob:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "ftp://host/path",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "blob:ws://example.org/",
+    "base": null,
+    "href": "blob:ws://example.org/",
+    "origin": "null",
+    "protocol": "blob:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "ws://example.org/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "blob:wss://example.org/",
+    "base": null,
+    "href": "blob:wss://example.org/",
+    "origin": "null",
+    "protocol": "blob:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "wss://example.org/",
+    "search": "",
+    "hash": ""
+  },
+  "Percent-encoded http: in blob:",
+  {
+    "input": "blob:http%3a//example.org/",
+    "base": null,
+    "href": "blob:http%3a//example.org/",
+    "origin": "null",
+    "protocol": "blob:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "http%3a//example.org/",
+    "search": "",
+    "hash": ""
+  },
+  "Invalid IPv4 radix digits",
+  {
+    "input": "http://0x7f.0.0.0x7g",
+    "base": null,
+    "href": "http://0x7f.0.0.0x7g/",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "0x7f.0.0.0x7g",
+    "hostname": "0x7f.0.0.0x7g",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://0X7F.0.0.0X7G",
+    "base": null,
+    "href": "http://0x7f.0.0.0x7g/",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "0x7f.0.0.0x7g",
+    "hostname": "0x7f.0.0.0x7g",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  "Invalid IPv4 portion of IPv6 address",
+  {
+    "input": "http://[::127.0.0.0.1]",
+    "base": null,
+    "failure": true
+  },
+  "Uncompressed IPv6 addresses with 0",
+  {
+    "input": "http://[0:1:0:1:0:1:0:1]",
+    "base": null,
+    "href": "http://[0:1:0:1:0:1:0:1]/",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "[0:1:0:1:0:1:0:1]",
+    "hostname": "[0:1:0:1:0:1:0:1]",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://[1:0:1:0:1:0:1:0]",
+    "base": null,
+    "href": "http://[1:0:1:0:1:0:1:0]/",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "[1:0:1:0:1:0:1:0]",
+    "hostname": "[1:0:1:0:1:0:1:0]",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  "Percent-encoded query and fragment",
+  {
+    "input": "http://example.org/test?\u0022",
+    "base": null,
+    "href": "http://example.org/test?%22",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/test",
+    "search": "?%22",
+    "hash": ""
+  },
+  {
+    "input": "http://example.org/test?\u0023",
+    "base": null,
+    "href": "http://example.org/test?#",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/test",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "http://example.org/test?\u003C",
+    "base": null,
+    "href": "http://example.org/test?%3C",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/test",
+    "search": "?%3C",
+    "hash": ""
+  },
+  {
+    "input": "http://example.org/test?\u003E",
+    "base": null,
+    "href": "http://example.org/test?%3E",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/test",
+    "search": "?%3E",
+    "hash": ""
+  },
+  {
+    "input": "http://example.org/test?\u2323",
+    "base": null,
+    "href": "http://example.org/test?%E2%8C%A3",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/test",
+    "search": "?%E2%8C%A3",
+    "hash": ""
+  },
+  {
+    "input": "http://example.org/test?%23%23",
+    "base": null,
+    "href": "http://example.org/test?%23%23",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/test",
+    "search": "?%23%23",
+    "hash": ""
+  },
+  {
+    "input": "http://example.org/test?%GH",
+    "base": null,
+    "href": "http://example.org/test?%GH",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/test",
+    "search": "?%GH",
+    "hash": ""
+  },
+  {
+    "input": "http://example.org/test?a#%EF",
+    "base": null,
+    "href": "http://example.org/test?a#%EF",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/test",
+    "search": "?a",
+    "hash": "#%EF"
+  },
+  {
+    "input": "http://example.org/test?a#%GH",
+    "base": null,
+    "href": "http://example.org/test?a#%GH",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/test",
+    "search": "?a",
+    "hash": "#%GH"
+  },
+  "URLs that require a non-about:blank base. (Also serve as invalid base tests.)",
+  {
+    "input": "a",
+    "base": null,
+    "failure": true,
+    "relativeTo": "non-opaque-path-base"
+  },
+  {
+    "input": "a/",
+    "base": null,
+    "failure": true,
+    "relativeTo": "non-opaque-path-base"
+  },
+  {
+    "input": "a//",
+    "base": null,
+    "failure": true,
+    "relativeTo": "non-opaque-path-base"
+  },
+  "Bases that don't fail to parse but fail to be bases",
+  {
+    "input": "test-a-colon.html",
+    "base": "a:",
+    "failure": true
+  },
+  {
+    "input": "test-a-colon-b.html",
+    "base": "a:b",
+    "failure": true
+  },
+  "Other base URL tests, that must succeed",
+  {
+    "input": "test-a-colon-slash.html",
+    "base": "a:/",
+    "href": "a:/test-a-colon-slash.html",
+    "protocol": "a:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/test-a-colon-slash.html",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "test-a-colon-slash-slash.html",
+    "base": "a://",
+    "href": "a:///test-a-colon-slash-slash.html",
+    "protocol": "a:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/test-a-colon-slash-slash.html",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "test-a-colon-slash-b.html",
+    "base": "a:/b",
+    "href": "a:/test-a-colon-slash-b.html",
+    "protocol": "a:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/test-a-colon-slash-b.html",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "test-a-colon-slash-slash-b.html",
+    "base": "a://b",
+    "href": "a://b/test-a-colon-slash-slash-b.html",
+    "protocol": "a:",
+    "username": "",
+    "password": "",
+    "host": "b",
+    "hostname": "b",
+    "port": "",
+    "pathname": "/test-a-colon-slash-slash-b.html",
+    "search": "",
+    "hash": ""
+  },
+  "Null code point in fragment",
+  {
+    "input": "http://example.org/test?a#b\u0000c",
+    "base": null,
+    "href": "http://example.org/test?a#b%00c",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/test",
+    "search": "?a",
+    "hash": "#b%00c"
+  },
+  {
+    "input": "non-spec://example.org/test?a#b\u0000c",
+    "base": null,
+    "href": "non-spec://example.org/test?a#b%00c",
+    "protocol": "non-spec:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/test",
+    "search": "?a",
+    "hash": "#b%00c"
+  },
+  {
+    "input": "non-spec:/test?a#b\u0000c",
+    "base": null,
+    "href": "non-spec:/test?a#b%00c",
+    "protocol": "non-spec:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/test",
+    "search": "?a",
+    "hash": "#b%00c"
+  },
+  "First scheme char - not allowed: https://github.com/whatwg/url/issues/464",
+  {
+    "input": "10.0.0.7:8080/foo.html",
+    "base": "file:///some/dir/bar.html",
+    "href": "file:///some/dir/10.0.0.7:8080/foo.html",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/some/dir/10.0.0.7:8080/foo.html",
+    "search": "",
+    "hash": ""
+  },
+  "Subsequent scheme chars - not allowed",
+  {
+    "input": "a!@$*=/foo.html",
+    "base": "file:///some/dir/bar.html",
+    "href": "file:///some/dir/a!@$*=/foo.html",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/some/dir/a!@$*=/foo.html",
+    "search": "",
+    "hash": ""
+  },
+  "First and subsequent scheme chars - allowed",
+  {
+    "input": "a1234567890-+.:foo/bar",
+    "base": "http://example.com/dir/file",
+    "href": "a1234567890-+.:foo/bar",
+    "protocol": "a1234567890-+.:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "foo/bar",
+    "search": "",
+    "hash": ""
+  },
+  "IDNA ignored code points in file URLs hosts",
+  {
+    "input": "file://a\u00ADb/p",
+    "base": null,
+    "href": "file://ab/p",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "ab",
+    "hostname": "ab",
+    "port": "",
+    "pathname": "/p",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "file://a%C2%ADb/p",
+    "base": null,
+    "href": "file://ab/p",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "ab",
+    "hostname": "ab",
+    "port": "",
+    "pathname": "/p",
+    "search": "",
+    "hash": ""
+  },
+  "IDNA hostnames which get mapped to 'localhost'",
+  {
+    "input": "file://loC𝐀𝐋𝐇𝐨𝐬𝐭/usr/bin",
+    "base": null,
+    "href": "file:///usr/bin",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/usr/bin",
+    "search": "",
+    "hash": ""
+  },
+  "Empty host after the domain to ASCII",
+  {
+    "input": "file://\u00ad/p",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "file://%C2%AD/p",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "file://xn--/p",
+    "base": null,
+    "failure": true
+  },
+  "https://bugzilla.mozilla.org/show_bug.cgi?id=1647058",
+  {
+    "input": "#link",
+    "base": "https://example.org/##link",
+    "href": "https://example.org/#link",
+    "protocol": "https:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": "#link"
+  },
+  "UTF-8 percent-encode of C0 control percent-encode set and supersets",
+  {
+    "input": "non-special:cannot-be-a-base-url-\u0000\u0001\u001F\u001E\u007E\u007F\u0080",
+    "base": null,
+    "hash": "",
+    "host": "",
+    "hostname": "",
+    "href": "non-special:cannot-be-a-base-url-%00%01%1F%1E~%7F%C2%80",
+    "origin": "null",
+    "password": "",
+    "pathname": "cannot-be-a-base-url-%00%01%1F%1E~%7F%C2%80",
+    "port": "",
+    "protocol": "non-special:",
+    "search": "",
+    "username": ""
+  },
+  {
+    "input": "non-special:cannot-be-a-base-url-!\"$%&'()*+,-.;<=>@[\\]^_`{|}~@/",
+    "base": null,
+    "hash": "",
+    "host": "",
+    "hostname": "",
+    "href": "non-special:cannot-be-a-base-url-!\"$%&'()*+,-.;<=>@[\\]^_`{|}~@/",
+    "origin": "null",
+    "password": "",
+    "pathname": "cannot-be-a-base-url-!\"$%&'()*+,-.;<=>@[\\]^_`{|}~@/",
+    "port": "",
+    "protocol": "non-special:",
+    "search": "",
+    "username": ""
+  },
+  {
+    "input": "https://www.example.com/path{\u007Fpath.html?query'\u007F=query#fragment<\u007Ffragment",
+    "base": null,
+    "hash": "#fragment%3C%7Ffragment",
+    "host": "www.example.com",
+    "hostname": "www.example.com",
+    "href": "https://www.example.com/path%7B%7Fpath.html?query%27%7F=query#fragment%3C%7Ffragment",
+    "origin": "https://www.example.com",
+    "password": "",
+    "pathname": "/path%7B%7Fpath.html",
+    "port": "",
+    "protocol": "https:",
+    "search": "?query%27%7F=query",
+    "username": ""
+  },
+  {
+    "input": "https://user:pass[\u007F@foo/bar",
+    "base": "http://example.org",
+    "hash": "",
+    "host": "foo",
+    "hostname": "foo",
+    "href": "https://user:pass%5B%7F@foo/bar",
+    "origin": "https://foo",
+    "password": "pass%5B%7F",
+    "pathname": "/bar",
+    "port": "",
+    "protocol": "https:",
+    "search": "",
+    "username": "user"
+  },
+  "Tests for the distinct percent-encode sets",
+  {
+    "input": "foo:// !\"$%&'()*+,-.;<=>@[\\]^_`{|}~@host/",
+    "base": null,
+    "hash": "",
+    "host": "host",
+    "hostname": "host",
+    "href": "foo://%20!%22$%&'()*+,-.%3B%3C%3D%3E%40%5B%5C%5D%5E_%60%7B%7C%7D~@host/",
+    "origin": "null",
+    "password": "",
+    "pathname": "/",
+    "port":"",
+    "protocol": "foo:",
+    "search": "",
+    "username": "%20!%22$%&'()*+,-.%3B%3C%3D%3E%40%5B%5C%5D%5E_%60%7B%7C%7D~"
+  },
+  {
+    "input": "wss:// !\"$%&'()*+,-.;<=>@[]^_`{|}~@host/",
+    "base": null,
+    "hash": "",
+    "host": "host",
+    "hostname": "host",
+    "href": "wss://%20!%22$%&'()*+,-.%3B%3C%3D%3E%40%5B%5D%5E_%60%7B%7C%7D~@host/",
+    "origin": "wss://host",
+    "password": "",
+    "pathname": "/",
+    "port":"",
+    "protocol": "wss:",
+    "search": "",
+    "username": "%20!%22$%&'()*+,-.%3B%3C%3D%3E%40%5B%5D%5E_%60%7B%7C%7D~"
+  },
+  {
+    "input": "foo://joe: !\"$%&'()*+,-.:;<=>@[\\]^_`{|}~@host/",
+    "base": null,
+    "hash": "",
+    "host": "host",
+    "hostname": "host",
+    "href": "foo://joe:%20!%22$%&'()*+,-.%3A%3B%3C%3D%3E%40%5B%5C%5D%5E_%60%7B%7C%7D~@host/",
+    "origin": "null",
+    "password": "%20!%22$%&'()*+,-.%3A%3B%3C%3D%3E%40%5B%5C%5D%5E_%60%7B%7C%7D~",
+    "pathname": "/",
+    "port":"",
+    "protocol": "foo:",
+    "search": "",
+    "username": "joe"
+  },
+  {
+    "input": "wss://joe: !\"$%&'()*+,-.:;<=>@[]^_`{|}~@host/",
+    "base": null,
+    "hash": "",
+    "host": "host",
+    "hostname": "host",
+    "href": "wss://joe:%20!%22$%&'()*+,-.%3A%3B%3C%3D%3E%40%5B%5D%5E_%60%7B%7C%7D~@host/",
+    "origin": "wss://host",
+    "password": "%20!%22$%&'()*+,-.%3A%3B%3C%3D%3E%40%5B%5D%5E_%60%7B%7C%7D~",
+    "pathname": "/",
+    "port":"",
+    "protocol": "wss:",
+    "search": "",
+    "username": "joe"
+  },
+  {
+    "input": "foo://!\"$%&'()*+,-.;=_`{}~/",
+    "base": null,
+    "hash": "",
+    "host": "!\"$%&'()*+,-.;=_`{}~",
+    "hostname": "!\"$%&'()*+,-.;=_`{}~",
+    "href":"foo://!\"$%&'()*+,-.;=_`{}~/",
+    "origin": "null",
+    "password": "",
+    "pathname": "/",
+    "port":"",
+    "protocol": "foo:",
+    "search": "",
+    "username": ""
+  },
+  {
+    "input": "wss://!\"$&'()*+,-.;=_`{}~/",
+    "base": null,
+    "hash": "",
+    "host": "!\"$&'()*+,-.;=_`{}~",
+    "hostname": "!\"$&'()*+,-.;=_`{}~",
+    "href":"wss://!\"$&'()*+,-.;=_`{}~/",
+    "origin": "wss://!\"$&'()*+,-.;=_`{}~",
+    "password": "",
+    "pathname": "/",
+    "port":"",
+    "protocol": "wss:",
+    "search": "",
+    "username": ""
+  },
+  {
+    "input": "foo://host/ !\"$%&'()*+,-./:;<=>@[\\]^_`{|}~",
+    "base": null,
+    "hash": "",
+    "host": "host",
+    "hostname": "host",
+    "href": "foo://host/%20!%22$%&'()*+,-./:;%3C=%3E@[\\]%5E_%60%7B|%7D~",
+    "origin": "null",
+    "password": "",
+    "pathname": "/%20!%22$%&'()*+,-./:;%3C=%3E@[\\]%5E_%60%7B|%7D~",
+    "port":"",
+    "protocol": "foo:",
+    "search": "",
+    "username": ""
+  },
+  {
+    "input": "wss://host/ !\"$%&'()*+,-./:;<=>@[\\]^_`{|}~",
+    "base": null,
+    "hash": "",
+    "host": "host",
+    "hostname": "host",
+    "href": "wss://host/%20!%22$%&'()*+,-./:;%3C=%3E@[/]%5E_%60%7B|%7D~",
+    "origin": "wss://host",
+    "password": "",
+    "pathname": "/%20!%22$%&'()*+,-./:;%3C=%3E@[/]%5E_%60%7B|%7D~",
+    "port":"",
+    "protocol": "wss:",
+    "search": "",
+    "username": ""
+  },
+  {
+    "input": "foo://host/dir/? !\"$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
+    "base": null,
+    "hash": "",
+    "host": "host",
+    "hostname": "host",
+    "href": "foo://host/dir/?%20!%22$%&'()*+,-./:;%3C=%3E?@[\\]^_`{|}~",
+    "origin": "null",
+    "password": "",
+    "pathname": "/dir/",
+    "port":"",
+    "protocol": "foo:",
+    "search": "?%20!%22$%&'()*+,-./:;%3C=%3E?@[\\]^_`{|}~",
+    "username": ""
+  },
+  {
+    "input": "wss://host/dir/? !\"$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
+    "base": null,
+    "hash": "",
+    "host": "host",
+    "hostname": "host",
+    "href": "wss://host/dir/?%20!%22$%&%27()*+,-./:;%3C=%3E?@[\\]^_`{|}~",
+    "origin": "wss://host",
+    "password": "",
+    "pathname": "/dir/",
+    "port":"",
+    "protocol": "wss:",
+    "search": "?%20!%22$%&%27()*+,-./:;%3C=%3E?@[\\]^_`{|}~",
+    "username": ""
+  },
+  {
+    "input": "foo://host/dir/# !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
+    "base": null,
+    "hash": "#%20!%22#$%&'()*+,-./:;%3C=%3E?@[\\]^_%60{|}~",
+    "host": "host",
+    "hostname": "host",
+    "href": "foo://host/dir/#%20!%22#$%&'()*+,-./:;%3C=%3E?@[\\]^_%60{|}~",
+    "origin": "null",
+    "password": "",
+    "pathname": "/dir/",
+    "port":"",
+    "protocol": "foo:",
+    "search": "",
+    "username": ""
+  },
+  {
+    "input": "wss://host/dir/# !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~",
+    "base": null,
+    "hash": "#%20!%22#$%&'()*+,-./:;%3C=%3E?@[\\]^_%60{|}~",
+    "host": "host",
+    "hostname": "host",
+    "href": "wss://host/dir/#%20!%22#$%&'()*+,-./:;%3C=%3E?@[\\]^_%60{|}~",
+    "origin": "wss://host",
+    "password": "",
+    "pathname": "/dir/",
+    "port":"",
+    "protocol": "wss:",
+    "search": "",
+    "username": ""
+  },
+  "Ensure that input schemes are not ignored when resolving non-special URLs",
+  {
+    "input": "abc:rootless",
+    "base": "abc://host/path",
+    "hash": "",
+    "host": "",
+    "hostname": "",
+    "href":"abc:rootless",
+    "password": "",
+    "pathname": "rootless",
+    "port":"",
+    "protocol": "abc:",
+    "search": "",
+    "username": ""
+  },
+  {
+    "input": "abc:rootless",
+    "base": "abc:/path",
+    "hash": "",
+    "host": "",
+    "hostname": "",
+    "href":"abc:rootless",
+    "password": "",
+    "pathname": "rootless",
+    "port":"",
+    "protocol": "abc:",
+    "search": "",
+    "username": ""
+  },
+  {
+    "input": "abc:rootless",
+    "base": "abc:path",
+    "hash": "",
+    "host": "",
+    "hostname": "",
+    "href":"abc:rootless",
+    "password": "",
+    "pathname": "rootless",
+    "port":"",
+    "protocol": "abc:",
+    "search": "",
+    "username": ""
+  },
+  {
+    "input": "abc:/rooted",
+    "base": "abc://host/path",
+    "hash": "",
+    "host": "",
+    "hostname": "",
+    "href":"abc:/rooted",
+    "password": "",
+    "pathname": "/rooted",
+    "port":"",
+    "protocol": "abc:",
+    "search": "",
+    "username": ""
+  },
+  "Empty query and fragment with blank should throw an error",
+  {
+    "input": "#",
+    "base": null,
+    "failure": true,
+    "relativeTo": "any-base"
+  },
+  {
+    "input": "?",
+    "base": null,
+    "failure": true,
+    "relativeTo": "non-opaque-path-base"
+  },
+  "Last component looks like a number, but not valid IPv4",
+  {
+    "input": "http://1.2.3.4.5",
+    "base": "http://other.com/",
+    "failure": true
+  },
+  {
+    "input": "http://1.2.3.4.5.",
+    "base": "http://other.com/",
+    "failure": true
+  },
+  {
+    "input": "http://0..0x300/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://0..0x300./",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://256.256.256.256.256",
+    "base": "http://other.com/",
+    "failure": true
+  },
+  {
+    "input": "http://256.256.256.256.256.",
+    "base": "http://other.com/",
+    "failure": true
+  },
+  {
+    "input": "http://1.2.3.08",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://1.2.3.08.",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://1.2.3.09",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://09.2.3.4",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://09.2.3.4.",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://01.2.3.4.5",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://01.2.3.4.5.",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://0x100.2.3.4",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://0x100.2.3.4.",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://0x1.2.3.4.5",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://0x1.2.3.4.5.",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://foo.1.2.3.4",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://foo.1.2.3.4.",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://foo.2.3.4",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://foo.2.3.4.",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://foo.09",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://foo.09.",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://foo.0x4",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://foo.0x4.",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://foo.09..",
+    "base": null,
+    "hash": "",
+    "host": "foo.09..",
+    "hostname": "foo.09..",
+    "href":"http://foo.09../",
+    "password": "",
+    "pathname": "/",
+    "port":"",
+    "protocol": "http:",
+    "search": "",
+    "username": ""
+  },
+  {
+    "input": "http://0999999999999999999/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://foo.0x",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://foo.0XFfFfFfFfFfFfFfFfFfAcE123",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "http://💩.123/",
+    "base": null,
+    "failure": true
+  },
+  "U+0000 and U+FFFF in various places",
+  {
+    "input": "https://\u0000y",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "https://x/\u0000y",
+    "base": null,
+    "hash": "",
+    "host": "x",
+    "hostname": "x",
+    "href": "https://x/%00y",
+    "password": "",
+    "pathname": "/%00y",
+    "port": "",
+    "protocol": "https:",
+    "search": "",
+    "username": ""
+  },
+  {
+    "input": "https://x/?\u0000y",
+    "base": null,
+    "hash": "",
+    "host": "x",
+    "hostname": "x",
+    "href": "https://x/?%00y",
+    "password": "",
+    "pathname": "/",
+    "port": "",
+    "protocol": "https:",
+    "search": "?%00y",
+    "username": ""
+  },
+  {
+    "input": "https://x/?#\u0000y",
+    "base": null,
+    "hash": "#%00y",
+    "host": "x",
+    "hostname": "x",
+    "href": "https://x/?#%00y",
+    "password": "",
+    "pathname": "/",
+    "port": "",
+    "protocol": "https:",
+    "search": "",
+    "username": ""
+  },
+  {
+    "input": "https://\uFFFFy",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "https://x/\uFFFFy",
+    "base": null,
+    "hash": "",
+    "host": "x",
+    "hostname": "x",
+    "href": "https://x/%EF%BF%BFy",
+    "password": "",
+    "pathname": "/%EF%BF%BFy",
+    "port": "",
+    "protocol": "https:",
+    "search": "",
+    "username": ""
+  },
+  {
+    "input": "https://x/?\uFFFFy",
+    "base": null,
+    "hash": "",
+    "host": "x",
+    "hostname": "x",
+    "href": "https://x/?%EF%BF%BFy",
+    "password": "",
+    "pathname": "/",
+    "port": "",
+    "protocol": "https:",
+    "search": "?%EF%BF%BFy",
+    "username": ""
+  },
+  {
+    "input": "https://x/?#\uFFFFy",
+    "base": null,
+    "hash": "#%EF%BF%BFy",
+    "host": "x",
+    "hostname": "x",
+    "href": "https://x/?#%EF%BF%BFy",
+    "password": "",
+    "pathname": "/",
+    "port": "",
+    "protocol": "https:",
+    "search": "",
+    "username": ""
+  },
+  {
+    "input": "non-special:\u0000y",
+    "base": null,
+    "hash": "",
+    "host": "",
+    "hostname": "",
+    "href": "non-special:%00y",
+    "password": "",
+    "pathname": "%00y",
+    "port": "",
+    "protocol": "non-special:",
+    "search": "",
+    "username": ""
+  },
+  {
+    "input": "non-special:x/\u0000y",
+    "base": null,
+    "hash": "",
+    "host": "",
+    "hostname": "",
+    "href": "non-special:x/%00y",
+    "password": "",
+    "pathname": "x/%00y",
+    "port": "",
+    "protocol": "non-special:",
+    "search": "",
+    "username": ""
+  },
+  {
+    "input": "non-special:x/?\u0000y",
+    "base": null,
+    "hash": "",
+    "host": "",
+    "hostname": "",
+    "href": "non-special:x/?%00y",
+    "password": "",
+    "pathname": "x/",
+    "port": "",
+    "protocol": "non-special:",
+    "search": "?%00y",
+    "username": ""
+  },
+  {
+    "input": "non-special:x/?#\u0000y",
+    "base": null,
+    "hash": "#%00y",
+    "host": "",
+    "hostname": "",
+    "href": "non-special:x/?#%00y",
+    "password": "",
+    "pathname": "x/",
+    "port": "",
+    "protocol": "non-special:",
+    "search": "",
+    "username": ""
+  },
+  {
+    "input": "non-special:\uFFFFy",
+    "base": null,
+    "hash": "",
+    "host": "",
+    "hostname": "",
+    "href": "non-special:%EF%BF%BFy",
+    "password": "",
+    "pathname": "%EF%BF%BFy",
+    "port": "",
+    "protocol": "non-special:",
+    "search": "",
+    "username": ""
+  },
+  {
+    "input": "non-special:x/\uFFFFy",
+    "base": null,
+    "hash": "",
+    "host": "",
+    "hostname": "",
+    "href": "non-special:x/%EF%BF%BFy",
+    "password": "",
+    "pathname": "x/%EF%BF%BFy",
+    "port": "",
+    "protocol": "non-special:",
+    "search": "",
+    "username": ""
+  },
+  {
+    "input": "non-special:x/?\uFFFFy",
+    "base": null,
+    "hash": "",
+    "host": "",
+    "hostname": "",
+    "href": "non-special:x/?%EF%BF%BFy",
+    "password": "",
+    "pathname": "x/",
+    "port": "",
+    "protocol": "non-special:",
+    "search": "?%EF%BF%BFy",
+    "username": ""
+  },
+  {
+    "input": "non-special:x/?#\uFFFFy",
+    "base": null,
+    "hash": "#%EF%BF%BFy",
+    "host": "",
+    "hostname": "",
+    "href": "non-special:x/?#%EF%BF%BFy",
+    "password": "",
+    "pathname": "x/",
+    "port": "",
+    "protocol": "non-special:",
+    "search": "",
+    "username": ""
+  },
+  {
+    "input": "",
+    "base": null,
+    "failure": true,
+    "relativeTo": "non-opaque-path-base"
+  },
+  {
+    "input": "https://example.com/\"quoted\"",
+    "base": null,
+    "hash": "",
+    "host": "example.com",
+    "hostname": "example.com",
+    "href": "https://example.com/%22quoted%22",
+    "origin": "https://example.com",
+    "password": "",
+    "pathname": "/%22quoted%22",
+    "port": "",
+    "protocol": "https:",
+    "search": "",
+    "username": ""
+  },
+  {
+    "input": "https://a%C2%ADb/",
+    "base": null,
+    "hash": "",
+    "host": "ab",
+    "hostname": "ab",
+    "href": "https://ab/",
+    "origin": "https://ab",
+    "password": "",
+    "pathname": "/",
+    "port": "",
+    "protocol": "https:",
+    "search": "",
+    "username": ""
+  },
+  {
+    "comment": "Empty host after domain to ASCII",
+    "input": "https://\u00AD/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "https://%C2%AD/",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "https://xn--/",
+    "base": null,
+    "failure": true
+  },
+  "Non-special schemes that some implementations might incorrectly treat as special",
+  {
+    "input": "data://example.com:8080/pathname?search#hash",
+    "base": null,
+    "href": "data://example.com:8080/pathname?search#hash",
+    "origin": "null",
+    "protocol": "data:",
+    "username": "",
+    "password": "",
+    "host": "example.com:8080",
+    "hostname": "example.com",
+    "port": "8080",
+    "pathname": "/pathname",
+    "search": "?search",
+    "hash": "#hash"
+  },
+  {
+    "input": "data:///test",
+    "base": null,
+    "href": "data:///test",
+    "origin": "null",
+    "protocol": "data:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/test",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "data://test/a/../b",
+    "base": null,
+    "href": "data://test/b",
+    "origin": "null",
+    "protocol": "data:",
+    "username": "",
+    "password": "",
+    "host": "test",
+    "hostname": "test",
+    "port": "",
+    "pathname": "/b",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "data://:443",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "data://test:test",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "data://[:1]",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "javascript://example.com:8080/pathname?search#hash",
+    "base": null,
+    "href": "javascript://example.com:8080/pathname?search#hash",
+    "origin": "null",
+    "protocol": "javascript:",
+    "username": "",
+    "password": "",
+    "host": "example.com:8080",
+    "hostname": "example.com",
+    "port": "8080",
+    "pathname": "/pathname",
+    "search": "?search",
+    "hash": "#hash"
+  },
+  {
+    "input": "javascript:///test",
+    "base": null,
+    "href": "javascript:///test",
+    "origin": "null",
+    "protocol": "javascript:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/test",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "javascript://test/a/../b",
+    "base": null,
+    "href": "javascript://test/b",
+    "origin": "null",
+    "protocol": "javascript:",
+    "username": "",
+    "password": "",
+    "host": "test",
+    "hostname": "test",
+    "port": "",
+    "pathname": "/b",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "javascript://:443",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "javascript://test:test",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "javascript://[:1]",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "mailto://example.com:8080/pathname?search#hash",
+    "base": null,
+    "href": "mailto://example.com:8080/pathname?search#hash",
+    "origin": "null",
+    "protocol": "mailto:",
+    "username": "",
+    "password": "",
+    "host": "example.com:8080",
+    "hostname": "example.com",
+    "port": "8080",
+    "pathname": "/pathname",
+    "search": "?search",
+    "hash": "#hash"
+  },
+  {
+    "input": "mailto:///test",
+    "base": null,
+    "href": "mailto:///test",
+    "origin": "null",
+    "protocol": "mailto:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/test",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "mailto://test/a/../b",
+    "base": null,
+    "href": "mailto://test/b",
+    "origin": "null",
+    "protocol": "mailto:",
+    "username": "",
+    "password": "",
+    "host": "test",
+    "hostname": "test",
+    "port": "",
+    "pathname": "/b",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "mailto://:443",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "mailto://test:test",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "mailto://[:1]",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "intent://example.com:8080/pathname?search#hash",
+    "base": null,
+    "href": "intent://example.com:8080/pathname?search#hash",
+    "origin": "null",
+    "protocol": "intent:",
+    "username": "",
+    "password": "",
+    "host": "example.com:8080",
+    "hostname": "example.com",
+    "port": "8080",
+    "pathname": "/pathname",
+    "search": "?search",
+    "hash": "#hash"
+  },
+  {
+    "input": "intent:///test",
+    "base": null,
+    "href": "intent:///test",
+    "origin": "null",
+    "protocol": "intent:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/test",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "intent://test/a/../b",
+    "base": null,
+    "href": "intent://test/b",
+    "origin": "null",
+    "protocol": "intent:",
+    "username": "",
+    "password": "",
+    "host": "test",
+    "hostname": "test",
+    "port": "",
+    "pathname": "/b",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "intent://:443",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "intent://test:test",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "intent://[:1]",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "urn://example.com:8080/pathname?search#hash",
+    "base": null,
+    "href": "urn://example.com:8080/pathname?search#hash",
+    "origin": "null",
+    "protocol": "urn:",
+    "username": "",
+    "password": "",
+    "host": "example.com:8080",
+    "hostname": "example.com",
+    "port": "8080",
+    "pathname": "/pathname",
+    "search": "?search",
+    "hash": "#hash"
+  },
+  {
+    "input": "urn:///test",
+    "base": null,
+    "href": "urn:///test",
+    "origin": "null",
+    "protocol": "urn:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/test",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "urn://test/a/../b",
+    "base": null,
+    "href": "urn://test/b",
+    "origin": "null",
+    "protocol": "urn:",
+    "username": "",
+    "password": "",
+    "host": "test",
+    "hostname": "test",
+    "port": "",
+    "pathname": "/b",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "urn://:443",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "urn://test:test",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "urn://[:1]",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "turn://example.com:8080/pathname?search#hash",
+    "base": null,
+    "href": "turn://example.com:8080/pathname?search#hash",
+    "origin": "null",
+    "protocol": "turn:",
+    "username": "",
+    "password": "",
+    "host": "example.com:8080",
+    "hostname": "example.com",
+    "port": "8080",
+    "pathname": "/pathname",
+    "search": "?search",
+    "hash": "#hash"
+  },
+  {
+    "input": "turn:///test",
+    "base": null,
+    "href": "turn:///test",
+    "origin": "null",
+    "protocol": "turn:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/test",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "turn://test/a/../b",
+    "base": null,
+    "href": "turn://test/b",
+    "origin": "null",
+    "protocol": "turn:",
+    "username": "",
+    "password": "",
+    "host": "test",
+    "hostname": "test",
+    "port": "",
+    "pathname": "/b",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "turn://:443",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "turn://test:test",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "turn://[:1]",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "stun://example.com:8080/pathname?search#hash",
+    "base": null,
+    "href": "stun://example.com:8080/pathname?search#hash",
+    "origin": "null",
+    "protocol": "stun:",
+    "username": "",
+    "password": "",
+    "host": "example.com:8080",
+    "hostname": "example.com",
+    "port": "8080",
+    "pathname": "/pathname",
+    "search": "?search",
+    "hash": "#hash"
+  },
+  {
+    "input": "stun:///test",
+    "base": null,
+    "href": "stun:///test",
+    "origin": "null",
+    "protocol": "stun:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/test",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "stun://test/a/../b",
+    "base": null,
+    "href": "stun://test/b",
+    "origin": "null",
+    "protocol": "stun:",
+    "username": "",
+    "password": "",
+    "host": "test",
+    "hostname": "test",
+    "port": "",
+    "pathname": "/b",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "stun://:443",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "stun://test:test",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "stun://[:1]",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "w://x:0",
+    "base": null,
+    "href": "w://x:0",
+    "origin": "null",
+    "protocol": "w:",
+    "username": "",
+    "password": "",
+    "host": "x:0",
+    "hostname": "x",
+    "port": "0",
+    "pathname": "",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "west://x:0",
+    "base": null,
+    "href": "west://x:0",
+    "origin": "null",
+    "protocol": "west:",
+    "username": "",
+    "password": "",
+    "host": "x:0",
+    "hostname": "x",
+    "port": "0",
+    "pathname": "",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "android://x:0/a",
+    "base": null,
+    "href": "android://x:0/a",
+    "origin": "null",
+    "protocol": "android:",
+    "username": "",
+    "password": "",
+    "host": "x:0",
+    "hostname": "x",
+    "port": "0",
+    "pathname": "/a",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "drivefs://x:0/a",
+    "base": null,
+    "href": "drivefs://x:0/a",
+    "origin": "null",
+    "protocol": "drivefs:",
+    "username": "",
+    "password": "",
+    "host": "x:0",
+    "hostname": "x",
+    "port": "0",
+    "pathname": "/a",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "chromeos-steam://x:0/a",
+    "base": null,
+    "href": "chromeos-steam://x:0/a",
+    "origin": "null",
+    "protocol": "chromeos-steam:",
+    "username": "",
+    "password": "",
+    "host": "x:0",
+    "hostname": "x",
+    "port": "0",
+    "pathname": "/a",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "steam://x:0/a",
+    "base": null,
+    "href": "steam://x:0/a",
+    "origin": "null",
+    "protocol": "steam:",
+    "username": "",
+    "password": "",
+    "host": "x:0",
+    "hostname": "x",
+    "port": "0",
+    "pathname": "/a",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "materialized-view://x:0/a",
+    "base": null,
+    "href": "materialized-view://x:0/a",
+    "origin": "null",
+    "protocol": "materialized-view:",
+    "username": "",
+    "password": "",
+    "host": "x:0",
+    "hostname": "x",
+    "port": "0",
+    "pathname": "/a",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "android-app://x:0",
+    "base": null,
+    "href": "android-app://x:0",
+    "origin": "null",
+    "protocol": "android-app:",
+    "username": "",
+    "password": "",
+    "host": "x:0",
+    "hostname": "x",
+    "port": "0",
+    "pathname": "",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "chrome-distiller://x:0",
+    "base": null,
+    "href": "chrome-distiller://x:0",
+    "origin": "null",
+    "protocol": "chrome-distiller:",
+    "username": "",
+    "password": "",
+    "host": "x:0",
+    "hostname": "x",
+    "port": "0",
+    "pathname": "",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "chrome-extension://x:0",
+    "base": null,
+    "href": "chrome-extension://x:0",
+    "origin": "null",
+    "protocol": "chrome-extension:",
+    "username": "",
+    "password": "",
+    "host": "x:0",
+    "hostname": "x",
+    "port": "0",
+    "pathname": "",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "chrome-native://x:0",
+    "base": null,
+    "href": "chrome-native://x:0",
+    "origin": "null",
+    "protocol": "chrome-native:",
+    "username": "",
+    "password": "",
+    "host": "x:0",
+    "hostname": "x",
+    "port": "0",
+    "pathname": "",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "chrome-resource://x:0",
+    "base": null,
+    "href": "chrome-resource://x:0",
+    "origin": "null",
+    "protocol": "chrome-resource:",
+    "username": "",
+    "password": "",
+    "host": "x:0",
+    "hostname": "x",
+    "port": "0",
+    "pathname": "",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "chrome-search://x:0",
+    "base": null,
+    "href": "chrome-search://x:0",
+    "origin": "null",
+    "protocol": "chrome-search:",
+    "username": "",
+    "password": "",
+    "host": "x:0",
+    "hostname": "x",
+    "port": "0",
+    "pathname": "",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "fuchsia-dir://x:0",
+    "base": null,
+    "href": "fuchsia-dir://x:0",
+    "origin": "null",
+    "protocol": "fuchsia-dir:",
+    "username": "",
+    "password": "",
+    "host": "x:0",
+    "hostname": "x",
+    "port": "0",
+    "pathname": "",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "isolated-app://x:0",
+    "base": null,
+    "href": "isolated-app://x:0",
+    "origin": "null",
+    "protocol": "isolated-app:",
+    "username": "",
+    "password": "",
+    "host": "x:0",
+    "hostname": "x",
+    "port": "0",
+    "pathname": "",
+    "search": "",
+    "hash": ""
+  },
+  "Scheme relative path starting with multiple slashes",
+  {
+    "input": "///test",
+    "base": "http://example.org/",
+    "href": "http://test/",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "test",
+    "hostname": "test",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "///\\//\\//test",
+    "base": "http://example.org/",
+    "href": "http://test/",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "test",
+    "hostname": "test",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "///example.org/path",
+    "base": "http://example.org/",
+    "href": "http://example.org/path",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/path",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "///example.org/../path",
+    "base": "http://example.org/",
+    "href": "http://example.org/path",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/path",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "///example.org/../../",
+    "base": "http://example.org/",
+    "href": "http://example.org/",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "///example.org/../path/../../",
+    "base": "http://example.org/",
+    "href": "http://example.org/",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "///example.org/../path/../../path",
+    "base": "http://example.org/",
+    "href": "http://example.org/path",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/path",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "/\\/\\//example.org/../path",
+    "base": "http://example.org/",
+    "href": "http://example.org/path",
+    "protocol": "http:",
+    "username": "",
+    "password": "",
+    "host": "example.org",
+    "hostname": "example.org",
+    "port": "",
+    "pathname": "/path",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "///abcdef/../",
+    "base": "file:///",
+    "href": "file:///",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "/\\//\\/a/../",
+    "base": "file:///",
+    "href": "file://////",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "////",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "//a/../",
+    "base": "file:///",
+    "href": "file://a/",
+    "protocol": "file:",
+    "username": "",
+    "password": "",
+    "host": "a",
+    "hostname": "a",
+    "port": "",
+    "pathname": "/",
+    "search": "",
+    "hash": ""
+  },
+  "# Non-special URL and backslashes",
+  {
+    "input": "non-special:\\\\opaque",
+    "base": null,
+    "href": "non-special:\\\\opaque",
+    "origin": "null",
+    "protocol": "non-special:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "\\\\opaque",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "non-special:\\\\opaque/path",
+    "base": null,
+    "href": "non-special:\\\\opaque/path",
+    "origin": "null",
+    "protocol": "non-special:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "\\\\opaque/path",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "non-special:\\\\opaque\\path",
+    "base": null,
+    "href": "non-special:\\\\opaque\\path",
+    "origin": "null",
+    "protocol": "non-special:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "\\\\opaque\\path",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "non-special:\\/opaque",
+    "base": null,
+    "href": "non-special:\\/opaque",
+    "origin": "null",
+    "protocol": "non-special:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "\\/opaque",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "non-special:/\\path",
+    "base": null,
+    "href": "non-special:/\\path",
+    "origin": "null",
+    "protocol": "non-special:",
+    "username": "",
+    "password": "",
+    "host": "",
+    "hostname": "",
+    "port": "",
+    "pathname": "/\\path",
+    "search": "",
+    "hash": ""
+  },
+  {
+    "input": "non-special://host\\a",
+    "base": null,
+    "failure": true
+  },
+  {
+    "input": "non-special://host/a\\b",
+    "base": null,
+    "href": "non-special://host/a\\b",
+    "origin": "null",
+    "protocol": "non-special:",
+    "username": "",
+    "password": "",
+    "host": "host",
+    "hostname": "host",
+    "port": "",
+    "pathname": "/a\\b",
+    "search": "",
+    "hash": ""
+  }
+]
diff --git a/test/js/node/test/parallel/test-assert-class-destructuring.js b/test/js/node/test/parallel/test-assert-class-destructuring.js
new file mode 100644
index 000000000000..ac82ab586312
--- /dev/null
+++ b/test/js/node/test/parallel/test-assert-class-destructuring.js
@@ -0,0 +1,128 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+// eslint-disable-next-line node-core/must-call-assert
+const { Assert } = require('assert');
+const { test } = require('node:test');
+
+// Disable colored output to prevent color codes from breaking assertion
+// message comparisons. This should only be an issue when process.stdout
+// is a TTY.
+if (process.stdout.isTTY) {
+  process.env.NODE_DISABLE_COLORS = '1';
+}
+
+test('Assert class destructuring behavior - diff option', () => {
+  const assertInstanceFull = new Assert({ diff: 'full' });
+  const assertInstanceSimple = new Assert({ diff: 'simple' });
+
+  assertInstanceFull.throws(
+    () => assertInstanceFull.strictEqual({ a: 1 }, { a: 2 }),
+    { diff: 'full' },
+  );
+
+  assertInstanceSimple.throws(
+    () => assertInstanceSimple.strictEqual({ a: 1 }, { a: 2 }),
+    { diff: 'simple' },
+  );
+
+  const { strictEqual: strictEqualSimple } = assertInstanceSimple;
+  const { strictEqual: strictEqualFull } = assertInstanceFull;
+  const { deepStrictEqual: deepStrictEqualFull } = assertInstanceFull;
+  const { equal: equalFull } = assertInstanceFull;
+
+  assert.throws(
+    () => strictEqualSimple({ a: 1 }, { a: 2 }),
+    (err) => {
+      assert.strictEqual(err.diff, 'simple');
+      return true;
+    }
+  );
+
+  assert.throws(
+    () => strictEqualFull({ a: 1 }, { a: 2 }),
+    (err) => {
+      assert.strictEqual(err.diff, 'simple');
+      return true;
+    }
+  );
+
+  assert.throws(
+    () => deepStrictEqualFull({ a: 1 }, { a: 2 }),
+    (err) => {
+      assert.strictEqual(err.diff, 'simple');
+      return true;
+    }
+  );
+
+  assert.throws(
+    () => equalFull({ a: 1 }, { a: 2 }),
+    (err) => {
+      assert.strictEqual(err.diff, 'simple');
+      return true;
+    }
+  );
+});
+
+test('Assert class destructuring behavior - strict option', () => {
+  const assertInstanceNonStrict = new Assert({ strict: false });
+  const assertInstanceStrict = new Assert({ strict: true });
+
+  assertInstanceNonStrict.equal(2, '2');
+
+  assert.throws(
+    () => assertInstanceStrict.equal(2, '2'),
+    assert.AssertionError
+  );
+
+  const { equal: equalNonStrict } = assertInstanceNonStrict;
+  const { equal: equalStrict } = assertInstanceStrict;
+
+  equalNonStrict(2, '2');
+  assert.throws(
+    () => equalStrict(2, '2'),
+    assert.AssertionError
+  );
+});
+
+test('Assert class destructuring behavior - comprehensive methods', () => {
+  const myAssert = new Assert({ diff: 'full', strict: false });
+
+  const {
+    fail,
+    equal,
+    strictEqual,
+    deepStrictEqual,
+    throws,
+    match,
+    doesNotMatch
+  } = myAssert;
+
+  assert.throws(() => fail('test message'), (err) => {
+    assert.strictEqual(err.diff, 'simple');
+    assert.strictEqual(err.message, 'test message');
+    return true;
+  });
+
+  assert.throws(() => equal({ a: 1 }, { a: 2 }), (err) => {
+    assert.strictEqual(err.diff, 'simple');
+    return true;
+  });
+
+  assert.throws(() => strictEqual({ a: 1 }, { a: 2 }), (err) => {
+    assert.strictEqual(err.diff, 'simple');
+    return true;
+  });
+
+  assert.throws(() => deepStrictEqual({ a: 1 }, { a: 2 }), (err) => {
+    assert.strictEqual(err.diff, 'simple');
+    return true;
+  });
+
+  throws(() => { throw new Error('test'); }, Error);
+
+  match('hello world', /world/);
+
+  doesNotMatch('hello world', /xyz/);
+});
diff --git a/test/js/node/test/parallel/test-assert-class.js b/test/js/node/test/parallel/test-assert-class.js
new file mode 100644
index 000000000000..cccc7a2f36ff
--- /dev/null
+++ b/test/js/node/test/parallel/test-assert-class.js
@@ -0,0 +1,641 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+// eslint-disable-next-line node-core/must-call-assert
+const { Assert } = require('assert');
+const { inspect } = require('util');
+const { test } = require('node:test');
+
+// Disable colored output to prevent color codes from breaking assertion
+// message comparisons. This should only be an issue when process.stdout
+// is a TTY.
+if (process.stdout.isTTY) {
+  process.env.NODE_DISABLE_COLORS = '1';
+}
+
+test('Assert constructor requires new', () => {
+  assert.throws(() => Assert(), {
+    code: 'ERR_CONSTRUCT_CALL_REQUIRED',
+    name: 'TypeError',
+  });
+});
+
+test('Assert class non strict', () => {
+  const assertInstance = new Assert({ diff: undefined, strict: false });
+
+  assertInstance.ok(
+    assert.AssertionError.prototype instanceof Error,
+    'assert.AssertionError instanceof Error'
+  );
+  assert.strictEqual(typeof assertInstance.ok, 'function');
+  assert.strictEqual(assertInstance.ok.strictEqual, undefined);
+  assert.strictEqual(typeof assertInstance.strictEqual, 'function');
+  assertInstance.ok(true);
+  assertInstance.throws(
+    () => {
+      assertInstance.fail();
+    },
+    {
+      code: 'ERR_ASSERTION',
+      name: 'AssertionError',
+      message: 'Failed',
+      operator: 'fail',
+      actual: undefined,
+      expected: undefined,
+      generatedMessage: true,
+      stack: /Failed/,
+    }
+  );
+  assertInstance.equal(undefined, undefined);
+  assertInstance.equal(null, undefined);
+  assertInstance.equal(2, '2');
+  assertInstance.notEqual(true, false);
+  assertInstance.throws(() => assertInstance.deepEqual(/a/), {
+    code: 'ERR_MISSING_ARGS',
+  });
+  assertInstance.throws(() => assertInstance.notDeepEqual('test'), {
+    code: 'ERR_MISSING_ARGS',
+  });
+  assertInstance.notStrictEqual(2, '2');
+  assertInstance.throws(
+    () => assertInstance.strictEqual(2, '2'),
+    assertInstance.AssertionError,
+    "strictEqual(2, '2')"
+  );
+  assertInstance.throws(
+    () => {
+      assertInstance.partialDeepStrictEqual(
+        { a: true },
+        { a: false },
+        'custom message'
+      );
+    },
+    {
+      code: 'ERR_ASSERTION',
+      name: 'AssertionError',
+      message:
+        'custom message\n+ actual - expected\n\n  {\n+   a: true\n-   a: false\n  }\n',
+    }
+  );
+  assertInstance.throws(() => assertInstance.match(/abc/, 'string'), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    message:
+      'The "regexp" argument must be an instance of RegExp. ' +
+      "Received type string ('string')",
+  });
+  assertInstance.throws(() => assertInstance.doesNotMatch(/abc/, 'string'), {
+    code: 'ERR_INVALID_ARG_TYPE',
+    message:
+      'The "regexp" argument must be an instance of RegExp. ' +
+      "Received type string ('string')",
+  });
+
+  /* eslint-disable no-restricted-syntax */
+  {
+    function thrower(errorConstructor) {
+      throw new errorConstructor({});
+    }
+
+    let threw = false;
+    try {
+      assertInstance.doesNotThrow(
+        () => thrower(TypeError),
+        assertInstance.AssertionError
+      );
+    } catch (e) {
+      threw = true;
+      assertInstance.ok(e instanceof TypeError);
+    }
+    assertInstance.ok(
+      threw,
+      'assertInstance.doesNotThrow with an explicit error is eating extra errors'
+    );
+  }
+  {
+    let threw = false;
+    const rangeError = new RangeError('my range');
+
+    try {
+      assertInstance.doesNotThrow(
+        () => {
+          throw new TypeError('wrong type');
+        },
+        TypeError,
+        rangeError
+      );
+    } catch (e) {
+      threw = true;
+      assertInstance.ok(e.message.includes(rangeError.message));
+      assertInstance.ok(e instanceof assertInstance.AssertionError);
+      assertInstance.ok(!e.stack.includes('doesNotThrow'), e);
+    }
+    assertInstance.ok(threw);
+  }
+  /* eslint-enable no-restricted-syntax */
+});
+
+test('Assert class strict', () => {
+  const assertInstance = new Assert();
+
+  assertInstance.equal(assertInstance.equal, assertInstance.strictEqual);
+  assertInstance.equal(
+    assertInstance.deepEqual,
+    assertInstance.deepStrictEqual
+  );
+  assertInstance.equal(assertInstance.notEqual, assertInstance.notStrictEqual);
+  assertInstance.equal(
+    assertInstance.notDeepEqual,
+    assertInstance.notDeepStrictEqual
+  );
+});
+
+test('Assert class with invalid diff option', () => {
+  assert.throws(() => new Assert({ diff: 'invalid' }), {
+    code: 'ERR_INVALID_ARG_VALUE',
+    name: 'TypeError',
+    message: "The property 'options.diff' must be one of: 'simple', 'full'. Received 'invalid'",
+  });
+});
+
+const longLinesOfAs = 'A\n'.repeat(100);
+const longLinesOFBs = 'B\n'.repeat(100);
+const truncatedAs = 'A\\n'.repeat(10) + '...';
+const truncatedBs = 'B\\n'.repeat(10) + '...';
+
+const longStringOfAs = 'A'.repeat(10_000);
+const longStringOfBs = 'B'.repeat(10_000);
+
+const longLinesOfAsWithEllipsis = longStringOfAs.substring(0, 9_488) + '...';
+const longLinesOFBsWithEllipsis = longStringOfBs.substring(0, 9_488) + '...';
+test('Assert class non strict with full diff', () => {
+  const assertInstance = new Assert({ diff: 'full', strict: false });
+
+  // long strings
+  {
+    assertInstance.throws(
+      () => {
+        assertInstance.strictEqual(longStringOfAs, longStringOfBs);
+      },
+      (err) => {
+        assertInstance.strictEqual(err.code, 'ERR_ASSERTION');
+        assertInstance.strictEqual(err.operator, 'strictEqual');
+        assertInstance.strictEqual(err.diff, 'full');
+        assertInstance.strictEqual(err.actual, longStringOfAs);
+        assertInstance.strictEqual(err.expected, longStringOfBs);
+
+        assertInstance.strictEqual(
+          err.message,
+          `Expected values to be strictly equal:\n+ actual - expected\n\n` +
+            `+ '${longStringOfAs}'\n- '${longStringOfBs}'\n`
+        );
+        assertInstance.ok(
+          inspect(err).includes(`actual: '${longLinesOfAsWithEllipsis}'`)
+        );
+        assertInstance.ok(
+          inspect(err).includes(`expected: '${longLinesOFBsWithEllipsis}'`)
+        );
+        return true;
+      }
+    );
+
+    assertInstance.throws(
+      () => {
+        assertInstance.notStrictEqual(longStringOfAs, longStringOfAs);
+      },
+      (err) => {
+        assertInstance.strictEqual(err.code, 'ERR_ASSERTION');
+        assertInstance.strictEqual(err.operator, 'notStrictEqual');
+        assertInstance.strictEqual(err.diff, 'full');
+        assertInstance.strictEqual(err.actual, longStringOfAs);
+        assertInstance.strictEqual(err.expected, longStringOfAs);
+
+        assertInstance.strictEqual(
+          err.message,
+          `Expected "actual" to be strictly unequal to:\n\n` +
+            `'${longStringOfAs}'`
+        );
+        assertInstance.ok(
+          inspect(err).includes(`actual: '${longLinesOfAsWithEllipsis}'`)
+        );
+        assertInstance.ok(
+          inspect(err).includes(`expected: '${longLinesOfAsWithEllipsis}'`)
+        );
+        return true;
+      }
+    );
+
+    assertInstance.throws(
+      () => {
+        assertInstance.deepEqual(longStringOfAs, longStringOfBs);
+      },
+      (err) => {
+        assertInstance.strictEqual(err.code, 'ERR_ASSERTION');
+        assertInstance.strictEqual(err.operator, 'deepEqual');
+        assertInstance.strictEqual(err.diff, 'full');
+        assertInstance.strictEqual(err.actual, longStringOfAs);
+        assertInstance.strictEqual(err.expected, longStringOfBs);
+
+        assertInstance.strictEqual(
+          err.message,
+          `Expected values to be loosely deep-equal:\n\n` +
+            `'${longStringOfAs}'\n\nshould loosely deep-equal\n\n'${longStringOfBs}'`
+        );
+        assertInstance.ok(
+          inspect(err).includes(`actual: '${longLinesOfAsWithEllipsis}'`)
+        );
+        assertInstance.ok(
+          inspect(err).includes(`expected: '${longLinesOFBsWithEllipsis}'`)
+        );
+        return true;
+      }
+    );
+  }
+
+  // long lines
+  {
+    assertInstance.throws(
+      () => {
+        assertInstance.strictEqual(longLinesOfAs, longLinesOFBs);
+      },
+      (err) => {
+        assertInstance.strictEqual(err.code, 'ERR_ASSERTION');
+        assertInstance.strictEqual(err.operator, 'strictEqual');
+        assertInstance.strictEqual(err.diff, 'full');
+        assertInstance.strictEqual(err.actual, longLinesOfAs);
+        assertInstance.strictEqual(err.expected, longLinesOFBs);
+
+        assertInstance.strictEqual(err.message.split('\n').length, 204);
+        assertInstance.strictEqual(err.actual.split('\n').length, 101);
+        assertInstance.ok(
+          err.message.includes('Expected values to be strictly equal')
+        );
+        assertInstance.ok(inspect(err).includes(`actual: '${truncatedAs}`));
+        assertInstance.ok(inspect(err).includes(`expected: '${truncatedBs}`));
+        return true;
+      }
+    );
+
+    assertInstance.throws(
+      () => {
+        assertInstance.notStrictEqual(longLinesOfAs, longLinesOfAs);
+      },
+      (err) => {
+        assertInstance.strictEqual(err.code, 'ERR_ASSERTION');
+        assertInstance.strictEqual(err.operator, 'notStrictEqual');
+        assertInstance.strictEqual(err.diff, 'full');
+        assertInstance.strictEqual(err.actual, longLinesOfAs);
+        assertInstance.strictEqual(err.expected, longLinesOfAs);
+
+        assertInstance.strictEqual(err.message.split('\n').length, 103);
+        assertInstance.strictEqual(err.actual.split('\n').length, 101);
+        assertInstance.ok(
+          err.message.includes(`Expected "actual" to be strictly unequal to:`)
+        );
+        assertInstance.ok(inspect(err).includes(`actual: '${truncatedAs}`));
+        assertInstance.ok(inspect(err).includes(`expected: '${truncatedAs}`));
+        return true;
+      }
+    );
+
+    assertInstance.throws(
+      () => {
+        assertInstance.deepEqual(longLinesOfAs, longLinesOFBs);
+      },
+      (err) => {
+        assertInstance.strictEqual(err.code, 'ERR_ASSERTION');
+        assertInstance.strictEqual(err.operator, 'deepEqual');
+        assertInstance.strictEqual(err.diff, 'full');
+        assertInstance.strictEqual(err.actual, longLinesOfAs);
+        assertInstance.strictEqual(err.expected, longLinesOFBs);
+
+        assertInstance.strictEqual(err.message.split('\n').length, 205);
+        assertInstance.strictEqual(err.actual.split('\n').length, 101);
+        assertInstance.ok(
+          err.message.includes(`Expected values to be loosely deep-equal:`)
+        );
+        assertInstance.ok(inspect(err).includes(`actual: '${truncatedAs}`));
+        assertInstance.ok(inspect(err).includes(`expected: '${truncatedBs}`));
+        return true;
+      }
+    );
+  }
+});
+
+test('Assert class non strict with simple diff', () => {
+  const assertInstance = new Assert({ diff: 'simple', strict: false });
+
+  // long strings
+  {
+    assertInstance.throws(
+      () => {
+        assertInstance.strictEqual(longStringOfAs, longStringOfBs);
+      },
+      (err) => {
+        assertInstance.strictEqual(err.code, 'ERR_ASSERTION');
+        assertInstance.strictEqual(err.operator, 'strictEqual');
+        assertInstance.strictEqual(err.diff, 'simple');
+        assertInstance.strictEqual(err.actual, longStringOfAs);
+        assertInstance.strictEqual(err.expected, longStringOfBs);
+
+        assertInstance.strictEqual(
+          err.message,
+          `Expected values to be strictly equal:\n+ actual - expected\n\n` +
+            `+ '${longStringOfAs}'\n- '${longStringOfBs}'\n`
+        );
+        assertInstance.ok(
+          inspect(err).includes(`actual: '${longLinesOfAsWithEllipsis}'`)
+        );
+        assertInstance.ok(
+          inspect(err).includes(`expected: '${longLinesOFBsWithEllipsis}'`)
+        );
+        return true;
+      }
+    );
+
+    assertInstance.throws(
+      () => {
+        assertInstance.notStrictEqual(longStringOfAs, longStringOfAs);
+      },
+      (err) => {
+        assertInstance.strictEqual(err.code, 'ERR_ASSERTION');
+        assertInstance.strictEqual(err.operator, 'notStrictEqual');
+        assertInstance.strictEqual(err.diff, 'simple');
+        assertInstance.strictEqual(err.actual, longStringOfAs);
+        assertInstance.strictEqual(err.expected, longStringOfAs);
+
+        assertInstance.strictEqual(
+          err.message,
+          `Expected "actual" to be strictly unequal to:\n\n` +
+            `'${longStringOfAs}'`
+        );
+        assertInstance.ok(
+          inspect(err).includes(`actual: '${longLinesOfAsWithEllipsis}'`)
+        );
+        assertInstance.ok(
+          inspect(err).includes(`expected: '${longLinesOfAsWithEllipsis}'`)
+        );
+        return true;
+      }
+    );
+
+    assertInstance.throws(
+      () => {
+        assertInstance.deepEqual(longStringOfAs, longStringOfBs);
+      },
+      (err) => {
+        assertInstance.strictEqual(err.code, 'ERR_ASSERTION');
+        assertInstance.strictEqual(err.operator, 'deepEqual');
+        assertInstance.strictEqual(err.diff, 'simple');
+        assertInstance.strictEqual(err.actual, longStringOfAs);
+        assertInstance.strictEqual(err.expected, longStringOfBs);
+
+        assertInstance.strictEqual(
+          err.message,
+          `Expected values to be loosely deep-equal:\n\n` +
+            `'${
+              longStringOfAs.substring(0, 508) + '...'
+            }\n\nshould loosely deep-equal\n\n'${
+              longStringOfBs.substring(0, 508) + '...'
+            }`
+        );
+        assertInstance.ok(
+          inspect(err).includes(`actual: '${longLinesOfAsWithEllipsis}'`)
+        );
+        assertInstance.ok(
+          inspect(err).includes(`expected: '${longLinesOFBsWithEllipsis}'`)
+        );
+        return true;
+      }
+    );
+  }
+
+  // long lines
+  {
+    assertInstance.throws(
+      () => {
+        assertInstance.strictEqual(longLinesOfAs, longLinesOFBs);
+      },
+      (err) => {
+        assertInstance.strictEqual(err.code, 'ERR_ASSERTION');
+        assertInstance.strictEqual(err.operator, 'strictEqual');
+        assertInstance.strictEqual(err.diff, 'simple');
+        assertInstance.strictEqual(err.actual, longLinesOfAs);
+        assertInstance.strictEqual(err.expected, longLinesOFBs);
+        assertInstance.strictEqual(err.message.split('\n').length, 204);
+        assertInstance.strictEqual(err.actual.split('\n').length, 101);
+
+        assertInstance.ok(
+          err.message.includes('Expected values to be strictly equal')
+        );
+        assertInstance.ok(inspect(err).includes(`actual: '${truncatedAs}`));
+        assertInstance.ok(inspect(err).includes(`expected: '${truncatedBs}`));
+        return true;
+      }
+    );
+
+    assertInstance.throws(
+      () => {
+        assertInstance.notStrictEqual(longLinesOfAs, longLinesOfAs);
+      },
+      (err) => {
+        assertInstance.strictEqual(err.code, 'ERR_ASSERTION');
+        assertInstance.strictEqual(err.operator, 'notStrictEqual');
+        assertInstance.strictEqual(err.diff, 'simple');
+        assertInstance.strictEqual(err.actual, longLinesOfAs);
+        assertInstance.strictEqual(err.expected, longLinesOfAs);
+
+        assertInstance.strictEqual(err.message.split('\n').length, 50);
+        assertInstance.strictEqual(err.actual.split('\n').length, 101);
+        assertInstance.ok(
+          err.message.includes(`Expected "actual" to be strictly unequal to:`)
+        );
+        assertInstance.ok(inspect(err).includes(`actual: '${truncatedAs}`));
+        assertInstance.ok(inspect(err).includes(`expected: '${truncatedAs}`));
+        return true;
+      }
+    );
+
+    assertInstance.throws(
+      () => {
+        assertInstance.deepEqual(longLinesOfAs, longLinesOFBs);
+      },
+      (err) => {
+        assertInstance.strictEqual(err.code, 'ERR_ASSERTION');
+        assertInstance.strictEqual(err.operator, 'deepEqual');
+        assertInstance.strictEqual(err.diff, 'simple');
+        assertInstance.strictEqual(err.actual, longLinesOfAs);
+        assertInstance.strictEqual(err.expected, longLinesOFBs);
+
+        assertInstance.strictEqual(err.message.split('\n').length, 109);
+        assertInstance.strictEqual(err.actual.split('\n').length, 101);
+        assertInstance.ok(
+          err.message.includes(`Expected values to be loosely deep-equal:`)
+        );
+        assertInstance.ok(inspect(err).includes(`actual: '${truncatedAs}`));
+        assertInstance.ok(inspect(err).includes(`expected: '${truncatedBs}`));
+        return true;
+      }
+    );
+  }
+});
+
+// Shared setup for skipPrototype tests
+{
+  const message = 'Expected values to be strictly deep-equal:\n' +
+  '+ actual - expected\n' +
+  '\n' +
+  '  [\n' +
+  '    1,\n' +
+  '    2,\n' +
+  '    3,\n' +
+  '    4,\n' +
+  '    5,\n' +
+  '+   6,\n' +
+  '-   9,\n' +
+  '    7\n' +
+  '  ]\n';
+
+  function CoolClass(name) { this.name = name; }
+
+  function AwesomeClass(name) { this.name = name; }
+
+  class Modern { constructor(value) { this.value = value; } }
+  class Legacy { constructor(value) { this.value = value; } }
+
+  const cool = new CoolClass('Assert is inspiring');
+  const awesome = new AwesomeClass('Assert is inspiring');
+  const modern = new Modern(42);
+  const legacy = new Legacy(42);
+
+  test('Assert class strict with skipPrototype', () => {
+    const assertInstance = new Assert({ skipPrototype: true });
+
+    assert.throws(
+      () => assertInstance.deepEqual([1, 2, 3, 4, 5, 6, 7], [1, 2, 3, 4, 5, 9, 7]),
+      { message }
+    );
+
+    assertInstance.deepEqual(cool, awesome);
+    assertInstance.deepStrictEqual(cool, awesome);
+    assertInstance.deepEqual(modern, legacy);
+    assertInstance.deepStrictEqual(modern, legacy);
+
+    const cool2 = new CoolClass('Soooo coooool');
+    assert.throws(
+      () => assertInstance.deepStrictEqual(cool, cool2),
+      { code: 'ERR_ASSERTION' }
+    );
+
+    const nested1 = { obj: new CoolClass('test'), arr: [1, 2, 3] };
+    const nested2 = { obj: new AwesomeClass('test'), arr: [1, 2, 3] };
+    assertInstance.deepStrictEqual(nested1, nested2);
+
+    const arr = new Uint8Array([1, 2, 3]);
+    const buf = Buffer.from([1, 2, 3]);
+    assertInstance.deepStrictEqual(arr, buf);
+  });
+
+  test('Assert class non strict with skipPrototype', () => {
+    const assertInstance = new Assert({ strict: false, skipPrototype: true });
+
+    assert.throws(
+      () => assertInstance.deepStrictEqual([1, 2, 3, 4, 5, 6, 7], [1, 2, 3, 4, 5, 9, 7]),
+      { message }
+    );
+
+    assertInstance.deepStrictEqual(cool, awesome);
+    assertInstance.deepStrictEqual(modern, legacy);
+  });
+
+  test('Assert class skipPrototype with complex objects', () => {
+    const assertInstance = new Assert({ skipPrototype: true });
+
+    function ComplexAwesomeClass(name, age) {
+      this.name = name;
+      this.age = age;
+      this.settings = {
+        theme: 'dark',
+        lang: 'en'
+      };
+    }
+
+    function ComplexCoolClass(name, age) {
+      this.name = name;
+      this.age = age;
+      this.settings = {
+        theme: 'dark',
+        lang: 'en'
+      };
+    }
+
+    const awesome1 = new ComplexAwesomeClass('Foo', 30);
+    const cool1 = new ComplexCoolClass('Foo', 30);
+
+    assertInstance.deepStrictEqual(awesome1, cool1);
+
+    const cool2 = new ComplexCoolClass('Foo', 30);
+    cool2.settings.theme = 'light';
+
+    assert.throws(
+      () => assertInstance.deepStrictEqual(awesome1, cool2),
+      { code: 'ERR_ASSERTION' }
+    );
+  });
+
+  test('Assert class skipPrototype with arrays and special objects', () => {
+    const assertInstance = new Assert({ skipPrototype: true });
+
+    const arr1 = [1, 2, 3];
+    const arr2 = new Array(1, 2, 3);
+    assertInstance.deepStrictEqual(arr1, arr2);
+
+    const date1 = new Date('2023-01-01');
+    const date2 = new Date('2023-01-01');
+    assertInstance.deepStrictEqual(date1, date2);
+
+    const regex1 = /test/g;
+    const regex2 = new RegExp('test', 'g');
+    assertInstance.deepStrictEqual(regex1, regex2);
+
+    const date3 = new Date('2023-01-02');
+    assert.throws(
+      () => assertInstance.deepStrictEqual(date1, date3),
+      { code: 'ERR_ASSERTION' }
+    );
+  });
+
+  test('Assert class skipPrototype with notDeepStrictEqual', () => {
+    const assertInstance = new Assert({ skipPrototype: true });
+
+    assert.throws(
+      () => assertInstance.notDeepStrictEqual(cool, awesome),
+      { code: 'ERR_ASSERTION' }
+    );
+
+    const notAwesome = new AwesomeClass('Not so awesome');
+    assertInstance.notDeepStrictEqual(cool, notAwesome);
+
+    const defaultAssertInstance = new Assert({ skipPrototype: false });
+    defaultAssertInstance.notDeepStrictEqual(cool, awesome);
+  });
+
+  test('Assert class skipPrototype with mixed types', () => {
+    const assertInstance = new Assert({ skipPrototype: true });
+
+    const obj1 = { value: 42, nested: { prop: 'test' } };
+
+    function CustomObj(value, nested) {
+      this.value = value;
+      this.nested = nested;
+    }
+
+    const obj2 = new CustomObj(42, { prop: 'test' });
+    assertInstance.deepStrictEqual(obj1, obj2);
+
+    assert.throws(
+      () => assertInstance.deepStrictEqual({ num: 42 }, { num: '42' }),
+      { code: 'ERR_ASSERTION' }
+    );
+  });
+}
diff --git a/test/js/node/test/parallel/test-assert.js b/test/js/node/test/parallel/test-assert.js
index 916065ccbf38..ede25f06eb12 100644
--- a/test/js/node/test/parallel/test-assert.js
+++ b/test/js/node/test/parallel/test-assert.js
@@ -557,7 +557,7 @@ test('Output that extends beyond 10 lines should also be truncated for display',
     assert.strictEqual(multilineString, '');
   }, (err) => {
     assert.strictEqual(err.code, 'ERR_ASSERTION');
-    assert.strictEqual(err.message.split('\n').length, 21);
+    assert.strictEqual(err.message.split('\n').length, 20);
     assert.strictEqual(err.actual.split('\n').length, 16);
     assert.ok(inspect(err).includes(
       "actual: 'fhqwhgads\\n' +\n" +
@@ -1496,8 +1496,8 @@ test('Additional assert', () => {
       () => assert.match(/abc/, 'string'),
       {
         code: 'ERR_INVALID_ARG_TYPE',
-        message: 'The "regexp" argument must be of type RegExp.' +
-          invalidArgTypeHelper('string')
+        message: 'The "regexp" argument must be an instance of RegExp. ' +
+                "Received type string ('string')"
       }
     );
     assert.throws(
@@ -1549,8 +1549,8 @@ test('Additional assert', () => {
       () => assert.doesNotMatch(/abc/, 'string'),
       {
         code: 'ERR_INVALID_ARG_TYPE',
-        message: 'The "regexp" argument must be of type RegExp.' +
-        invalidArgTypeHelper('string')
+        message: 'The "regexp" argument must be an instance of RegExp. ' +
+                "Received type string ('string')"
       }
     );
     assert.throws(
diff --git a/test/js/node/test/parallel/test-child-process-advanced-serialization.js b/test/js/node/test/parallel/test-child-process-advanced-serialization.js
index 14c9b2be875f..71a0c44a042d 100644
--- a/test/js/node/test/parallel/test-child-process-advanced-serialization.js
+++ b/test/js/node/test/parallel/test-child-process-advanced-serialization.js
@@ -11,7 +11,7 @@ if (process.argv[2] !== 'child') {
       child_process.spawn(process.execPath, [], { serialization: value });
     }, {
       code: 'ERR_INVALID_ARG_VALUE',
-      message: "The argument 'options.serialization' " +
+      message: "The property 'options.serialization' " +
         "must be one of: undefined, 'json', 'advanced'. " +
         `Received ${inspect(value)}`
     });
diff --git a/test/js/node/test/parallel/test-child-process-bad-stdio.js b/test/js/node/test/parallel/test-child-process-bad-stdio.js
new file mode 100644
index 000000000000..1e5bd4afc44e
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-bad-stdio.js
@@ -0,0 +1,66 @@
+'use strict';
+// Flags: --expose-internals
+const common = require('../common');
+
+if (process.argv[2] === 'child') {
+  setTimeout(() => {}, common.platformTimeout(1000));
+  return;
+}
+
+const assert = require('node:assert');
+const cp = require('node:child_process');
+const { mock, test } = require('node:test');
+const { ChildProcess } = require('internal/child_process');
+
+// Monkey patch spawn() to create a child process normally, but destroy the
+// stdout and stderr streams. This replicates the conditions where the streams
+// cannot be properly created.
+const original = ChildProcess.prototype.spawn;
+
+mock.method(ChildProcess.prototype, 'spawn', function() {
+  const err = original.apply(this, arguments);
+
+  this.stdout.destroy();
+  this.stderr.destroy();
+  this.stdout = null;
+  this.stderr = null;
+
+  return err;
+});
+
+function createChild(options, callback) {
+  const [cmd, opts] = common.escapePOSIXShell`"${process.execPath}" "${__filename}" child`;
+  options = { ...options, env: { ...opts?.env, ...options.env } };
+
+  return cp.exec(cmd, options, common.mustCall(callback));
+}
+
+test('normal execution of a child process is handled', (_, done) => {
+  createChild({}, common.mustCall((err, stdout, stderr) => {
+    assert.strictEqual(err, null);
+    assert.strictEqual(stdout, '');
+    assert.strictEqual(stderr, '');
+    done();
+  }));
+});
+
+test('execution with an error event is handled', (_, done) => {
+  const error = new Error('foo');
+  const child = createChild({}, common.mustCall((err, stdout, stderr) => {
+    assert.strictEqual(err, error);
+    assert.strictEqual(stdout, '');
+    assert.strictEqual(stderr, '');
+    done();
+  }));
+
+  child.emit('error', error);
+});
+
+test('execution with a killed process is handled', (_, done) => {
+  createChild({ timeout: 1 }, common.mustCall((err, stdout, stderr) => {
+    assert.strictEqual(err.killed, true);
+    assert.strictEqual(stdout, '');
+    assert.strictEqual(stderr, '');
+    done();
+  }));
+});
diff --git a/test/js/node/test/parallel/test-child-process-exec-kill-throws.js b/test/js/node/test/parallel/test-child-process-exec-kill-throws.js
new file mode 100644
index 000000000000..fbc9677f5310
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-exec-kill-throws.js
@@ -0,0 +1,31 @@
+'use strict';
+// Flags: --expose-internals
+const common = require('../common');
+const assert = require('assert');
+const cp = require('child_process');
+
+if (process.argv[2] === 'child') {
+  // Since maxBuffer is 0, this should trigger an error.
+  console.log('foo');
+} else {
+  const internalCp = require('internal/child_process');
+
+  // Monkey patch ChildProcess#kill() to kill the process and then throw.
+  const kill = internalCp.ChildProcess.prototype.kill;
+
+  internalCp.ChildProcess.prototype.kill = function() {
+    kill.apply(this, arguments);
+    throw new Error('mock error');
+  };
+
+  const cmd = `"${process.execPath}" "${__filename}" child`;
+  const options = { maxBuffer: 0, killSignal: 'SIGKILL' };
+
+  const child = cp.exec(cmd, options, common.mustCall((err, stdout, stderr) => {
+    // Verify that if ChildProcess#kill() throws, the error is reported.
+    assert.strictEqual(err.message, 'mock error', err);
+    assert.strictEqual(stdout, '');
+    assert.strictEqual(stderr, '');
+    assert.strictEqual(child.killed, true);
+  }));
+}
diff --git a/test/js/node/test/parallel/test-child-process-validate-stdio.js b/test/js/node/test/parallel/test-child-process-validate-stdio.js
new file mode 100644
index 000000000000..5ba6f0fd123c
--- /dev/null
+++ b/test/js/node/test/parallel/test-child-process-validate-stdio.js
@@ -0,0 +1,63 @@
+'use strict';
+// Flags: --expose-internals
+
+const common = require('../common');
+const assert = require('assert');
+const getValidStdio = require('internal/child_process').getValidStdio;
+
+const expectedError = { code: 'ERR_INVALID_ARG_VALUE', name: 'TypeError' };
+
+// Should throw if string and not ignore, pipe, or inherit
+assert.throws(() => getValidStdio('foo'), expectedError);
+
+// Should throw if not a string or array
+assert.throws(() => getValidStdio(600), expectedError);
+
+// Should populate stdio with undefined if len < 3
+{
+  const stdio1 = [];
+  const result = getValidStdio(stdio1, false);
+  assert.strictEqual(stdio1.length, 3);
+  assert.strictEqual(Object.hasOwn(result, 'stdio'), true);
+  assert.strictEqual(Object.hasOwn(result, 'ipc'), true);
+  assert.strictEqual(Object.hasOwn(result, 'ipcFd'), true);
+}
+
+// Should throw if stdio has ipc and sync is true
+const stdio2 = ['ipc', 'ipc', 'ipc'];
+assert.throws(() => getValidStdio(stdio2, true),
+              { code: 'ERR_IPC_SYNC_FORK', name: 'Error' }
+);
+
+// Should throw if stdio is not a valid input
+{
+  const stdio = ['foo'];
+  assert.throws(() => getValidStdio(stdio, false),
+                { code: 'ERR_INVALID_SYNC_FORK_INPUT', name: 'TypeError' }
+  );
+}
+
+// Should throw if stdio is not a valid option
+{
+  const stdio = [{ foo: 'bar' }];
+  assert.throws(() => getValidStdio(stdio), expectedError);
+}
+
+const { isMainThread } = require('worker_threads');
+
+if (isMainThread) {
+  const stdio3 = [process.stdin, process.stdout, process.stderr];
+  const result = getValidStdio(stdio3, false);
+  assert.deepStrictEqual(result, {
+    stdio: [
+      { type: 'fd', fd: 0 },
+      { type: 'fd', fd: 1 },
+      { type: 'fd', fd: 2 },
+    ],
+    ipc: undefined,
+    ipcFd: undefined
+  });
+} else {
+  common.printSkipMessage(
+    'stdio is not associated with file descriptors in Workers');
+}
diff --git a/test/js/node/test/parallel/test-compile-cache-api-flush.js b/test/js/node/test/parallel/test-compile-cache-api-flush.js
new file mode 100644
index 000000000000..7e66b1fee103
--- /dev/null
+++ b/test/js/node/test/parallel/test-compile-cache-api-flush.js
@@ -0,0 +1,47 @@
+'use strict';
+
+// This tests module.flushCompileCache() works as expected.
+
+require('../common');
+const { spawnSyncAndAssert } = require('../common/child_process');
+const assert = require('assert');
+const tmpdir = require('../common/tmpdir');
+const fixtures = require('../common/fixtures');
+
+{
+  // Test that it works with non-existent directory.
+  tmpdir.refresh();
+  const cacheDir = tmpdir.resolve('compile_cache');
+  spawnSyncAndAssert(
+    process.execPath,
+    [fixtures.path('compile-cache-flush.js')],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_COMPILE_CACHE: cacheDir,
+      },
+      cwd: tmpdir.path
+    },
+    {
+      stdout(output) {
+        // This contains output from the nested spawnings of compile-cache-flush.js.
+        assert.match(output, /child1.* cache for .*compile-cache-flush\.js was accepted, keeping the in-memory entry/);
+        assert.match(output, /child2.* cache for .*compile-cache-flush\.js was accepted, keeping the in-memory entry/);
+        return true;
+      },
+      stderr(output) {
+        // This contains output from the top-level spawning of compile-cache-flush.js.
+        assert.match(output, /reading cache from .*compile_cache.* for CommonJS .*compile-cache-flush\.js/);
+        assert.match(output, /compile-cache-flush\.js was not initialized, initializing the in-memory entry/);
+
+        const writeRE = /writing cache for .*compile-cache-flush\.js.*success/;
+        const flushRE = /module\.flushCompileCache\(\) finished/;
+        assert.match(output, writeRE);
+        assert.match(output, flushRE);
+        // The cache writing should happen before flushing finishes i.e. it's not delayed until process shutdown.
+        assert(output.match(writeRE).index < output.match(flushRE).index);
+        return true;
+      }
+    });
+}
diff --git a/test/js/node/test/parallel/test-compile-cache-api-portable.js b/test/js/node/test/parallel/test-compile-cache-api-portable.js
new file mode 100644
index 000000000000..3c7c84b32202
--- /dev/null
+++ b/test/js/node/test/parallel/test-compile-cache-api-portable.js
@@ -0,0 +1,100 @@
+'use strict';
+
+// This tests module.enableCompileCache({ directory, portable: true }) works
+// and supports portable paths across directory relocations.
+
+require('../common');
+const { spawnSyncAndAssert } = require('../common/child_process');
+const assert = require('assert');
+const fs = require('fs');
+const tmpdir = require('../common/tmpdir');
+const path = require('path');
+const fixtures = require('../common/fixtures');
+
+tmpdir.refresh();
+const workDir = path.join(tmpdir.path, 'work');
+const cacheRel = '.compile_cache_dir';
+fs.mkdirSync(workDir, { recursive: true });
+
+const wrapper = fixtures.path('compile-cache-wrapper-options.js');
+const target = path.join(workDir, 'target.js');
+
+fs.writeFileSync(target, '');
+const NODE_TEST_COMPILE_CACHE_OPTIONS = JSON.stringify({ directory: cacheRel, portable: true });
+
+// First run
+{
+  spawnSyncAndAssert(
+    process.execPath,
+    ['-r', wrapper, target],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_TEST_COMPILE_CACHE_OPTIONS,
+      },
+      cwd: workDir,
+    },
+    {
+      stdout(output) {
+        console.log(output);
+        assert.match(output, /dir before enableCompileCache: undefined/);
+        assert.match(
+          output,
+          /dir after enableCompileCache: .+\.compile_cache_dir/
+        );
+        return true;
+      },
+      stderr(output) {
+        assert.match(
+          output,
+          /target\.js was not initialized, initializing the in-memory entry/
+        );
+        assert.match(output, /writing cache for .*target\.js.*success/);
+        return true;
+      },
+    }
+  );
+}
+
+// Second run — moved directory, but same relative cache path
+{
+  const movedWorkDir = `${workDir}_moved`;
+  fs.renameSync(workDir, movedWorkDir);
+
+  spawnSyncAndAssert(
+    process.execPath,
+    [
+      '-r',
+      wrapper,
+      path.join(movedWorkDir, 'target.js'),
+    ],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_TEST_COMPILE_CACHE_OPTIONS,
+      },
+      cwd: movedWorkDir,
+    },
+    {
+      stdout(output) {
+        console.log(output);
+        assert.match(output, /dir before enableCompileCache: undefined/);
+        assert.match(
+          output,
+          /dir after enableCompileCache: .+\.compile_cache_dir/
+        );
+        return true;
+      },
+      stderr(output) {
+        assert.match(
+          output,
+          /cache for .*target\.js was accepted, keeping the in-memory entry/
+        );
+        assert.match(output, /.*skip .*target\.js because cache was the same/);
+        return true;
+      },
+    }
+  );
+}
diff --git a/test/js/node/test/parallel/test-compile-cache-api-success.js b/test/js/node/test/parallel/test-compile-cache-api-success.js
new file mode 100644
index 000000000000..2d4d94fd6e9d
--- /dev/null
+++ b/test/js/node/test/parallel/test-compile-cache-api-success.js
@@ -0,0 +1,79 @@
+'use strict';
+
+// This tests module.enableCompileCache() and module.getCompileCacheDir() work.
+
+require('../common');
+const { spawnSyncAndAssert } = require('../common/child_process');
+const assert = require('assert');
+const fixtures = require('../common/fixtures');
+const tmpdir = require('../common/tmpdir');
+const fs = require('fs');
+const path = require('path');
+
+{
+  // Test that it works with non-existent directory.
+  tmpdir.refresh();
+  const dir = tmpdir.resolve('.compile_cache_dir');
+
+  spawnSyncAndAssert(
+    process.execPath,
+    ['-r', fixtures.path('compile-cache-wrapper.js'), fixtures.path('snapshot', 'typescript.js')],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_COMPILE_CACHE: undefined,
+        NODE_TEST_COMPILE_CACHE_DIR: dir,
+      },
+      cwd: tmpdir.path
+    },
+    {
+      stdout(output) {
+        console.log(output);  // Logging for debugging.
+        assert.match(output, /dir before enableCompileCache: undefined/);
+        assert.match(output, /Compile cache enabled\. .*\.compile_cache_dir/);
+        assert.match(output, /dir after enableCompileCache: .*\.compile_cache_dir/);
+        return true;
+      },
+      stderr(output) {
+        console.log(output);  // Logging for debugging.
+        assert.match(output, /typescript\.js was not initialized, initializing the in-memory entry/);
+        assert.match(output, /writing cache for .*typescript\.js.*success/);
+        return true;
+      }
+    });
+
+  const cacheDir = fs.readdirSync(dir);
+  assert.strictEqual(cacheDir.length, 1);
+  const entries = fs.readdirSync(path.join(dir, cacheDir[0]));
+  assert.strictEqual(entries.length, 1);
+
+  // Second run reads the cache, but no need to re-write because it didn't change.
+  spawnSyncAndAssert(
+    process.execPath,
+    ['-r', fixtures.path('compile-cache-wrapper.js'), fixtures.path('snapshot', 'typescript.js')],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_COMPILE_CACHE: undefined,
+        NODE_TEST_COMPILE_CACHE_DIR: dir,
+      },
+      cwd: tmpdir.path
+    },
+    {
+      stdout(output) {
+        console.log(output);  // Logging for debugging.
+        assert.match(output, /dir before enableCompileCache: undefined/);
+        assert.match(output, /Compile cache enabled\. .*\.compile_cache_dir/);
+        assert.match(output, /dir after enableCompileCache: .*\.compile_cache_dir/);
+        return true;
+      },
+      stderr(output) {
+        console.log(output);  // Logging for debugging.
+        assert.match(output, /cache for .*typescript\.js was accepted, keeping the in-memory entry/);
+        assert.match(output, /.*skip .*typescript\.js because cache was the same/);
+        return true;
+      }
+    });
+}
diff --git a/test/js/node/test/parallel/test-compile-cache-api-tmpdir.js b/test/js/node/test/parallel/test-compile-cache-api-tmpdir.js
new file mode 100644
index 000000000000..e676893b01f5
--- /dev/null
+++ b/test/js/node/test/parallel/test-compile-cache-api-tmpdir.js
@@ -0,0 +1,92 @@
+'use strict';
+
+// This tests module.enableCompileCache() and module.getCompileCacheDir() work with
+// the TMPDIR environment variable override.
+
+require('../common');
+const { spawnSyncAndAssert } = require('../common/child_process');
+const assert = require('assert');
+const fixtures = require('../common/fixtures');
+const tmpdir = require('../common/tmpdir');
+const fs = require('fs');
+const path = require('path');
+
+{
+  // Test that it works with non-existent directory.
+  tmpdir.refresh();
+
+  spawnSyncAndAssert(
+    process.execPath,
+    ['-r', fixtures.path('compile-cache-wrapper.js'), fixtures.path('empty.js')],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_COMPILE_CACHE: undefined,
+        NODE_TEST_COMPILE_CACHE_DIR: undefined,
+        // TMPDIR is ignored on Windows while on other platforms, TMPDIR takes precedence.
+        // Override all related environment variables to ensure the tmpdir is configured properly
+        // regardless of the global environment variables used to run the test.
+        TMPDIR: tmpdir.path,
+        TEMP: tmpdir.path,
+        TMP: tmpdir.path,
+      },
+      cwd: tmpdir.path
+    },
+    {
+      stdout(output) {
+        console.log(output);  // Logging for debugging.
+        assert.match(output, /dir before enableCompileCache: undefined/);
+        assert.match(output, /Compile cache enabled\. .*node-compile-cache/);
+        assert.match(output, /dir after enableCompileCache: .*node-compile-cache/);
+        return true;
+      },
+      stderr(output) {
+        console.log(output);  // Logging for debugging.
+        assert.match(output, /empty\.js was not initialized, initializing the in-memory entry/);
+        assert.match(output, /writing cache for .*empty\.js.*success/);
+        return true;
+      }
+    });
+
+  const baseDir = path.join(tmpdir.path, 'node-compile-cache');
+  const cacheDir = fs.readdirSync(baseDir);
+  assert.strictEqual(cacheDir.length, 1);
+  const entries = fs.readdirSync(path.join(baseDir, cacheDir[0]));
+  assert.strictEqual(entries.length, 1);
+
+  // Second run reads the cache, but no need to re-write because it didn't change.
+  spawnSyncAndAssert(
+    process.execPath,
+    ['-r', fixtures.path('compile-cache-wrapper.js'), fixtures.path('empty.js')],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_COMPILE_CACHE: undefined,
+        NODE_TEST_COMPILE_CACHE_DIR: undefined,
+        // TMPDIR is ignored on Windows while on other platforms, TMPDIR takes precedence.
+        // Override all related environment variables to ensure the tmpdir is configured properly
+        // regardless of the global environment variables used to run the test.
+        TMPDIR: tmpdir.path,
+        TEMP: tmpdir.path,
+        TMP: tmpdir.path,
+      },
+      cwd: tmpdir.path
+    },
+    {
+      stdout(output) {
+        console.log(output);  // Logging for debugging.
+        assert.match(output, /dir before enableCompileCache: undefined/);
+        assert.match(output, /Compile cache enabled\. .*node-compile-cache/);
+        assert.match(output, /dir after enableCompileCache: .*node-compile-cache/);
+        return true;
+      },
+      stderr(output) {
+        console.log(output);  // Logging for debugging.
+        assert.match(output, /cache for .*empty\.js was accepted, keeping the in-memory entry/);
+        assert.match(output, /.*skip .*empty\.js because cache was the same/);
+        return true;
+      }
+    });
+}
diff --git a/test/js/node/test/parallel/test-compile-cache-bad-syntax.js b/test/js/node/test/parallel/test-compile-cache-bad-syntax.js
new file mode 100644
index 000000000000..63f6374b2c38
--- /dev/null
+++ b/test/js/node/test/parallel/test-compile-cache-bad-syntax.js
@@ -0,0 +1,54 @@
+'use strict';
+
+// This tests NODE_COMPILE_CACHE works.
+
+require('../common');
+const { spawnSyncAndExit } = require('../common/child_process');
+const fixtures = require('../common/fixtures');
+const tmpdir = require('../common/tmpdir');
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+
+{
+  // Test that it throws if the script fails to parse, and no cache is created.
+  tmpdir.refresh();
+  const dir = tmpdir.resolve('.compile_cache_dir');
+
+  spawnSyncAndExit(
+    process.execPath,
+    [fixtures.path('syntax', 'bad_syntax.js')],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_COMPILE_CACHE: dir
+      },
+      cwd: tmpdir.path
+    },
+    {
+      status: 1,
+      stderr: /skip .*bad_syntax\.js because the cache was not initialized/,
+    });
+
+  const cacheDir = fs.readdirSync(dir);
+  assert.strictEqual(cacheDir.length, 1);
+  const entries = fs.readdirSync(path.join(dir, cacheDir[0]));
+  assert.strictEqual(entries.length, 0);
+
+  spawnSyncAndExit(
+    process.execPath,
+    [fixtures.path('syntax', 'bad_syntax.mjs')],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_COMPILE_CACHE: dir
+      },
+      cwd: tmpdir.path
+    },
+    {
+      status: 1,
+      stderr: /skip .*bad_syntax\.mjs because the cache was not initialized/,
+    });
+}
diff --git a/test/js/node/test/parallel/test-compile-cache-disable.js b/test/js/node/test/parallel/test-compile-cache-disable.js
new file mode 100644
index 000000000000..36d01675c905
--- /dev/null
+++ b/test/js/node/test/parallel/test-compile-cache-disable.js
@@ -0,0 +1,39 @@
+'use strict';
+
+require('../common');
+const { spawnSyncAndAssert } = require('../common/child_process');
+const assert = require('assert');
+const fixtures = require('../common/fixtures');
+const tmpdir = require('../common/tmpdir');
+
+{
+  tmpdir.refresh();
+
+  spawnSyncAndAssert(
+    process.execPath,
+    ['-r', fixtures.path('compile-cache-wrapper.js'), fixtures.path('empty.js')],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_COMPILE_CACHE: undefined,
+        NODE_TEST_COMPILE_CACHE_DIR: tmpdir.path,
+        NODE_DISABLE_COMPILE_CACHE: '1',
+      },
+      cwd: tmpdir.path
+    },
+    {
+      stdout(output) {
+        console.log(output);  // Logging for debugging.
+        assert.match(output, /dir before enableCompileCache: undefined/);
+        assert.match(output, /Compile cache already disabled/);
+        assert.match(output, /dir after enableCompileCache: undefined/);
+        return true;
+      },
+      stderr(output) {
+        console.log(output);  // Logging for debugging.
+        assert.match(output, /Disabled by NODE_DISABLE_COMPILE_CACHE/);
+        return true;
+      }
+    });
+}
diff --git a/test/js/node/test/parallel/test-compile-cache-dynamic-import.js b/test/js/node/test/parallel/test-compile-cache-dynamic-import.js
new file mode 100644
index 000000000000..01731dc68225
--- /dev/null
+++ b/test/js/node/test/parallel/test-compile-cache-dynamic-import.js
@@ -0,0 +1,111 @@
+'use strict';
+
+// This tests NODE_COMPILE_CACHE works in existing directory.
+
+require('../common');
+const { spawnSyncAndAssert } = require('../common/child_process');
+const assert = require('assert');
+const tmpdir = require('../common/tmpdir');
+const fixtures = require('../common/fixtures');
+
+{
+  tmpdir.refresh();
+  const dir = tmpdir.resolve('.compile_cache_dir');
+  const cjs = fixtures.path('es-modules', 'dynamic-import', 'import.cjs');
+  const mjs = fixtures.path('es-modules', 'dynamic-import', 'import.mjs');
+
+  spawnSyncAndAssert(
+    process.execPath,
+    [cjs],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_COMPILE_CACHE: dir
+      },
+      cwd: tmpdir.path
+    },
+    {
+      trim: true,
+      stdout: 'hello world',
+      stderr(output) {
+        assert.match(output, /reading cache from .* for ESM .*mod\.js/);
+        assert.match(output, /mod\.js was not initialized, initializing the in-memory entry/);
+        assert.match(output, /writing cache for .*mod\.js.*success/);
+        assert.match(output, /reading cache .* for CommonJS .*import\.cjs/);
+        assert.match(output, /import\.cjs was not initialized, initializing the in-memory entry/);
+        assert.match(output, /writing cache for .*import\.cjs.*success/);
+        return true;
+      }
+    });
+
+  spawnSyncAndAssert(
+    process.execPath,
+    [cjs],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_COMPILE_CACHE: dir
+      },
+      cwd: tmpdir.path
+    },
+    {
+      trim: true,
+      stdout: 'hello world',
+      stderr(output) {
+        assert.match(output, /cache for .*mod\.js was accepted, keeping the in-memory entry/);
+        assert.match(output, /.*skip .*mod\.js because cache was the same/);
+        assert.match(output, /cache for .*import\.cjs was accepted, keeping the in-memory entry/);
+        assert.match(output, /.*skip .*import\.cjs because cache was the same/);
+        return true;
+      }
+    });
+
+  spawnSyncAndAssert(
+    process.execPath,
+    [mjs],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_COMPILE_CACHE: dir
+      },
+      cwd: tmpdir.path
+    },
+    {
+      trim: true,
+      stdout: 'hello world',
+      stderr(output) {
+        assert.match(output, /cache for .*mod\.js was accepted, keeping the in-memory entry/);
+        assert.match(output, /.*skip .*mod\.js because cache was the same/);
+        assert.match(output, /reading cache .* for ESM .*import\.mjs/);
+        assert.match(output, /import\.mjs was not initialized, initializing the in-memory entry/);
+        assert.match(output, /writing cache for .*import\.mjs.*success/);
+        return true;
+      }
+    });
+
+  spawnSyncAndAssert(
+    process.execPath,
+    [mjs],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_COMPILE_CACHE: dir
+      },
+      cwd: tmpdir.path
+    },
+    {
+      trim: true,
+      stdout: 'hello world',
+      stderr(output) {
+        assert.match(output, /cache for .*mod\.js was accepted, keeping the in-memory entry/);
+        assert.match(output, /.*skip .*mod\.js because cache was the same/);
+        assert.match(output, /cache for .*import\.mjs was accepted, keeping the in-memory entry/);
+        assert.match(output, /.*skip .*import\.mjs because cache was the same/);
+        return true;
+      }
+    });
+}
diff --git a/test/js/node/test/parallel/test-compile-cache-esm.js b/test/js/node/test/parallel/test-compile-cache-esm.js
new file mode 100644
index 000000000000..963de8bcaba2
--- /dev/null
+++ b/test/js/node/test/parallel/test-compile-cache-esm.js
@@ -0,0 +1,53 @@
+'use strict';
+
+// This tests NODE_COMPILE_CACHE works in existing directory.
+
+require('../common');
+const { spawnSyncAndAssert } = require('../common/child_process');
+const assert = require('assert');
+const tmpdir = require('../common/tmpdir');
+const fixtures = require('../common/fixtures');
+
+{
+  tmpdir.refresh();
+  const dir = tmpdir.resolve('.compile_cache_dir');
+  const script = fixtures.path('es-modules', 'message.mjs');
+
+  spawnSyncAndAssert(
+    process.execPath,
+    [script],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_COMPILE_CACHE: dir
+      },
+      cwd: tmpdir.path
+    },
+    {
+      stderr(output) {
+        assert.match(output, /message\.mjs was not initialized, initializing the in-memory entry/);
+        assert.match(output, /writing cache for .*message\.mjs.*success/);
+        return true;
+      }
+    });
+
+  spawnSyncAndAssert(
+    process.execPath,
+    [script],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_COMPILE_CACHE: dir
+      },
+      cwd: tmpdir.path
+    },
+    {
+      stderr(output) {
+        assert.match(output, /cache for .*message\.mjs was accepted, keeping the in-memory entry/);
+        assert.match(output, /.*skip .*message\.mjs because cache was the same/);
+        return true;
+      }
+    });
+}
diff --git a/test/js/node/test/parallel/test-compile-cache-existing-directory.js b/test/js/node/test/parallel/test-compile-cache-existing-directory.js
new file mode 100644
index 000000000000..0fc60f9544d5
--- /dev/null
+++ b/test/js/node/test/parallel/test-compile-cache-existing-directory.js
@@ -0,0 +1,55 @@
+'use strict';
+
+// This tests NODE_COMPILE_CACHE works in existing directory.
+
+require('../common');
+const { spawnSyncAndAssert } = require('../common/child_process');
+const assert = require('assert');
+const fs = require('fs');
+const fixtures = require('../common/fixtures');
+const tmpdir = require('../common/tmpdir');
+
+{
+  tmpdir.refresh();
+  const dir = tmpdir.resolve('.compile_cache_dir');
+  fs.mkdirSync(dir);
+
+  spawnSyncAndAssert(
+    process.execPath,
+    [fixtures.path('empty.js')],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_COMPILE_CACHE: dir
+      },
+      cwd: tmpdir.path
+    },
+    {
+      stderr(output) {
+        assert.match(output, /empty\.js was not initialized, initializing the in-memory entry/);
+        assert.match(output, /writing cache for .*empty\.js.*success/);
+        return true;
+      }
+    });
+
+  // Second run reads the cache.
+  spawnSyncAndAssert(
+    process.execPath,
+    [fixtures.path('empty.js')],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_COMPILE_CACHE: dir
+      },
+      cwd: tmpdir.path
+    },
+    {
+      stderr(output) {
+        assert.match(output, /cache for .*empty\.js was accepted, keeping the in-memory entry/);
+        assert.match(output, /.*skip .*empty\.js because cache was the same/);
+        return true;
+      }
+    });
+}
diff --git a/test/js/node/test/parallel/test-compile-cache-portable-esm.js b/test/js/node/test/parallel/test-compile-cache-portable-esm.js
new file mode 100644
index 000000000000..18766b6810ea
--- /dev/null
+++ b/test/js/node/test/parallel/test-compile-cache-portable-esm.js
@@ -0,0 +1,84 @@
+'use strict';
+
+// This tests NODE_COMPILE_CACHE works after moving directory and unusual characters in path are handled correctly.
+
+require('../common');
+const { spawnSyncAndAssert } = require('../common/child_process');
+const assert = require('assert');
+const tmpdir = require('../common/tmpdir');
+const fs = require('fs');
+const path = require('path');
+
+tmpdir.refresh();
+
+const workDir = path.join(tmpdir.path, 'work');
+const cacheRel = '.compile_cache_dir';
+fs.mkdirSync(workDir, { recursive: true });
+
+const script = path.join(workDir, 'message.mjs');
+fs.writeFileSync(
+  script,
+  `
+  export const message = 'A message';
+  `
+);
+
+{
+  spawnSyncAndAssert(
+    process.execPath,
+    [script],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_COMPILE_CACHE: cacheRel,
+        NODE_COMPILE_CACHE_PORTABLE: '1',
+      },
+      cwd: workDir,
+    },
+    {
+      stderr(output) {
+        console.log(output);
+        assert.match(
+          output,
+          /message\.mjs was not initialized, initializing the in-memory entry/
+        );
+        assert.match(output, /writing cache for .*message\.mjs.*success/);
+        return true;
+      },
+    }
+  );
+
+  // Move the working directory and run again
+  const movedWorkDir = `${workDir}_moved`;
+  fs.renameSync(workDir, movedWorkDir);
+
+
+  spawnSyncAndAssert(
+    process.execPath,
+    [[path.join(movedWorkDir, 'message.mjs')]],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_COMPILE_CACHE: cacheRel,
+        NODE_COMPILE_CACHE_PORTABLE: '1',
+      },
+      cwd: movedWorkDir,
+    },
+    {
+      stderr(output) {
+        console.log(output);
+        assert.match(
+          output,
+          /cache for .*message\.mjs was accepted, keeping the in-memory entry/
+        );
+        assert.match(
+          output,
+          /.*skip .*message\.mjs because cache was the same/
+        );
+        return true;
+      },
+    }
+  );
+}
diff --git a/test/js/node/test/parallel/test-compile-cache-portable.js b/test/js/node/test/parallel/test-compile-cache-portable.js
new file mode 100644
index 000000000000..b5978b5b0c62
--- /dev/null
+++ b/test/js/node/test/parallel/test-compile-cache-portable.js
@@ -0,0 +1,75 @@
+'use strict';
+
+// This tests NODE_COMPILE_CACHE works with the NODE_COMPILE_CACHE_PORTABLE
+// environment variable.
+
+require('../common');
+const { spawnSyncAndAssert } = require('../common/child_process');
+const assert = require('assert');
+const fs = require('fs');
+const tmpdir = require('../common/tmpdir');
+const path = require('path');
+
+tmpdir.refresh();
+const workDir = path.join(tmpdir.path, 'work');
+const cacheRel = '.compile_cache_dir';
+fs.mkdirSync(workDir, { recursive: true });
+
+const script = path.join(workDir, 'script.js');
+fs.writeFileSync(script, '');
+
+// First run
+{
+  spawnSyncAndAssert(
+    process.execPath,
+    [script],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_COMPILE_CACHE: cacheRel,
+        NODE_COMPILE_CACHE_PORTABLE: '1',
+      },
+      cwd: workDir,
+    },
+    {
+      stderr(output) {
+        console.log(output);
+        assert.match(
+          output,
+          /script\.js was not initialized, initializing the in-memory entry/
+        );
+        assert.match(output, /writing cache for .*script\.js.*success/);
+        return true;
+      },
+    }
+  );
+
+  // Move the working directory and run again
+  const movedWorkDir = `${workDir}_moved`;
+  fs.renameSync(workDir, movedWorkDir);
+  spawnSyncAndAssert(
+    process.execPath,
+    [[path.join(movedWorkDir, 'script.js')]],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_COMPILE_CACHE: cacheRel,
+        NODE_COMPILE_CACHE_PORTABLE: '1',
+      },
+      cwd: movedWorkDir,
+    },
+    {
+      stderr(output) {
+        console.log(output);
+        assert.match(
+          output,
+          /cache for .*script\.js was accepted, keeping the in-memory entry/
+        );
+        assert.match(output, /.*skip .*script\.js because cache was the same/);
+        return true;
+      },
+    }
+  );
+}
diff --git a/test/js/node/test/parallel/test-compile-cache-success.js b/test/js/node/test/parallel/test-compile-cache-success.js
new file mode 100644
index 000000000000..c02a62432869
--- /dev/null
+++ b/test/js/node/test/parallel/test-compile-cache-success.js
@@ -0,0 +1,66 @@
+'use strict';
+
+// This tests NODE_COMPILE_CACHE works.
+
+require('../common');
+const { spawnSyncAndAssert } = require('../common/child_process');
+const assert = require('assert');
+const fixtures = require('../common/fixtures');
+const tmpdir = require('../common/tmpdir');
+const fs = require('fs');
+const path = require('path');
+
+{
+  // Test that it works with non-existent directory.
+  tmpdir.refresh();
+  const dir = tmpdir.resolve('.compile_cache_dir');
+
+  spawnSyncAndAssert(
+    process.execPath,
+    [fixtures.path('snapshot', 'typescript.js')],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_COMPILE_CACHE: dir
+      },
+      cwd: tmpdir.path
+    },
+    {
+      stderr(output) {
+        console.log(output);  // Logging for debugging.
+        assert.match(output, /typescript\.js was not initialized, initializing the in-memory entry/);
+        assert.match(output, /writing cache for .*typescript\.js.*success/);
+        return true;
+      }
+    });
+
+  const cacheDir = fs.readdirSync(dir);
+  assert.strictEqual(cacheDir.length, 1);
+  const entries = fs.readdirSync(path.join(dir, cacheDir[0]));
+  assert.strictEqual(entries.length, 1);
+  const cacheFile = path.join(dir, cacheDir[0], entries[0]);
+  const data = fs.readFileSync(cacheFile);
+  console.log(`Header in ${cacheFile}`, new Uint32Array(data.buffer, data.byteOffset, 4));
+
+  // Second run reads the cache, but no need to re-write because it didn't change.
+  spawnSyncAndAssert(
+    process.execPath,
+    [fixtures.path('snapshot', 'typescript.js')],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_COMPILE_CACHE: dir
+      },
+      cwd: tmpdir.path
+    },
+    {
+      stderr(output) {
+        console.log(output);  // Logging for debugging.
+        assert.match(output, /cache for .*typescript\.js was accepted, keeping the in-memory entry/);
+        assert.match(output, /.*skip .*typescript\.js because cache was the same/);
+        return true;
+      }
+    });
+}
diff --git a/test/js/node/test/parallel/test-compile-cache-updated-file.js b/test/js/node/test/parallel/test-compile-cache-updated-file.js
new file mode 100644
index 000000000000..68f20a6990cc
--- /dev/null
+++ b/test/js/node/test/parallel/test-compile-cache-updated-file.js
@@ -0,0 +1,78 @@
+'use strict';
+
+// This tests NODE_COMPILE_CACHE works in existing directory.
+
+require('../common');
+const { spawnSyncAndAssert } = require('../common/child_process');
+const assert = require('assert');
+const fs = require('fs');
+const tmpdir = require('../common/tmpdir');
+
+{
+  tmpdir.refresh();
+  const dir = tmpdir.resolve('.compile_cache_dir');
+  const script = tmpdir.resolve('script.js');
+  fs.writeFileSync(script, 'const foo = 1;', 'utf-8');
+
+  spawnSyncAndAssert(
+    process.execPath,
+    [script],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_COMPILE_CACHE: dir
+      },
+      cwd: tmpdir.path
+    },
+    {
+      stderr(output) {
+        assert.match(output, /script\.js was not initialized, initializing the in-memory entry/);
+        assert.match(output, /writing cache for .*script\.js.*success/);
+        return true;
+      }
+    });
+
+  // Update the content.
+  fs.writeFileSync(script, 'const foo = 2;', 'utf-8');
+
+  // Another run regenerates it.
+  spawnSyncAndAssert(
+    process.execPath,
+    [script],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_COMPILE_CACHE: dir
+      },
+      cwd: tmpdir.path
+    },
+    {
+      stderr(output) {
+        assert.match(output, /reading cache from .* for .*script\.js.*code hash mismatch:/);
+        assert.match(output, /writing cache for .*script\.js.*success/);
+        return true;
+      }
+    });
+
+  // Then it's consumed just fine.
+  spawnSyncAndAssert(
+    process.execPath,
+    [script],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_COMPILE_CACHE: dir
+      },
+      cwd: tmpdir.path
+    },
+    {
+      stderr(output) {
+        assert.match(output, /cache for .*script\.js was accepted, keeping the in-memory entry/);
+        assert.match(output, /.*skip .*script\.js because cache was the same/);
+        return true;
+      }
+    });
+}
diff --git a/test/js/node/test/parallel/test-console-formatTime.js b/test/js/node/test/parallel/test-console-formatTime.js
new file mode 100644
index 000000000000..6ce0b761c656
--- /dev/null
+++ b/test/js/node/test/parallel/test-console-formatTime.js
@@ -0,0 +1,14 @@
+'use strict';
+// Flags: --expose-internals
+require('../common');
+const { formatTime } = require('internal/util/debuglog');
+const assert = require('assert');
+
+assert.strictEqual(formatTime(100.0096), '100.01ms');
+assert.strictEqual(formatTime(100.0115), '100.011ms');
+assert.strictEqual(formatTime(1500.04), '1.500s');
+assert.strictEqual(formatTime(1000.056), '1.000s');
+assert.strictEqual(formatTime(60300.3), '1:00.300 (m:ss.mmm)');
+assert.strictEqual(formatTime(4000457.4), '1:06:40.457 (h:mm:ss.mmm)');
+assert.strictEqual(formatTime(3601310.4), '1:00:01.310 (h:mm:ss.mmm)');
+assert.strictEqual(formatTime(3213601017.6), '892:40:01.018 (h:mm:ss.mmm)');
diff --git a/test/js/node/test/parallel/test-constants.js b/test/js/node/test/parallel/test-constants.js
new file mode 100644
index 000000000000..51023b56d4dc
--- /dev/null
+++ b/test/js/node/test/parallel/test-constants.js
@@ -0,0 +1,30 @@
+// Flags: --expose-internals
+'use strict';
+
+require('../common');
+const { internalBinding } = require('internal/test/binding');
+const binding = internalBinding('constants');
+const constants = require('constants');
+const assert = require('assert');
+
+assert.ok(binding);
+assert.ok(binding.os);
+assert.ok(binding.os.signals);
+assert.ok(binding.os.errno);
+assert.ok(binding.fs);
+assert.ok(binding.crypto);
+
+['os', 'fs', 'crypto'].forEach((l) => {
+  for (const k of Object.keys(binding[l])) {
+    if (typeof binding[l][k] === 'object') { // errno and signals
+      for (const j of Object.keys(binding[l][k])) {
+        assert.strictEqual(binding[l][k][j], constants[j]);
+      }
+    }
+    if (l !== 'os') { // Top level os constant isn't currently copied
+      assert.strictEqual(binding[l][k], constants[k]);
+    }
+  }
+});
+
+assert.ok(Object.isFrozen(constants));
diff --git a/test/js/node/test/parallel/test-cppheap-stats.js b/test/js/node/test/parallel/test-cppheap-stats.js
new file mode 100644
index 000000000000..b77847602aa8
--- /dev/null
+++ b/test/js/node/test/parallel/test-cppheap-stats.js
@@ -0,0 +1,125 @@
+'use strict';
+// Tests that v8.getCppHeapStatistics() returns an object with an expected shape.
+
+require('../common');
+const assert = require('assert');
+const v8 = require('v8');
+
+// Detailed heap statistics
+const heapStatsDetailed = v8.getCppHeapStatistics('detailed');
+assert.strictEqual(heapStatsDetailed.detail_level, 'detailed');
+const expectedTopLevelKeys = [
+  'committed_size_bytes',
+  'resident_size_bytes',
+  'used_size_bytes',
+  'detail_level',
+  'space_statistics',
+  'type_names',
+].sort();
+
+// Check top level properties
+const actualTopLevelKeys = Object.keys(heapStatsDetailed).sort();
+assert.deepStrictEqual(actualTopLevelKeys, expectedTopLevelKeys);
+
+// Check types of top level properties
+assert.strictEqual(typeof heapStatsDetailed.committed_size_bytes, 'number');
+assert.strictEqual(typeof heapStatsDetailed.resident_size_bytes, 'number');
+assert.strictEqual(typeof heapStatsDetailed.used_size_bytes, 'number');
+assert.strictEqual(typeof heapStatsDetailed.detail_level, 'string');
+assert.strictEqual(Array.isArray(heapStatsDetailed.space_statistics), true);
+assert.strictEqual(Array.isArray(heapStatsDetailed.type_names), true);
+
+
+// Check space statistics array
+const expectedSpaceKeys = [
+  'name',
+  'committed_size_bytes',
+  'resident_size_bytes',
+  'used_size_bytes',
+  'page_stats',
+  'free_list_stats',
+].sort();
+
+for (const space of heapStatsDetailed.space_statistics) {
+  const actualSpaceKeys = Object.keys(space).sort();
+  assert.deepStrictEqual(actualSpaceKeys, expectedSpaceKeys);
+  assert.strictEqual(typeof space.name, 'string');
+  assert.strictEqual(typeof space.committed_size_bytes, 'number');
+  assert.strictEqual(typeof space.resident_size_bytes, 'number');
+  assert.strictEqual(typeof space.used_size_bytes, 'number');
+  assert.strictEqual(Array.isArray(space.page_stats), true);
+  assert.strictEqual(typeof space.free_list_stats, 'object');
+}
+
+// Check page statistics array
+const expectedPageKeys = [
+  'committed_size_bytes',
+  'resident_size_bytes',
+  'used_size_bytes',
+  'object_statistics',
+].sort();
+
+for (const space of heapStatsDetailed.space_statistics) {
+  for (const page of space.page_stats) {
+    const actualPageKeys = Object.keys(page).sort();
+    assert.deepStrictEqual(actualPageKeys, expectedPageKeys);
+    assert.strictEqual(typeof page.committed_size_bytes, 'number');
+    assert.strictEqual(typeof page.resident_size_bytes, 'number');
+    assert.strictEqual(typeof page.used_size_bytes, 'number');
+    assert.strictEqual(Array.isArray(page.object_statistics), true);
+  }
+}
+
+// Check free list statistics
+const expectedFreeListKeys = ['bucket_size', 'free_count', 'free_size'].sort();
+
+for (const space of heapStatsDetailed.space_statistics) {
+  const actualFreeListKeys = Object.keys(space.free_list_stats).sort();
+  assert.deepStrictEqual(actualFreeListKeys, expectedFreeListKeys);
+  assert.strictEqual(Array.isArray(space.free_list_stats.bucket_size), true);
+  assert.strictEqual(Array.isArray(space.free_list_stats.free_count), true);
+  assert.strictEqual(Array.isArray(space.free_list_stats.free_size), true);
+}
+
+// Check object statistics
+const expectedObjectStatsKeys = ['allocated_bytes', 'object_count'].sort();
+
+for (const space of heapStatsDetailed.space_statistics) {
+  for (const page of space.page_stats) {
+    for (const objectStats of page.object_statistics) {
+      const actualObjectStatsKeys = Object.keys(objectStats).sort();
+      assert.deepStrictEqual(actualObjectStatsKeys, expectedObjectStatsKeys);
+      assert.strictEqual(typeof objectStats.allocated_bytes, 'number');
+      assert.strictEqual(typeof objectStats.object_count, 'number');
+    }
+  }
+}
+
+// Check type names
+for (const typeName of heapStatsDetailed.type_names) {
+  assert.strictEqual(typeof typeName, 'string');
+}
+
+// Brief heap statistics
+const heapStatsBrief = v8.getCppHeapStatistics('brief');
+const expectedBriefKeys = [
+  'committed_size_bytes',
+  'resident_size_bytes',
+  'used_size_bytes',
+  'detail_level',
+  'space_statistics',
+  'type_names',
+].sort();
+
+// Check top level properties
+const actualBriefKeys = Object.keys(heapStatsBrief).sort();
+assert.strictEqual(heapStatsBrief.detail_level, 'brief');
+assert.deepStrictEqual(actualBriefKeys, expectedBriefKeys);
+
+// Check types of top level properties
+assert.strictEqual(typeof heapStatsBrief.committed_size_bytes, 'number');
+assert.strictEqual(typeof heapStatsBrief.resident_size_bytes, 'number');
+assert.strictEqual(typeof heapStatsBrief.used_size_bytes, 'number');
+assert.strictEqual(typeof heapStatsBrief.detail_level, 'string');
+assert.strictEqual(Array.isArray(heapStatsBrief.space_statistics), true);
+assert.strictEqual(Array.isArray(heapStatsBrief.type_names), true);
diff --git a/test/js/node/test/parallel/test-crypto-sec-level.js b/test/js/node/test/parallel/test-crypto-sec-level.js
new file mode 100644
index 000000000000..017db3e361e8
--- /dev/null
+++ b/test/js/node/test/parallel/test-crypto-sec-level.js
@@ -0,0 +1,18 @@
+// Flags: --expose-internals
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+
+// OpenSSL has a set of security levels which affect what algorithms
+// are available by default. Different OpenSSL veresions have different
+// default security levels and we use this value to adjust what a test
+// expects based on the security level. You can read more in
+// https://docs.openssl.org/1.1.1/man3/SSL_CTX_set_security_level/#default-callback-behaviour
+// This test simply validates that we can get some value for the secLevel
+// when needed by tests.
+const secLevel = require('internal/crypto/util').getOpenSSLSecLevel();
+assert.ok(secLevel >= 0 && secLevel <= 5);
diff --git a/test/js/node/test/parallel/test-cwd-enoent-improved-message.js b/test/js/node/test/parallel/test-cwd-enoent-improved-message.js
new file mode 100644
index 000000000000..e481627bbadf
--- /dev/null
+++ b/test/js/node/test/parallel/test-cwd-enoent-improved-message.js
@@ -0,0 +1,32 @@
+'use strict';
+
+const common = require('../common');
+const { isMainThread } = require('worker_threads');
+const assert = require('assert');
+const fs = require('fs');
+
+if (!isMainThread) {
+  common.skip('process.chdir is not available in Workers');
+}
+
+// Fails with EINVAL on SmartOS, EBUSY on Windows, EBUSY on AIX.
+if (common.isSunOS || common.isWindows || common.isAIX || common.isIBMi) {
+  common.skip('cannot rmdir current working directory');
+}
+
+const tmpdir = require('../common/tmpdir');
+const dirname = `${tmpdir.path}/cwd-does-not-exist-${process.pid}`;
+
+tmpdir.refresh();
+fs.mkdirSync(dirname);
+process.chdir(dirname);
+fs.rmdirSync(dirname);
+
+assert.throws(
+  () => process.cwd(),
+  {
+    code: 'ENOENT',
+    message: 'ENOENT: process.cwd failed with error no such file or directory,' +
+      ' the current working directory was likely removed without changing the working directory, uv_cwd',
+  }
+);
diff --git a/test/js/node/test/parallel/test-cwd-enoent-preload.js b/test/js/node/test/parallel/test-cwd-enoent-preload.js
new file mode 100644
index 000000000000..a7841e984d0e
--- /dev/null
+++ b/test/js/node/test/parallel/test-cwd-enoent-preload.js
@@ -0,0 +1,35 @@
+'use strict';
+const common = require('../common');
+// Fails with EINVAL on SmartOS, EBUSY on Windows, EBUSY on AIX.
+if (common.isSunOS || common.isWindows || common.isAIX || common.isIBMi) {
+  common.skip('cannot rmdir current working directory');
+}
+
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('process.chdir is not available in Workers');
+}
+
+const assert = require('assert');
+const fs = require('fs');
+const spawn = require('child_process').spawn;
+const fixtures = require('../common/fixtures');
+const tmpdir = require('../common/tmpdir');
+
+const dirname = `${tmpdir.path}/cwd-does-not-exist-${process.pid}`;
+const abspathFile = fixtures.path('a.js');
+tmpdir.refresh();
+fs.mkdirSync(dirname);
+process.chdir(dirname);
+fs.rmdirSync(dirname);
+
+
+const proc = spawn(process.execPath, ['-r', abspathFile, '-e', '0']);
+proc.stdout.pipe(process.stdout);
+proc.stderr.pipe(process.stderr);
+
+proc.once('exit', common.mustCall(function(exitCode, signalCode) {
+  assert.strictEqual(exitCode, 0);
+  assert.strictEqual(signalCode, null);
+}));
diff --git a/test/js/node/test/parallel/test-cwd-enoent-repl.js b/test/js/node/test/parallel/test-cwd-enoent-repl.js
new file mode 100644
index 000000000000..fcb08c004f34
--- /dev/null
+++ b/test/js/node/test/parallel/test-cwd-enoent-repl.js
@@ -0,0 +1,35 @@
+'use strict';
+const common = require('../common');
+// Fails with EINVAL on SmartOS, EBUSY on Windows, EBUSY on AIX.
+if (common.isSunOS || common.isWindows || common.isAIX || common.isIBMi) {
+  common.skip('cannot rmdir current working directory');
+}
+
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('process.chdir is not available in Workers');
+}
+
+const assert = require('assert');
+const fs = require('fs');
+const spawn = require('child_process').spawn;
+
+const tmpdir = require('../common/tmpdir');
+
+const dirname = `${tmpdir.path}/cwd-does-not-exist-${process.pid}`;
+tmpdir.refresh();
+fs.mkdirSync(dirname);
+process.chdir(dirname);
+fs.rmdirSync(dirname);
+
+const proc = spawn(process.execPath, ['--interactive']);
+proc.stdout.pipe(process.stdout);
+proc.stderr.pipe(process.stderr);
+proc.stdin.write('require("path");\n');
+proc.stdin.write('process.exit(42);\n');
+
+proc.once('exit', common.mustCall(function(exitCode, signalCode) {
+  assert.strictEqual(exitCode, 42);
+  assert.strictEqual(signalCode, null);
+}));
diff --git a/test/js/node/test/parallel/test-cwd-enoent.js b/test/js/node/test/parallel/test-cwd-enoent.js
new file mode 100644
index 000000000000..ca8b460835d4
--- /dev/null
+++ b/test/js/node/test/parallel/test-cwd-enoent.js
@@ -0,0 +1,33 @@
+'use strict';
+const common = require('../common');
+// Fails with EINVAL on SmartOS, EBUSY on Windows, EBUSY on AIX.
+if (common.isSunOS || common.isWindows || common.isAIX || common.isIBMi) {
+  common.skip('cannot rmdir current working directory');
+}
+
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('process.chdir is not available in Workers');
+}
+
+const assert = require('assert');
+const fs = require('fs');
+const spawn = require('child_process').spawn;
+
+const tmpdir = require('../common/tmpdir');
+
+const dirname = `${tmpdir.path}/cwd-does-not-exist-${process.pid}`;
+tmpdir.refresh();
+fs.mkdirSync(dirname);
+process.chdir(dirname);
+fs.rmdirSync(dirname);
+
+const proc = spawn(process.execPath, ['-e', '0']);
+proc.stdout.pipe(process.stdout);
+proc.stderr.pipe(process.stderr);
+
+proc.once('exit', common.mustCall(function(exitCode, signalCode) {
+  assert.strictEqual(exitCode, 0);
+  assert.strictEqual(signalCode, null);
+}));
diff --git a/test/js/node/test/parallel/test-disable-sigusr1.js b/test/js/node/test/parallel/test-disable-sigusr1.js
new file mode 100644
index 000000000000..e1d15a25ee65
--- /dev/null
+++ b/test/js/node/test/parallel/test-disable-sigusr1.js
@@ -0,0 +1,26 @@
+'use strict';
+
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+const { it } = require('node:test');
+const assert = require('node:assert');
+const { NodeInstance } = require('../common/inspector-helper.js');
+
+common.skipIfInspectorDisabled();
+
+it('should not attach a debugger with SIGUSR1', { skip: common.isWindows }, async () => {
+  const file = fixtures.path('disable-signal/sigusr1.js');
+  const instance = new NodeInstance(['--disable-sigusr1'], undefined, file);
+
+  instance.on('stderr', common.mustNotCall());
+  const loggedPid = await new Promise((resolve) => {
+    instance.on('stdout', (data) => {
+      const matches = data.match(/pid is (\d+)/);
+      if (matches) resolve(Number(matches[1]));
+    });
+  });
+
+  assert.ok(process.kill(instance.pid, 'SIGUSR1'));
+  assert.strictEqual(loggedPid, instance.pid);
+  assert.ok(await instance.kill());
+});
diff --git a/test/js/node/test/parallel/test-err-name-deprecation.js b/test/js/node/test/parallel/test-err-name-deprecation.js
new file mode 100644
index 000000000000..5f3fb28f1006
--- /dev/null
+++ b/test/js/node/test/parallel/test-err-name-deprecation.js
@@ -0,0 +1,16 @@
+'use strict';
+const common = require('../common');
+
+// Flags: --pending-deprecation
+
+common.expectWarning({
+  DeprecationWarning: [
+    ['process.binding() is deprecated. Please use public APIs instead.',
+     'DEP0111'],
+    ['Directly calling process.binding(\'uv\').errname(<val>) is being ' +
+     'deprecated. Please make sure to use util.getSystemErrorName() instead.',
+     'DEP0119'],
+  ]
+});
+
+process.binding('uv').errname(-1);
diff --git a/test/js/node/test/parallel/test-fs-util-validateoffsetlength.js b/test/js/node/test/parallel/test-fs-util-validateoffsetlength.js
new file mode 100644
index 000000000000..bda20f866837
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-util-validateoffsetlength.js
@@ -0,0 +1,87 @@
+// Flags: --expose-internals
+'use strict';
+
+const common = require('../common');
+
+const assert = require('assert');
+const {
+  validateOffsetLengthRead,
+  validateOffsetLengthWrite,
+} = require('internal/fs/utils');
+
+{
+  const offset = -1;
+  assert.throws(
+    () => validateOffsetLengthRead(offset, 0, 0),
+    common.expectsError({
+      code: 'ERR_OUT_OF_RANGE',
+      name: 'RangeError',
+      message: 'The value of "offset" is out of range. ' +
+                 `It must be >= 0. Received ${offset}`
+    })
+  );
+}
+
+{
+  const length = -1;
+  assert.throws(
+    () => validateOffsetLengthRead(0, length, 0),
+    common.expectsError({
+      code: 'ERR_OUT_OF_RANGE',
+      name: 'RangeError',
+      message: 'The value of "length" is out of range. ' +
+                 `It must be >= 0. Received ${length}`
+    })
+  );
+}
+
+{
+  const offset = 1;
+  const length = 1;
+  const byteLength = offset + length - 1;
+  assert.throws(
+    () => validateOffsetLengthRead(offset, length, byteLength),
+    common.expectsError({
+      code: 'ERR_OUT_OF_RANGE',
+      name: 'RangeError',
+      message: 'The value of "length" is out of range. ' +
+                 `It must be <= ${byteLength - offset}. Received ${length}`
+    })
+  );
+}
+
+// Most platforms don't allow reads or writes >= 2 GiB.
+// See https://github.com/libuv/libuv/pull/1501.
+const kIoMaxLength = 2 ** 31 - 1;
+
+// RangeError when offset > byteLength
+{
+  const offset = 100;
+  const length = 100;
+  const byteLength = 50;
+  assert.throws(
+    () => validateOffsetLengthWrite(offset, length, byteLength),
+    common.expectsError({
+      code: 'ERR_OUT_OF_RANGE',
+      name: 'RangeError',
+      message: 'The value of "offset" is out of range. ' +
+               `It must be <= ${byteLength}. Received ${offset}`
+    })
+  );
+}
+
+// RangeError when byteLength < kIoMaxLength, and length > byteLength - offset.
+{
+  const offset = kIoMaxLength - 150;
+  const length = 200;
+  const byteLength = kIoMaxLength - 100;
+  assert.throws(
+    () => validateOffsetLengthWrite(offset, length, byteLength),
+    common.expectsError({
+      code: 'ERR_OUT_OF_RANGE',
+      name: 'RangeError',
+      message: 'The value of "length" is out of range. ' +
+               `It must be <= ${byteLength - offset}. Received ${length}`
+    })
+  );
+}
diff --git a/test/js/node/test/parallel/test-fs-utils-get-dirents.js b/test/js/node/test/parallel/test-fs-utils-get-dirents.js
new file mode 100644
index 000000000000..55082ee698f3
--- /dev/null
+++ b/test/js/node/test/parallel/test-fs-utils-get-dirents.js
@@ -0,0 +1,138 @@
+// Flags: --expose-internals
+'use strict';
+
+const common = require('../common');
+const { getDirents, getDirent } = require('internal/fs/utils');
+const assert = require('assert');
+const { internalBinding } = require('internal/test/binding');
+const { UV_DIRENT_UNKNOWN } = internalBinding('constants').fs;
+const fs = require('fs');
+
+const tmpdir = require('../common/tmpdir');
+const filename = 'foo';
+
+{
+  // setup
+  tmpdir.refresh();
+  fs.writeFileSync(tmpdir.resolve(filename), '');
+}
+// getDirents
+{
+  // string + string
+  getDirents(
+    tmpdir.path,
+    [[filename], [UV_DIRENT_UNKNOWN]],
+    common.mustCall((err, names) => {
+      assert.strictEqual(err, null);
+      assert.strictEqual(names.length, 1);
+    },
+    ));
+}
+{
+  // string + Buffer
+  getDirents(
+    tmpdir.path,
+    [[Buffer.from(filename)], [UV_DIRENT_UNKNOWN]],
+    common.mustCall((err, names) => {
+      assert.strictEqual(err, null);
+      assert.strictEqual(names.length, 1);
+    },
+    ));
+}
+{
+  // Buffer + Buffer
+  getDirents(
+    Buffer.from(tmpdir.path),
+    [[Buffer.from(filename)], [UV_DIRENT_UNKNOWN]],
+    common.mustCall((err, names) => {
+      assert.strictEqual(err, null);
+      assert.strictEqual(names.length, 1);
+    },
+    ));
+}
+{
+  // wrong combination
+  getDirents(
+    42,
+    [[Buffer.from(filename)], [UV_DIRENT_UNKNOWN]],
+    common.mustCall((err) => {
+      assert.strictEqual(
+        err.message,
+        [
+          'The "path" argument must be of type string or an ' +
+          'instance of Buffer. Received type number (42)',
+        ].join(''));
+    },
+    ));
+}
+// getDirent
+{
+  // string + string
+  getDirent(
+    tmpdir.path,
+    filename,
+    UV_DIRENT_UNKNOWN,
+    common.mustCall((err, dirent) => {
+      assert.strictEqual(err, null);
+      assert.strictEqual(dirent.name, filename);
+      assert.strictEqual(dirent.parentPath, tmpdir.path);
+    },
+    ));
+}
+{
+  // Reassigning `.path` property should not trigger a warning
+  const dirent = getDirent(
+    tmpdir.path,
+    filename,
+    UV_DIRENT_UNKNOWN,
+  );
+  assert.strictEqual(dirent.name, filename);
+  dirent.path = 'some other value';
+  assert.strictEqual(dirent.parentPath, tmpdir.path);
+  assert.strictEqual(dirent.path, 'some other value');
+}
+{
+  // string + Buffer
+  const filenameBuffer = Buffer.from(filename);
+  getDirent(
+    tmpdir.path,
+    filenameBuffer,
+    UV_DIRENT_UNKNOWN,
+    common.mustCall((err, dirent) => {
+      assert.strictEqual(err, null);
+      assert.strictEqual(dirent.name, filenameBuffer);
+      assert.strictEqual(dirent.parentPath, tmpdir.path);
+    },
+    ));
+}
+{
+  // Buffer + Buffer
+  const filenameBuffer = Buffer.from(filename);
+  const dirnameBuffer = Buffer.from(tmpdir.path);
+  getDirent(
+    dirnameBuffer,
+    filenameBuffer,
+    UV_DIRENT_UNKNOWN,
+    common.mustCall((err, dirent) => {
+      assert.strictEqual(err, null);
+      assert.strictEqual(dirent.name, filenameBuffer);
+      assert.deepStrictEqual(dirent.parentPath, dirnameBuffer);
+    },
+    ));
+}
+{
+  // wrong combination
+  getDirent(
+    42,
+    Buffer.from(filename),
+    UV_DIRENT_UNKNOWN,
+    common.mustCall((err) => {
+      assert.strictEqual(
+        err.message,
+        [
+          'The "path" argument must be of type string or an ' +
+          'instance of Buffer. Received type number (42)',
+        ].join(''));
+    },
+    ));
+}
diff --git a/test/js/node/test/parallel/test-global-customevent.js b/test/js/node/test/parallel/test-global-customevent.js
new file mode 100644
index 000000000000..abce4ad90285
--- /dev/null
+++ b/test/js/node/test/parallel/test-global-customevent.js
@@ -0,0 +1,11 @@
+// Flags: --expose-internals
+'use strict';
+
+require('../common');
+const assert = require('node:assert');
+const { CustomEvent: internalCustomEvent } = require('internal/event_target');
+
+// Global
+assert.ok(CustomEvent);
+
+assert.strictEqual(CustomEvent, internalCustomEvent);
diff --git a/test/js/node/test/parallel/test-heap-prof-basic.js b/test/js/node/test/parallel/test-heap-prof-basic.js
new file mode 100644
index 000000000000..34d8af9a7840
--- /dev/null
+++ b/test/js/node/test/parallel/test-heap-prof-basic.js
@@ -0,0 +1,37 @@
+'use strict';
+
+// Tests --heap-prof without --heap-prof-interval. Here we just verify that
+// we manage to generate a profile.
+
+const common = require('../common');
+
+const fixtures = require('../common/fixtures');
+common.skipIfInspectorDisabled();
+
+const assert = require('assert');
+const { spawnSync } = require('child_process');
+
+const tmpdir = require('../common/tmpdir');
+
+const {
+  getHeapProfiles,
+  env
+} = require('../common/prof');
+
+{
+  tmpdir.refresh();
+  const output = spawnSync(process.execPath, [
+    '--heap-prof',
+    fixtures.path('workload', 'allocation.js'),
+  ], {
+    cwd: tmpdir.path,
+    env
+  });
+  if (output.status !== 0) {
+    console.log(output.stderr.toString());
+    console.log(output);
+  }
+  assert.strictEqual(output.status, 0);
+  const profiles = getHeapProfiles(tmpdir.path);
+  assert.strictEqual(profiles.length, 1);
+}
diff --git a/test/js/node/test/parallel/test-heap-prof-invalid-args.js b/test/js/node/test/parallel/test-heap-prof-invalid-args.js
new file mode 100644
index 000000000000..e35376038ecc
--- /dev/null
+++ b/test/js/node/test/parallel/test-heap-prof-invalid-args.js
@@ -0,0 +1,82 @@
+'use strict';
+
+// Tests invalid --heap-prof CLI arguments.
+
+const common = require('../common');
+
+const fixtures = require('../common/fixtures');
+common.skipIfInspectorDisabled();
+
+const assert = require('assert');
+const { spawnSync } = require('child_process');
+
+const tmpdir = require('../common/tmpdir');
+
+const {
+  kHeapProfInterval,
+  env
+} = require('../common/prof');
+
+// Tests --heap-prof-name without --heap-prof.
+{
+  tmpdir.refresh();
+  const output = spawnSync(process.execPath, [
+    '--heap-prof-name',
+    'test.heapprofile',
+    fixtures.path('workload', 'allocation.js'),
+  ], {
+    cwd: tmpdir.path,
+    env
+  });
+  const stderr = output.stderr.toString().trim();
+  if (output.status !== 9) {
+    console.log(stderr);
+  }
+  assert.strictEqual(output.status, 9);
+  assert.strictEqual(
+    stderr,
+    `${process.execPath}: --heap-prof-name must be used with --heap-prof`);
+}
+
+// Tests --heap-prof-dir without --heap-prof.
+{
+  tmpdir.refresh();
+  const output = spawnSync(process.execPath, [
+    '--heap-prof-dir',
+    'prof',
+    fixtures.path('workload', 'allocation.js'),
+  ], {
+    cwd: tmpdir.path,
+    env
+  });
+  const stderr = output.stderr.toString().trim();
+  if (output.status !== 9) {
+    console.log(stderr);
+  }
+  assert.strictEqual(output.status, 9);
+  assert.strictEqual(
+    stderr,
+    `${process.execPath}: --heap-prof-dir must be used with --heap-prof`);
+}
+
+// Tests --heap-prof-interval without --heap-prof.
+{
+  tmpdir.refresh();
+  const output = spawnSync(process.execPath, [
+    '--heap-prof-interval',
+    kHeapProfInterval,
+    fixtures.path('workload', 'allocation.js'),
+  ], {
+    cwd: tmpdir.path,
+    env
+  });
+  const stderr = output.stderr.toString().trim();
+  if (output.status !== 9) {
+    console.log(stderr);
+  }
+  assert.strictEqual(output.status, 9);
+  assert.strictEqual(
+    stderr,
+    `${process.execPath}: ` +
+    '--heap-prof-interval must be used with --heap-prof');
+}
diff --git a/test/js/node/test/parallel/test-icu-stringwidth.js b/test/js/node/test/parallel/test-icu-stringwidth.js
new file mode 100644
index 000000000000..40ef7a42cd05
--- /dev/null
+++ b/test/js/node/test/parallel/test-icu-stringwidth.js
@@ -0,0 +1,95 @@
+// Flags: --expose-internals
+'use strict';
+const common = require('../common');
+
+const assert = require('assert');
+const { getStringWidth } = require('internal/util/inspect');
+
+// Test column width
+
+// Ll (Lowercase Letter): LATIN SMALL LETTER A
+assert.strictEqual(getStringWidth('a'), 1);
+assert.strictEqual(getStringWidth(String.fromCharCode(0x0061)), 1);
+// Lo (Other Letter)
+assert.strictEqual(getStringWidth('丁'), 2);
+assert.strictEqual(getStringWidth(String.fromCharCode(0x4E01)), 2);
+// Surrogate pairs
+assert.strictEqual(getStringWidth('\ud83d\udc78\ud83c\udfff'), 4);
+assert.strictEqual(getStringWidth('👅'), 2);
+// Cs (Surrogate): High Surrogate
+assert.strictEqual(getStringWidth('\ud83d'), 1);
+// Cs (Surrogate): Low Surrogate
+assert.strictEqual(getStringWidth('\udc78'), 1);
+// Cc (Control): NULL
+assert.strictEqual(getStringWidth('\u0000'), 0);
+// Cc (Control): BELL
+assert.strictEqual(getStringWidth(String.fromCharCode(0x0007)), 0);
+// Cc (Control): LINE FEED
+assert.strictEqual(getStringWidth('\n'), 0);
+// Cf (Format): SOFT HYPHEN
+assert.strictEqual(getStringWidth(String.fromCharCode(0x00AD)), 1);
+// Cf (Format): LEFT-TO-RIGHT MARK
+// Cf (Format): RIGHT-TO-LEFT MARK
+assert.strictEqual(getStringWidth('\u200Ef\u200F'), 1);
+// Cn (Unassigned): Not a character
+assert.strictEqual(getStringWidth(String.fromCharCode(0x10FFEF)), 1);
+// Cn (Unassigned): Not a character (but in a CJK range)
+assert.strictEqual(getStringWidth(String.fromCharCode(0x3FFEF)), 1);
+// Mn (Nonspacing Mark): COMBINING ACUTE ACCENT
+assert.strictEqual(getStringWidth(String.fromCharCode(0x0301)), 0);
+// Mc (Spacing Mark): BALINESE ADEG ADEG
+// Chosen as its Canonical_Combining_Class is not 0, but is not a 0-width
+// character.
+assert.strictEqual(getStringWidth(String.fromCharCode(0x1B44)), 1);
+// Me (Enclosing Mark): COMBINING ENCLOSING CIRCLE
+assert.strictEqual(getStringWidth(String.fromCharCode(0x20DD)), 0);
+
+// The following is an emoji sequence with ZWJ (zero-width-joiner). In some
+// implementations, it is represented as a single glyph, in other
+// implementations as a sequence of individual glyphs. By default, each
+// component will be counted individually, since not a lot of systems support
+// these fully.
+// See https://www.unicode.org/reports/tr51/tr51-16.html#Emoji_ZWJ_Sequences
+assert.strictEqual(getStringWidth('👩‍👩‍👧‍👧'), 8);
+// Upstream note (BridgeAR): This should have a width of two and six. The heart contains
+// the \uFE0F variation selector that indicates that it should be displayed as
+// emoji instead of as text. Emojis are all full width characters when not being
+// rendered as text.
+// https://en.wikipedia.org/wiki/Variation_Selectors_(Unicode_block)
+assert.strictEqual(getStringWidth('❤️'), 1);
+assert.strictEqual(getStringWidth('👩‍❤️‍👩'), 5);
+// The length of one is correct. It is an emoji treated as text.
+assert.strictEqual(getStringWidth('❤'), 1);
+
+// By default, unicode characters whose width is considered ambiguous will
+// be considered half-width. For these characters, getStringWidth will return
+// 1. In some contexts, however, it is more appropriate to consider them full
+// width. By default, the algorithm will assume half width.
+assert.strictEqual(getStringWidth('\u01d4'), 1);
+
+// Control chars and combining chars are zero
+assert.strictEqual(getStringWidth('\u200E\n\u220A\u20D2'), 1);
+
+// Test that the fast path for ASCII characters yields results consistent
+// with the 'slow' path.
+for (let i = 0; i < 256; i++) {
+  const char = String.fromCharCode(i);
+  assert.strictEqual(
+    getStringWidth(char + '🎉'),
+    getStringWidth(char) + 2);
+
+  if (i < 32 || (i >= 127 && i < 160)) {  // Control character
+    assert.strictEqual(getStringWidth(char), 0);
+  } else {  // Regular ASCII character
+    assert.strictEqual(getStringWidth(char), 1);
+  }
+}
+
+if (common.hasIntl) {
+  const a = '한글'.normalize('NFD'); // 한글
+  const b = '한글'.normalize('NFC'); // 한글
+  assert.strictEqual(a.length, 6);
+  assert.strictEqual(b.length, 2);
+  assert.strictEqual(getStringWidth(a), 4);
+  assert.strictEqual(getStringWidth(b), 4);
+}
diff --git a/test/js/node/test/parallel/test-internal-fs.js b/test/js/node/test/parallel/test-internal-fs.js
new file mode 100644
index 000000000000..4204890cdf5d
--- /dev/null
+++ b/test/js/node/test/parallel/test-internal-fs.js
@@ -0,0 +1,53 @@
+// Flags: --expose-internals
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const fs = require('internal/fs/utils');
+
+// Valid encodings and no args should not throw.
+fs.assertEncoding();
+fs.assertEncoding('utf8');
+
+assert.throws(
+  () => fs.assertEncoding('foo'),
+  { code: 'ERR_INVALID_ARG_VALUE', name: 'TypeError' }
+);
+
+// Test junction symlinks
+{
+  const pathString = 'c:\\test1';
+  const linkPathString = '\\test2';
+
+  const preprocessSymlinkDestination = fs.preprocessSymlinkDestination(
+    pathString,
+    'junction',
+    linkPathString
+  );
+
+  if (process.platform === 'win32') {
+    assert.match(preprocessSymlinkDestination, /^\\\\\?\\/);
+  } else {
+    assert.strictEqual(preprocessSymlinkDestination, pathString);
+  }
+}
+
+// Test none junction symlinks
+{
+  const pathString = 'c:\\test1';
+  const linkPathString = '\\test2';
+
+  const preprocessSymlinkDestination = fs.preprocessSymlinkDestination(
+    pathString,
+    undefined,
+    linkPathString
+  );
+
+  if (process.platform === 'win32') {
+    // There should not be any forward slashes
+    assert.strictEqual(
+      /\//.test(preprocessSymlinkDestination), false);
+  } else {
+    assert.strictEqual(preprocessSymlinkDestination, pathString);
+  }
+}
diff --git a/test/js/node/test/parallel/test-internal-only-binding.js b/test/js/node/test/parallel/test-internal-only-binding.js
new file mode 100644
index 000000000000..87c1b05c8572
--- /dev/null
+++ b/test/js/node/test/parallel/test-internal-only-binding.js
@@ -0,0 +1,9 @@
+'use strict';
+// Flags: --expose-internals
+require('../common');
+const assert = require('assert');
+const { internalBinding } = require('internal/test/binding');
+
+assert.throws(() => internalBinding('internal_only_v8'), {
+  code: 'ERR_INVALID_MODULE'
+});
diff --git a/test/js/node/test/parallel/test-internal-socket-list-receive.js b/test/js/node/test/parallel/test-internal-socket-list-receive.js
new file mode 100644
index 000000000000..e7e64887600f
--- /dev/null
+++ b/test/js/node/test/parallel/test-internal-socket-list-receive.js
@@ -0,0 +1,68 @@
+// Flags: --expose-internals
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const EventEmitter = require('events');
+const SocketListReceive = require('internal/socket_list').SocketListReceive;
+
+const key = 'test-key';
+
+// Verify that the message won't be sent when child is not connected.
+{
+  const child = Object.assign(new EventEmitter(), {
+    connected: false,
+    _send: common.mustNotCall()
+  });
+
+  const list = new SocketListReceive(child, key);
+  list.child.emit('internalMessage', { key, cmd: 'NODE_SOCKET_NOTIFY_CLOSE' });
+  list.child.emit('internalMessage', { key, cmd: 'NODE_SOCKET_GET_COUNT' });
+}
+
+// Verify that a "NODE_SOCKET_ALL_CLOSED" message will be sent.
+{
+  const child = Object.assign(new EventEmitter(), {
+    connected: true,
+    _send: common.mustCall((msg) => {
+      assert.strictEqual(msg.cmd, 'NODE_SOCKET_ALL_CLOSED');
+      assert.strictEqual(msg.key, key);
+    })
+  });
+
+  const list = new SocketListReceive(child, key);
+  list.child.emit('internalMessage', { key, cmd: 'NODE_SOCKET_NOTIFY_CLOSE' });
+}
+
+// Verify that a "NODE_SOCKET_COUNT" message will be sent.
+{
+  const child = Object.assign(new EventEmitter(), {
+    connected: true,
+    _send: common.mustCall((msg) => {
+      assert.strictEqual(msg.cmd, 'NODE_SOCKET_COUNT');
+      assert.strictEqual(msg.key, key);
+      assert.strictEqual(msg.count, 0);
+    })
+  });
+
+  const list = new SocketListReceive(child, key);
+  list.child.emit('internalMessage', { key, cmd: 'NODE_SOCKET_GET_COUNT' });
+}
+
+// Verify that the connections count is added and an "empty" event
+// will be emitted when all sockets in obj were closed.
+{
+  const child = new EventEmitter();
+  const obj = { socket: new EventEmitter() };
+
+  const list = new SocketListReceive(child, key);
+  assert.strictEqual(list.connections, 0);
+
+  list.add(obj);
+  assert.strictEqual(list.connections, 1);
+
+  list.on('empty', common.mustCall((self) => assert.strictEqual(self, list)));
+
+  obj.socket.emit('close');
+  assert.strictEqual(list.connections, 0);
+}
diff --git a/test/js/node/test/parallel/test-internal-socket-list-send.js b/test/js/node/test/parallel/test-internal-socket-list-send.js
new file mode 100644
index 000000000000..41df85f50a9b
--- /dev/null
+++ b/test/js/node/test/parallel/test-internal-socket-list-send.js
@@ -0,0 +1,148 @@
+// Flags: --expose-internals
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const EventEmitter = require('events');
+const SocketListSend = require('internal/socket_list').SocketListSend;
+
+const key = 'test-key';
+
+// Verify that an error will be received in callback when child is not
+// connected.
+{
+  const child = Object.assign(new EventEmitter(), { connected: false });
+  assert.strictEqual(child.listenerCount('internalMessage'), 0);
+
+  const list = new SocketListSend(child, 'test');
+
+  list._request('msg', 'cmd', false, common.mustCall((err) => {
+    common.expectsError({
+      code: 'ERR_CHILD_CLOSED_BEFORE_REPLY',
+      name: 'Error',
+      message: 'Child closed before reply received'
+    })(err);
+    assert.strictEqual(child.listenerCount('internalMessage'), 0);
+  }));
+}
+
+// Verify that the given message will be received in callback.
+{
+  const child = Object.assign(new EventEmitter(), {
+    connected: true,
+    _send: function(msg) {
+      process.nextTick(() =>
+        this.emit('internalMessage', { key, cmd: 'cmd' })
+      );
+    }
+  });
+
+  const list = new SocketListSend(child, key);
+
+  list._request('msg', 'cmd', false, common.mustCall((err, msg) => {
+    assert.strictEqual(err, null);
+    assert.strictEqual(msg.cmd, 'cmd');
+    assert.strictEqual(msg.key, key);
+    assert.strictEqual(child.listenerCount('internalMessage'), 0);
+    assert.strictEqual(child.listenerCount('disconnect'), 0);
+  }));
+}
+
+// Verify that an error will be received in callback when child was
+// disconnected.
+{
+  const child = Object.assign(new EventEmitter(), {
+    connected: true,
+    _send: function(msg) { process.nextTick(() => this.emit('disconnect')); }
+  });
+
+  const list = new SocketListSend(child, key);
+
+  list._request('msg', 'cmd', false, common.mustCall((err) => {
+    common.expectsError({
+      code: 'ERR_CHILD_CLOSED_BEFORE_REPLY',
+      name: 'Error',
+      message: 'Child closed before reply received'
+    })(err);
+    assert.strictEqual(child.listenerCount('internalMessage'), 0);
+  }));
+}
+
+// Verify that a "NODE_SOCKET_ALL_CLOSED" message will be received
+// in callback.
+{
+  const child = Object.assign(new EventEmitter(), {
+    connected: true,
+    _send: common.mustCall(function(msg) {
+      assert.strictEqual(msg.cmd, 'NODE_SOCKET_NOTIFY_CLOSE');
+      assert.strictEqual(msg.key, key);
+      process.nextTick(() =>
+        this.emit('internalMessage', { key, cmd: 'NODE_SOCKET_ALL_CLOSED' })
+      );
+    })
+  });
+
+  const list = new SocketListSend(child, key);
+
+  list.close(common.mustCall((err, msg) => {
+    assert.strictEqual(err, null);
+    assert.strictEqual(msg.cmd, 'NODE_SOCKET_ALL_CLOSED');
+    assert.strictEqual(msg.key, key);
+    assert.strictEqual(child.listenerCount('internalMessage'), 0);
+    assert.strictEqual(child.listenerCount('disconnect'), 0);
+  }));
+}
+
+// Verify that the count of connections will be received in callback.
+{
+  const count = 1;
+  const child = Object.assign(new EventEmitter(), {
+    connected: true,
+    _send: common.mustCall(function(msg) {
+      assert.strictEqual(msg.cmd, 'NODE_SOCKET_GET_COUNT');
+      assert.strictEqual(msg.key, key);
+      process.nextTick(() =>
+        this.emit('internalMessage', {
+          key,
+          count,
+          cmd: 'NODE_SOCKET_COUNT'
+        })
+      );
+    })
+  });
+
+  const list = new SocketListSend(child, key);
+
+  list.getConnections(common.mustCall((err, msg) => {
+    assert.strictEqual(err, null);
+    assert.strictEqual(msg, count);
+    assert.strictEqual(child.listenerCount('internalMessage'), 0);
+    assert.strictEqual(child.listenerCount('disconnect'), 0);
+  }));
+}
+
+// Verify that an error will be received in callback when child is
+// disconnected after sending a message and before getting the reply.
+{
+  const count = 1;
+  const child = Object.assign(new EventEmitter(), {
+    connected: true,
+    _send: function() {
+      process.nextTick(() => {
+        this.emit('disconnect');
+        this.emit('internalMessage', { key, count, cmd: 'NODE_SOCKET_COUNT' });
+      });
+    }
+  });
+
+  const list = new SocketListSend(child, key);
+
+  list.getConnections(common.mustCall((err) => {
+    common.expectsError({
+      code: 'ERR_CHILD_CLOSED_BEFORE_REPLY',
+      name: 'Error',
+      message: 'Child closed before reply received'
+    })(err);
+    assert.strictEqual(child.listenerCount('internalMessage'), 0);
+  }));
+}
diff --git a/test/js/node/test/parallel/test-internal-util-assertCrypto.js b/test/js/node/test/parallel/test-internal-util-assertCrypto.js
new file mode 100644
index 000000000000..a6a1610d456a
--- /dev/null
+++ b/test/js/node/test/parallel/test-internal-util-assertCrypto.js
@@ -0,0 +1,15 @@
+// Flags: --expose-internals
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const util = require('internal/util');
+
+if (!process.versions.openssl) {
+  const expectedError = common.expectsError({
+    code: 'ERR_NO_CRYPTO',
+    name: 'Error'
+  });
+  assert.throws(() => util.assertCrypto(), expectedError);
+} else {
+  util.assertCrypto();
+}
diff --git a/test/js/node/test/parallel/test-internal-util-getCIDR.js b/test/js/node/test/parallel/test-internal-util-getCIDR.js
new file mode 100644
index 000000000000..f7dd3c1194b6
--- /dev/null
+++ b/test/js/node/test/parallel/test-internal-util-getCIDR.js
@@ -0,0 +1,23 @@
+// Flags: --expose-internals
+'use strict';
+require('../common');
+
+// These are tests that verify that the subnetmask is used
+// to create the correct CIDR address.
+// Tests that it returns null if the subnetmask is not in the correct format.
+// (ref: https://www.rfc-editor.org/rfc/rfc1878)
+
+const assert = require('node:assert');
+const { getCIDR } = require('internal/util');
+
+assert.strictEqual(getCIDR('127.0.0.1', '255.0.0.0', 'IPv4'), '127.0.0.1/8');
+assert.strictEqual(getCIDR('127.0.0.1', '255.255.0.0', 'IPv4'), '127.0.0.1/16');
+
+// 242 = 11110010(2)
+assert.strictEqual(getCIDR('127.0.0.1', '242.0.0.0', 'IPv4'), null);
+
+assert.strictEqual(getCIDR('::1', 'ffff:ffff:ffff:ffff::', 'IPv6'), '::1/64');
+assert.strictEqual(getCIDR('::1', 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff', 'IPv6'), '::1/128');
+
+// ff00:ffff = 11111111 00000000 : 11111111 11111111(2)
+assert.strictEqual(getCIDR('::1', 'ffff:ff00:ffff::', 'IPv6'), null);
diff --git a/test/js/node/test/parallel/test-internal-util-helpers.js b/test/js/node/test/parallel/test-internal-util-helpers.js
new file mode 100644
index 000000000000..01e99d52420d
--- /dev/null
+++ b/test/js/node/test/parallel/test-internal-util-helpers.js
@@ -0,0 +1,64 @@
+// Flags: --expose-internals
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const { types } = require('util');
+const { assignFunctionName, isError } = require('internal/util');
+const vm = require('vm');
+
+// Special cased errors. Test the internal function which is used in
+// `util.inspect()`, the `repl` and maybe more. This verifies that errors from
+// different realms, and non native instances of error are properly detected as
+// error while definitely false ones are not detected. This is different than
+// the public `util.isError()` function which falsy detects the fake errors as
+// actual errors.
+{
+  const fake = { [Symbol.toStringTag]: 'Error' };
+  assert(!types.isNativeError(fake));
+  assert(!(fake instanceof Error));
+  assert(!isError(fake));
+
+  const err = new Error('test');
+  const newErr = Object.create(
+    Object.getPrototypeOf(err),
+    Object.getOwnPropertyDescriptors(err));
+  Object.defineProperty(err, 'message', { value: err.message });
+  assert(types.isNativeError(err));
+  assert(!types.isNativeError(newErr));
+  assert(newErr instanceof Error);
+  assert(isError(newErr));
+
+  const context = vm.createContext({});
+  const differentRealmErr = vm.runInContext('new Error()', context);
+  assert(types.isNativeError(differentRealmErr));
+  assert(!(differentRealmErr instanceof Error));
+  assert(isError(differentRealmErr));
+}
+
+{
+  const nameMap = new Map([
+    [ 'meaningfulName', 'meaningfulName' ],
+    [ '', '' ],
+    [ Symbol.asyncIterator, '[Symbol.asyncIterator]' ],
+    [ Symbol('notWellKnownSymbol'), '[notWellKnownSymbol]' ],
+  ]);
+  for (const fn of [
+    () => {},
+    function() {},
+    function value() {},
+    ({ value() {} }).value,
+    new Function(),
+    Function(),
+    function() {}.bind(null),
+    class {},
+    class value {},
+  ]) {
+    for (const [ stringOrSymbol, expectedName ] of nameMap) {
+      const namedFn = assignFunctionName(stringOrSymbol, fn);
+      assert.strictEqual(fn, namedFn);
+      assert.strictEqual(namedFn.name, expectedName);
+      assert.strictEqual(namedFn.bind(null).name, `bound ${expectedName}`);
+    }
+  }
+}
diff --git a/test/js/node/test/parallel/test-internal-util-isinsidenodemodules.js b/test/js/node/test/parallel/test-internal-util-isinsidenodemodules.js
new file mode 100644
index 000000000000..d9eecd5e4bcf
--- /dev/null
+++ b/test/js/node/test/parallel/test-internal-util-isinsidenodemodules.js
@@ -0,0 +1,36 @@
+'use strict';
+
+// Flags: --expose-internals
+
+const common = require('../common');
+const assert = require('assert');
+const vm = require('vm');
+
+const { internalBinding } = require('internal/test/binding');
+const { isInsideNodeModules } = internalBinding('util');
+
+const script = new vm.Script(`
+  const runInsideNodeModules = (cb) => {
+    return cb();
+  };
+
+  runInsideNodeModules;
+`, {
+  filename: '/workspace/node_modules/test.js',
+});
+const runInsideNodeModules = script.runInThisContext();
+
+// Test when called directly inside node_modules
+assert.strictEqual(runInsideNodeModules(isInsideNodeModules), true);
+
+// Test when called inside a user callback from node_modules
+runInsideNodeModules(common.mustCall(() => {
+  function nonNodeModulesFunction() {
+    assert.strictEqual(isInsideNodeModules(), false);
+  }
+
+  nonNodeModulesFunction();
+}));
+
+// Test when called outside node_modules
+assert.strictEqual(isInsideNodeModules(), false);
diff --git a/test/js/node/test/parallel/test-internal-util-normalizeencoding.js b/test/js/node/test/parallel/test-internal-util-normalizeencoding.js
new file mode 100644
index 000000000000..167880d661ff
--- /dev/null
+++ b/test/js/node/test/parallel/test-internal-util-normalizeencoding.js
@@ -0,0 +1,55 @@
+// Flags: --expose-internals
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const util = require('internal/util');
+
+const tests = [
+  [undefined, 'utf8'],
+  [null, 'utf8'],
+  ['', 'utf8'],
+  ['utf8', 'utf8'],
+  ['utf-8', 'utf8'],
+  ['UTF-8', 'utf8'],
+  ['UTF8', 'utf8'],
+  ['Utf8', 'utf8'],
+  ['uTf-8', 'utf8'],
+  ['utF-8', 'utf8'],
+  ['ucs2', 'utf16le'],
+  ['UCS2', 'utf16le'],
+  ['UcS2', 'utf16le'],
+  ['ucs-2', 'utf16le'],
+  ['UCS-2', 'utf16le'],
+  ['UcS-2', 'utf16le'],
+  ['utf16le', 'utf16le'],
+  ['utf-16le', 'utf16le'],
+  ['UTF-16LE', 'utf16le'],
+  ['UTF16LE', 'utf16le'],
+  ['binary', 'latin1'],
+  ['BINARY', 'latin1'],
+  ['latin1', 'latin1'],
+  ['LaTiN1', 'latin1'],
+  ['base64', 'base64'],
+  ['BASE64', 'base64'],
+  ['Base64', 'base64'],
+  ['base64url', 'base64url'],
+  ['BASE64url', 'base64url'],
+  ['Base64url', 'base64url'],
+  ['hex', 'hex'],
+  ['HEX', 'hex'],
+  ['ASCII', 'ascii'],
+  ['AsCii', 'ascii'],
+  ['foo', undefined],
+  [1, undefined],
+  [false, undefined],
+  [NaN, undefined],
+  [0, undefined],
+  [[], undefined],
+  [{}, undefined],
+];
+
+tests.forEach((e, i) => {
+  const res = util.normalizeEncoding(e[0]);
+  assert.strictEqual(res, e[1], `#${i} failed: expected ${e[1]}, got ${res}`);
+});
diff --git a/test/js/node/test/parallel/test-internal-util-objects.js b/test/js/node/test/parallel/test-internal-util-objects.js
new file mode 100644
index 000000000000..74068e4c577b
--- /dev/null
+++ b/test/js/node/test/parallel/test-internal-util-objects.js
@@ -0,0 +1,119 @@
+// Flags: --expose-internals
+'use strict';
+require('../common');
+
+// Test helper objects from internal/util
+
+const assert = require('assert');
+const {
+  kEnumerableProperty,
+  kEmptyObject,
+} = require('internal/util');
+
+Object.prototype.blep = 'blop';
+
+{
+  assert.strictEqual(
+    kEnumerableProperty.blep,
+    undefined
+  );
+  assert.strictEqual(
+    kEnumerableProperty.enumerable,
+    true
+  );
+  assert.strictEqual(
+    Object.getPrototypeOf(kEnumerableProperty),
+    null
+  );
+  assert.deepStrictEqual(
+    Object.getOwnPropertyNames(kEnumerableProperty),
+    [ 'enumerable' ]
+  );
+
+  assert.throws(
+    () => Object.setPrototypeOf(kEnumerableProperty, { value: undefined }),
+    TypeError
+  );
+  assert.throws(
+    () => delete kEnumerableProperty.enumerable,
+    TypeError
+  );
+  assert.throws(
+    () => kEnumerableProperty.enumerable = false,
+    TypeError
+  );
+  assert.throws(
+    () => Object.assign(kEnumerableProperty, { enumerable: false }),
+    TypeError
+  );
+  assert.throws(
+    () => kEnumerableProperty.value = undefined,
+    TypeError
+  );
+  assert.throws(
+    () => Object.assign(kEnumerableProperty, { value: undefined }),
+    TypeError
+  );
+  assert.throws(
+    () => Object.defineProperty(kEnumerableProperty, 'value', {}),
+    TypeError
+  );
+}
+
+{
+  assert.strictEqual(
+    kEmptyObject.blep,
+    undefined
+  );
+  assert.strictEqual(
+    kEmptyObject.prototype,
+    undefined
+  );
+  assert.strictEqual(
+    Object.getPrototypeOf(kEmptyObject),
+    null
+  );
+  assert.strictEqual(
+    kEmptyObject instanceof Object,
+    false
+  );
+  assert.deepStrictEqual(
+    Object.getOwnPropertyDescriptors(kEmptyObject),
+    {}
+  );
+  assert.deepStrictEqual(
+    Object.getOwnPropertyNames(kEmptyObject),
+    []
+  );
+  assert.deepStrictEqual(
+    Object.getOwnPropertySymbols(kEmptyObject),
+    []
+  );
+  assert.strictEqual(
+    Object.isExtensible(kEmptyObject),
+    false
+  );
+  assert.strictEqual(
+    Object.isSealed(kEmptyObject),
+    true
+  );
+  assert.strictEqual(
+    Object.isFrozen(kEmptyObject),
+    true
+  );
+
+  assert.throws(
+    () => kEmptyObject.foo = 'bar',
+    TypeError
+  );
+  assert.throws(
+    () => Object.assign(kEmptyObject, { foo: 'bar' }),
+    TypeError
+  );
+  assert.throws(
+    () => Object.defineProperty(kEmptyObject, 'foo', {}),
+    TypeError
+  );
+}
+
+delete Object.prototype.blep;
diff --git a/test/js/node/test/parallel/test-internal-util-weakreference.js b/test/js/node/test/parallel/test-internal-util-weakreference.js
new file mode 100644
index 000000000000..0ecef956a44a
--- /dev/null
+++ b/test/js/node/test/parallel/test-internal-util-weakreference.js
@@ -0,0 +1,19 @@
+// Flags: --expose-internals --expose-gc
+'use strict';
+require('../common');
+const { gcUntil } = require('../common/gc');
+const assert = require('assert');
+const { WeakReference } = require('internal/util');
+
+let obj = { hello: 'world' };
+const ref = new WeakReference(obj);
+assert.strictEqual(ref.get(), obj);
+
+async function main() {
+  obj = null;
+  await gcUntil(
+    'Reference is garbage collected',
+    () => ref.get() === undefined);
+}
+
+main();
diff --git a/test/js/node/test/parallel/test-internal-webidl-buffer-source.js b/test/js/node/test/parallel/test-internal-webidl-buffer-source.js
new file mode 100644
index 000000000000..9e522d7d7b8a
--- /dev/null
+++ b/test/js/node/test/parallel/test-internal-webidl-buffer-source.js
@@ -0,0 +1,298 @@
+// Flags: --expose-internals
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const { test } = require('node:test');
+const vm = require('vm');
+
+const { converters } = require('internal/webidl');
+
+const TYPED_ARRAY_CTORS = [
+  Uint8Array, Int8Array, Uint8ClampedArray,
+  Uint16Array, Int16Array,
+  Uint32Array, Int32Array,
+  Float16Array, Float32Array, Float64Array,
+  BigInt64Array, BigUint64Array,
+];
+
+function createGrowableSharedArrayBufferView(Ctor) {
+  const buffer = createGrowableSharedArrayBuffer();
+  const view = new Ctor(buffer);
+  return view;
+}
+
+function createGrowableSharedArrayBuffer() {
+  const buffer = new SharedArrayBuffer(0, { maxByteLength: 1 });
+  assert.strictEqual(buffer.growable, true);
+  return buffer;
+}
+
+test('BufferSource accepts ArrayBuffer', () => {
+  const ab = new ArrayBuffer(8);
+  assert.strictEqual(converters.BufferSource(ab), ab);
+});
+
+test('BufferSource accepts all TypedArray kinds', () => {
+  for (const Ctor of TYPED_ARRAY_CTORS) {
+    const ta = new Ctor(4);
+    assert.strictEqual(converters.BufferSource(ta), ta);
+  }
+});
+
+test('BufferSource accepts Buffer', () => {
+  const buf = Buffer.alloc(8);
+  assert.strictEqual(converters.BufferSource(buf), buf);
+});
+
+test('BufferSource accepts DataView', () => {
+  const dv = new DataView(new ArrayBuffer(8));
+  assert.strictEqual(converters.BufferSource(dv), dv);
+});
+
+test('BufferSource accepts cross-realm buffer sources', () => {
+  const context = vm.createContext();
+
+  {
+    const ab = vm.runInContext('new ArrayBuffer(0)', context);
+    assert.strictEqual(converters.BufferSource(ab), ab);
+  }
+
+  {
+    const dv = vm.runInContext('new DataView(new ArrayBuffer(0))', context);
+    assert.strictEqual(converters.BufferSource(dv), dv);
+  }
+
+  for (const Ctor of TYPED_ARRAY_CTORS) {
+    const ta = vm.runInContext(
+      `new ${Ctor.name}(new ArrayBuffer(0))`,
+      context,
+    );
+    assert.strictEqual(converters.BufferSource(ta), ta);
+  }
+});
+
+test('BufferSource accepts ArrayBuffer subclass instance', () => {
+  class MyAB extends ArrayBuffer {}
+  const sub = new MyAB(8);
+  assert.strictEqual(converters.BufferSource(sub), sub);
+});
+
+test('BufferSource accepts TypedArray with null prototype', () => {
+  const ta = new Uint8Array(4);
+  Object.setPrototypeOf(ta, null);
+  assert.strictEqual(converters.BufferSource(ta), ta);
+});
+
+test('BufferSource accepts DataView with null prototype', () => {
+  const dv = new DataView(new ArrayBuffer(4));
+  Object.setPrototypeOf(dv, null);
+  assert.strictEqual(converters.BufferSource(dv), dv);
+});
+
+test('BufferSource accepts ArrayBuffer with null prototype', () => {
+  const ab = new ArrayBuffer(4);
+  Object.setPrototypeOf(ab, null);
+  assert.strictEqual(converters.BufferSource(ab), ab);
+});
+
+test('BufferSource rejects SharedArrayBuffer', () => {
+  assert.throws(
+    () => converters.BufferSource(new SharedArrayBuffer(4)),
+    { code: 'ERR_INVALID_ARG_TYPE' },
+  );
+});
+
+test('BufferSource rejects SAB-backed TypedArray', () => {
+  const view = new Uint8Array(new SharedArrayBuffer(4));
+  assert.throws(
+    () => converters.BufferSource(view),
+    { code: 'ERR_INVALID_ARG_TYPE' },
+  );
+  assert.throws(
+    () => converters.BufferSource(view, { allowShared: true }),
+    { code: 'ERR_INVALID_ARG_TYPE' },
+  );
+});
+
+test('BufferSource rejects SAB-backed DataView', () => {
+  const dv = new DataView(new SharedArrayBuffer(4));
+  assert.throws(
+    () => converters.BufferSource(dv),
+    { code: 'ERR_INVALID_ARG_TYPE' },
+  );
+  assert.throws(
+    () => converters.BufferSource(dv, { allowShared: true }),
+    { code: 'ERR_INVALID_ARG_TYPE' },
+  );
+});
+
+test('BufferSource rejects SAB view whose buffer prototype was reassigned', () => {
+  const sab = new SharedArrayBuffer(4);
+  Object.setPrototypeOf(sab, ArrayBuffer.prototype);
+  const view = new Uint8Array(sab);
+  assert.throws(
+    () => converters.BufferSource(view),
+    { code: 'ERR_INVALID_ARG_TYPE' },
+  );
+});
+
+test('BufferSource accepts a detached ArrayBuffer', () => {
+  const ab = new ArrayBuffer(8);
+  structuredClone(ab, { transfer: [ab] });
+  assert.strictEqual(ab.byteLength, 0);
+  assert.strictEqual(converters.BufferSource(ab), ab);
+});
+
+test('BufferSource rejects resizable ArrayBuffer by default', () => {
+  const ab = new ArrayBuffer(0, { maxByteLength: 1 });
+  assert.throws(
+    () => converters.BufferSource(ab),
+    { code: 'ERR_INVALID_ARG_TYPE' },
+  );
+});
+
+test('BufferSource handles resizable-backed views with explicit options', () => {
+  for (const Ctor of [DataView, ...TYPED_ARRAY_CTORS]) {
+    {
+      const view = new Ctor(new ArrayBuffer(0, { maxByteLength: 1 }));
+      assert.throws(
+        () => converters.BufferSource(view),
+        { code: 'ERR_INVALID_ARG_TYPE' },
+      );
+    }
+
+    {
+      const view = new Ctor(new ArrayBuffer(0, { maxByteLength: 1 }));
+      assert.throws(
+        () => converters.BufferSource(view, { allowResizable: false }),
+        { code: 'ERR_INVALID_ARG_TYPE' },
+      );
+    }
+
+    {
+      const view = new Ctor(new ArrayBuffer(0, { maxByteLength: 1 }));
+      assert.strictEqual(converters.BufferSource(view, {
+        allowResizable: true,
+      }), view);
+    }
+  }
+});
+
+test('BufferSource rejects SAB-backed views with explicit options', () => {
+  for (const Ctor of [DataView, ...TYPED_ARRAY_CTORS]) {
+    const view = createGrowableSharedArrayBufferView(Ctor);
+    assert.throws(
+      () => converters.BufferSource(view, {
+        allowShared: true,
+        allowResizable: true,
+      }),
+      { code: 'ERR_INVALID_ARG_TYPE' },
+    );
+  }
+});
+
+test('AllowSharedBufferSource accepts ArrayBuffer and SharedArrayBuffer', () => {
+  const ab = new ArrayBuffer(8);
+  const sab = new SharedArrayBuffer(8);
+
+  assert.strictEqual(converters.AllowSharedBufferSource(ab), ab);
+  assert.strictEqual(converters.AllowSharedBufferSource(sab), sab);
+});
+
+test('AllowSharedBufferSource accepts cross-realm buffers', () => {
+  const context = vm.createContext();
+  const ab = vm.runInContext('new ArrayBuffer(0)', context);
+  const sab = vm.runInContext('new SharedArrayBuffer(0)', context);
+
+  assert.strictEqual(converters.AllowSharedBufferSource(ab), ab);
+  assert.strictEqual(converters.AllowSharedBufferSource(sab), sab);
+});
+
+test('AllowSharedBufferSource accepts ArrayBuffer and SharedArrayBuffer views', () => {
+  const abView = new Uint8Array(new ArrayBuffer(8));
+  const sabView = new Uint8Array(new SharedArrayBuffer(8));
+  const abDataView = new DataView(new ArrayBuffer(8));
+  const sabDataView = new DataView(new SharedArrayBuffer(8));
+
+  assert.strictEqual(converters.AllowSharedBufferSource(abView), abView);
+  assert.strictEqual(converters.AllowSharedBufferSource(sabView), sabView);
+  assert.strictEqual(
+    converters.AllowSharedBufferSource(abDataView), abDataView);
+  assert.strictEqual(
+    converters.AllowSharedBufferSource(sabDataView), sabDataView);
+});
+
+test('AllowSharedBufferSource handles resizable buffers with explicit options', () => {
+  const ab = new ArrayBuffer(0, { maxByteLength: 1 });
+  const views = [new Uint8Array(ab), new DataView(ab)];
+
+  assert.throws(
+    () => converters.AllowSharedBufferSource(ab),
+    { code: 'ERR_INVALID_ARG_TYPE' },
+  );
+  for (const view of views) {
+    assert.throws(
+      () => converters.AllowSharedBufferSource(view),
+      { code: 'ERR_INVALID_ARG_TYPE' },
+    );
+  }
+  assert.strictEqual(converters.AllowSharedBufferSource(ab, {
+    allowResizable: true,
+  }), ab);
+  for (const view of views) {
+    assert.strictEqual(converters.AllowSharedBufferSource(view, {
+      allowResizable: true,
+    }), view);
+  }
+});
+
+test('AllowSharedBufferSource handles growable shared buffers with explicit ' +
+     'options', () => {
+  const sab = createGrowableSharedArrayBuffer();
+  const views = [new Uint8Array(sab), new DataView(sab)];
+
+  assert.throws(
+    () => converters.AllowSharedBufferSource(sab),
+    { code: 'ERR_INVALID_ARG_TYPE' },
+  );
+  for (const view of views) {
+    assert.throws(
+      () => converters.AllowSharedBufferSource(view),
+      { code: 'ERR_INVALID_ARG_TYPE' },
+    );
+  }
+  assert.strictEqual(converters.AllowSharedBufferSource(sab, {
+    allowResizable: true,
+  }), sab);
+  for (const view of views) {
+    assert.strictEqual(converters.AllowSharedBufferSource(view, {
+      allowResizable: true,
+    }), view);
+  }
+});
+
+test('BufferSource rejects objects with a forged @@toStringTag', () => {
+  const fake = { [Symbol.toStringTag]: 'Uint8Array' };
+  assert.throws(
+    () => converters.BufferSource(fake),
+    { code: 'ERR_INVALID_ARG_TYPE' },
+  );
+});
+
+for (const value of [null, undefined, 0, 1, 1n, '', 'x', true, Symbol('s'), [],
+                     {}, () => {}]) {
+  test(`BufferSource rejects ${typeof value} ${String(value)}`, () => {
+    assert.throws(
+      () => converters.BufferSource(value),
+      { code: 'ERR_INVALID_ARG_TYPE' },
+    );
+  });
+
+  test(`AllowSharedBufferSource rejects ${typeof value} ${String(value)}`, () => {
+    assert.throws(
+      () => converters.AllowSharedBufferSource(value),
+      { code: 'ERR_INVALID_ARG_TYPE' },
+    );
+  });
+}
diff --git a/test/js/node/test/parallel/test-internal-webidl-converttoint.js b/test/js/node/test/parallel/test-internal-webidl-converttoint.js
new file mode 100644
index 000000000000..4c2032dc8354
--- /dev/null
+++ b/test/js/node/test/parallel/test-internal-webidl-converttoint.js
@@ -0,0 +1,362 @@
+// Flags: --expose-internals
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const { convertToInt } = require('internal/webidl');
+
+function assertPlainTypeError(fn) {
+  assert.throws(fn, (err) => {
+    assert(err instanceof TypeError);
+    assert.strictEqual(err.name, 'TypeError');
+    assert.strictEqual(err.code, undefined);
+    return true;
+  });
+}
+
+function assertSameError(fn, expected) {
+  assert.throws(fn, (err) => {
+    assert.strictEqual(err, expected);
+    return true;
+  });
+}
+
+// https://webidl.spec.whatwg.org/#abstract-opdef-converttoint
+const two63 = 2 ** 63;
+const two64 = 2 ** 64;
+
+assert.strictEqual(convertToInt(0, 64), 0);
+assert.strictEqual(convertToInt(1, 64), 1);
+assert.strictEqual(convertToInt(-0.5, 64), 0);
+assert.strictEqual(convertToInt(-0.5, 64, 'signed'), 0);
+assert.strictEqual(convertToInt(-1.5, 64, 'signed'), -1);
+assert.strictEqual(convertToInt(2 ** 12 + 1, 12), 1);
+assert.strictEqual(convertToInt(-1, 12), 2 ** 12 - 1);
+assert.strictEqual(convertToInt(2 ** 11, 12, 'signed'), -(2 ** 11));
+assert.strictEqual(convertToInt(-1, 12, 'signed'), -1);
+
+{
+  const options = {
+    get enforceRange() {
+      throw new Error('enforceRange should not be read');
+    },
+    get clamp() {
+      throw new Error('clamp should not be read');
+    },
+  };
+
+  assert.strictEqual(convertToInt(7, 8, 'unsigned', options), 7);
+}
+
+{
+  const opts = {
+    __proto__: null,
+    prefix: 'Prefix',
+    context: 'Context',
+  };
+
+  assert.throws(() => convertToInt(1n, 8, 'unsigned', opts), {
+    name: 'TypeError',
+    code: 'ERR_INVALID_ARG_TYPE',
+    message: 'Prefix: Context is a BigInt and cannot be converted ' +
+      'to a number.',
+  });
+
+  assert.throws(() => convertToInt(Symbol(), 8, 'unsigned', opts), {
+    name: 'TypeError',
+    code: 'ERR_INVALID_ARG_TYPE',
+    message: 'Prefix: Context is a Symbol and cannot be converted ' +
+      'to a number.',
+  });
+
+  for (const value of [
+    Object(1n),
+    { valueOf() { return 1n; } },
+    { valueOf() { return {}; }, toString() { return 1n; } },
+    { [Symbol.toPrimitive]() { return 1n; } },
+    Object(Symbol()),
+    { valueOf() { return Symbol(); } },
+    { valueOf() { return {}; }, toString() { return Symbol(); } },
+    { [Symbol.toPrimitive]() { return Symbol(); } },
+  ]) {
+    assertPlainTypeError(() => convertToInt(value, 8, 'unsigned', opts));
+  }
+
+  assert.strictEqual(convertToInt({
+    valueOf() { return {}; },
+    toString() { return 7; },
+  }, 8), 7);
+
+  {
+    const value = Object(1n);
+    value.valueOf = () => 7;
+    assert.strictEqual(convertToInt(value, 8), 7);
+  }
+
+  {
+    const calls = [];
+    const value = {
+      [Symbol.toPrimitive](hint) {
+        calls.push(hint);
+        return '7';
+      },
+      valueOf() {
+        calls.push('valueOf');
+        return 1;
+      },
+      toString() {
+        calls.push('toString');
+        return '1';
+      },
+    };
+
+    assert.strictEqual(convertToInt(value, 8), 7);
+    assert.deepStrictEqual(calls, ['number']);
+  }
+
+  for (const { value, expected } of [
+    {
+      value: {
+        [Symbol.toPrimitive]: undefined,
+        valueOf() { return 8; },
+      },
+      expected: 8,
+    },
+    {
+      value: {
+        [Symbol.toPrimitive]: null,
+        valueOf() { return 9; },
+      },
+      expected: 9,
+    },
+  ]) {
+    assert.strictEqual(convertToInt(value, 8), expected);
+  }
+
+  {
+    const calls = [];
+    const value = {
+      valueOf: 1,
+      toString() {
+        calls.push('toString');
+        return '10';
+      },
+    };
+
+    assert.strictEqual(convertToInt(value, 8), 10);
+    assert.deepStrictEqual(calls, ['toString']);
+  }
+
+  {
+    const calls = [];
+    const value = {
+      valueOf() {
+        calls.push('valueOf');
+        return {};
+      },
+      toString() {
+        calls.push('toString');
+        return '11';
+      },
+    };
+
+    assert.strictEqual(convertToInt(value, 8), 11);
+    assert.deepStrictEqual(calls, ['valueOf', 'toString']);
+  }
+
+  for (const value of [
+    { [Symbol.toPrimitive]: 1 },
+    { [Symbol.toPrimitive]() { return {}; } },
+    {
+      valueOf() { return {}; },
+      toString() { return {}; },
+    },
+  ]) {
+    assertPlainTypeError(() => convertToInt(value, 8, 'unsigned', opts));
+  }
+
+  {
+    const sentinel = new TypeError('sentinel');
+    assertSameError(() => convertToInt({
+      get [Symbol.toPrimitive]() {
+        throw sentinel;
+      },
+    }, 8), sentinel);
+  }
+
+  {
+    const sentinel = new TypeError('sentinel');
+    assertSameError(() => convertToInt({
+      get valueOf() {
+        throw sentinel;
+      },
+      toString() {
+        return 1;
+      },
+    }, 8), sentinel);
+  }
+
+  {
+    const sentinel = new TypeError('sentinel');
+    assertSameError(() => convertToInt({
+      valueOf() {
+        throw sentinel;
+      },
+      toString() {
+        return 1;
+      },
+    }, 8), sentinel);
+  }
+}
+
+// EnforceRange
+const nonFiniteValues = [NaN, Infinity, -Infinity];
+for (const value of nonFiniteValues) {
+  assert.throws(() => convertToInt(value, 64, 'unsigned', {
+    enforceRange: true,
+  }), {
+    name: 'TypeError',
+    code: 'ERR_INVALID_ARG_TYPE',
+  });
+}
+
+assert.strictEqual(convertToInt(-0.8, 64, 'unsigned', {
+  enforceRange: true,
+}), 0);
+assert.strictEqual(convertToInt(-0.8, 64, 'signed', {
+  enforceRange: true,
+}), 0);
+assert.strictEqual(convertToInt(Number.MAX_SAFE_INTEGER, 64, 'signed', {
+  enforceRange: true,
+}), Number.MAX_SAFE_INTEGER);
+assert.strictEqual(convertToInt(Number.MIN_SAFE_INTEGER, 64, 'signed', {
+  enforceRange: true,
+}), Number.MIN_SAFE_INTEGER);
+assert.strictEqual(convertToInt(-0.5, 8, 'unsigned', {
+  enforceRange: true,
+}), 0);
+assert.strictEqual(convertToInt(255.5, 8, 'unsigned', {
+  enforceRange: true,
+}), 255);
+
+const outOfRangeValues = [2 ** 53, -(2 ** 53)];
+for (const value of outOfRangeValues) {
+  assert.throws(() => convertToInt(value, 64, 'unsigned', {
+    enforceRange: true,
+  }), {
+    name: 'TypeError',
+    code: 'ERR_OUT_OF_RANGE',
+  });
+}
+assert.throws(() => convertToInt(Number.MAX_SAFE_INTEGER + 1, 64, 'signed', {
+  enforceRange: true,
+}), {
+  name: 'TypeError',
+  code: 'ERR_OUT_OF_RANGE',
+});
+assert.throws(() => convertToInt(Number.MIN_SAFE_INTEGER - 1, 64, 'signed', {
+  enforceRange: true,
+}), {
+  name: 'TypeError',
+  code: 'ERR_OUT_OF_RANGE',
+});
+assert.throws(() => convertToInt(256, 8, 'unsigned', {
+  enforceRange: true,
+}), {
+  name: 'TypeError',
+  code: 'ERR_OUT_OF_RANGE',
+});
+
+{
+  const calls = [];
+  const options = {
+    get enforceRange() {
+      calls.push('enforceRange');
+      return false;
+    },
+    get clamp() {
+      calls.push('clamp');
+      return true;
+    },
+  };
+
+  assert.strictEqual(convertToInt(256, 8, 'unsigned', options), 255);
+  assert.deepStrictEqual(calls, ['enforceRange', 'clamp']);
+}
+
+{
+  const calls = [];
+  const options = {
+    get enforceRange() {
+      calls.push('enforceRange');
+      return false;
+    },
+    get clamp() {
+      calls.push('clamp');
+      return true;
+    },
+  };
+
+  assert.strictEqual(convertToInt({ valueOf: () => 2.5 }, 8, 'unsigned', options), 2);
+  assert.deepStrictEqual(calls, ['enforceRange', 'clamp']);
+}
+
+// Out of range: clamp
+assert.strictEqual(convertToInt(NaN, 64, 'unsigned', { clamp: true }), 0);
+assert.strictEqual(convertToInt(Infinity, 64, 'unsigned', { clamp: true }), Number.MAX_SAFE_INTEGER);
+assert.strictEqual(convertToInt(-Infinity, 64, 'unsigned', { clamp: true }), 0);
+assert.strictEqual(convertToInt(-Infinity, 64, 'signed', { clamp: true }), Number.MIN_SAFE_INTEGER);
+assert.strictEqual(convertToInt(0x1_0000, 16, 'unsigned', { clamp: true }), 0xFFFF);
+assert.strictEqual(convertToInt(0x1_0000_0000, 32, 'unsigned', { clamp: true }), 0xFFFF_FFFF);
+assert.strictEqual(convertToInt(0xFFFF_FFFF, 32, 'unsigned', { clamp: true }), 0xFFFF_FFFF);
+assert.strictEqual(convertToInt(0x8000, 16, 'signed', { clamp: true }), 0x7FFF);
+assert.strictEqual(convertToInt(-0x8001, 16, 'signed', { clamp: true }), -0x8000);
+assert.strictEqual(convertToInt(0x8000_0000, 32, 'signed', { clamp: true }), 0x7FFF_FFFF);
+assert.strictEqual(convertToInt(0xFFFF_FFFF, 32, 'signed', { clamp: true }), 0x7FFF_FFFF);
+assert.strictEqual(convertToInt(0.5, 64, 'unsigned', { clamp: true }), 0);
+assert.strictEqual(convertToInt(0.8, 64, 'unsigned', { clamp: true }), 1);
+assert.strictEqual(convertToInt(1.5, 64, 'unsigned', { clamp: true }), 2);
+assert.strictEqual(convertToInt(-0.5, 64, 'unsigned', { clamp: true }), 0);
+assert.strictEqual(convertToInt(-0.5, 64, 'signed', { clamp: true }), 0);
+assert.strictEqual(convertToInt(-0.8, 64, 'signed', { clamp: true }), -1);
+assert.strictEqual(convertToInt(-1.5, 64, 'signed', { clamp: true }), -2);
+
+// Out of range, step 8.
+assert.strictEqual(convertToInt(NaN, 64), 0);
+assert.strictEqual(convertToInt(Infinity, 64), 0);
+assert.strictEqual(convertToInt(-Infinity, 64), 0);
+assert.strictEqual(convertToInt(-3, 8), 253);
+assert.strictEqual(convertToInt(-3, 8), new Uint8Array([-3])[0]);
+assert.strictEqual(convertToInt(0x1_0000, 16), 0);
+assert.strictEqual(convertToInt(0x1_0001, 16), 1);
+assert.strictEqual(convertToInt(-1, 16), 0xFFFF);
+assert.strictEqual(convertToInt(-1, 16), new Uint16Array([-1])[0]);
+assert.strictEqual(convertToInt(0x1_0000_0000, 32), 0);
+assert.strictEqual(convertToInt(0x1_0000_0001, 32), 1);
+assert.strictEqual(convertToInt(0xFFFF_FFFF, 32), 0xFFFF_FFFF);
+assert.strictEqual(convertToInt(-1, 32), 0xFFFF_FFFF);
+assert.strictEqual(convertToInt(-1, 32), new Uint32Array([-1])[0]);
+assert.strictEqual(convertToInt(-8192, 64), 2 ** 64 - 8192);
+assert.strictEqual(convertToInt(two63, 64), two63);
+assert.strictEqual(convertToInt(two64, 64), 0);
+assert.strictEqual(convertToInt(two64 + 8192, 64), 8192);
+assert.strictEqual(convertToInt(-(two64 + 2 ** 12), 64),
+                   two64 - 2 ** 12);
+
+// Out of range, step 11.
+assert.strictEqual(convertToInt(0x8000, 16, 'signed'), -0x8000);
+assert.strictEqual(convertToInt(0xFFFF, 16, 'signed'), -1);
+assert.strictEqual(convertToInt(-0x8001, 16, 'signed'), 0x7FFF);
+assert.strictEqual(convertToInt(-0x8001, 16, 'signed'), new Int16Array([-0x8001])[0]);
+assert.strictEqual(convertToInt(0x8000_0000, 32, 'signed'), -0x8000_0000);
+assert.strictEqual(convertToInt(0xFFF_FFFF, 32, 'signed'), 0xFFF_FFFF);
+assert.strictEqual(convertToInt(-200, 8, 'signed'), 56);
+assert.strictEqual(convertToInt(-200, 8, 'signed'), new Int8Array([-200])[0]);
+assert.strictEqual(convertToInt(-8192, 64, 'signed'), -8192);
+assert.strictEqual(convertToInt(-8193, 64, 'signed'), -8193);
+assert.strictEqual(convertToInt(two63, 64, 'signed'), -two63);
+assert.strictEqual(convertToInt(two63 + 2 ** 11, 64, 'signed'),
+                   -two63 + 2 ** 11);
+assert.strictEqual(convertToInt(two64 + 8192, 64, 'signed'), 8192);
+assert.strictEqual(convertToInt(-(two64 + 2 ** 12), 64, 'signed'),
+                   -(2 ** 12));
diff --git a/test/js/node/test/parallel/test-internal-webidl.js b/test/js/node/test/parallel/test-internal-webidl.js
new file mode 100644
index 000000000000..bd08648549be
--- /dev/null
+++ b/test/js/node/test/parallel/test-internal-webidl.js
@@ -0,0 +1,616 @@
+// Flags: --expose-internals
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const vm = require('vm');
+const webidl = require('internal/webidl');
+
+const { converters } = webidl;
+const opts = {
+  __proto__: null,
+  prefix: 'Prefix',
+  context: 'Context',
+};
+function createGrowableSharedArrayBufferView() {
+  const buffer = new SharedArrayBuffer(4, { maxByteLength: 8 });
+  const view = new Uint8Array(buffer);
+  assert.strictEqual(view.buffer.growable, true);
+  return view;
+}
+
+function assertInvalidArgType(fn) {
+  assert.throws(fn, {
+    name: 'TypeError',
+    code: 'ERR_INVALID_ARG_TYPE',
+  });
+}
+
+function assertPlainTypeError(fn) {
+  assert.throws(fn, (err) => {
+    assert(err instanceof TypeError);
+    assert.strictEqual(err.name, 'TypeError');
+    assert.strictEqual(err.code, undefined);
+    return true;
+  });
+}
+
+function assertSameError(fn, expected) {
+  assert.throws(fn, (err) => {
+    assert.strictEqual(err, expected);
+    return true;
+  });
+}
+
+assert.strictEqual(webidl.type(undefined), 'Undefined');
+assert.strictEqual(webidl.type(null), 'Null');
+assert.strictEqual(webidl.type(false), 'Boolean');
+assert.strictEqual(webidl.type(''), 'String');
+assert.strictEqual(webidl.type(Symbol()), 'Symbol');
+assert.strictEqual(webidl.type(0), 'Number');
+assert.strictEqual(webidl.type(0n), 'BigInt');
+assert.strictEqual(webidl.type({}), 'Object');
+assert.strictEqual(webidl.type(function fn() {}), 'Object');
+
+assert.strictEqual(converters.boolean(0), false);
+assert.strictEqual(converters.boolean('false'), true);
+{
+  function fn() {}
+  assert.strictEqual(converters.object(fn), fn);
+}
+assert.throws(() => converters.object(null, opts), {
+  name: 'TypeError',
+  code: 'ERR_INVALID_ARG_TYPE',
+  message: 'Prefix: Context is not an object.',
+});
+
+assert.strictEqual(converters.DOMString(null), 'null');
+assert.throws(() => converters.DOMString(Symbol(), opts), {
+  name: 'TypeError',
+  code: 'ERR_INVALID_ARG_TYPE',
+  message: 'Prefix: Context is a Symbol and cannot be converted to a string.',
+});
+
+for (const value of [
+  Object(Symbol()),
+  { toString() { return Symbol(); } },
+  { toString() { return {}; }, valueOf() { return Symbol(); } },
+  { [Symbol.toPrimitive]() { return Symbol(); } },
+]) {
+  assertPlainTypeError(() => converters.DOMString(value, opts));
+}
+assert.strictEqual(converters.DOMString(1n), '1');
+assert.strictEqual(converters.DOMString(Object(1n)), '1');
+assert.strictEqual(converters.DOMString({
+  toString() { return {}; },
+  valueOf() { return 1n; },
+}), '1');
+assert.strictEqual(converters.DOMString({
+  [Symbol.toPrimitive]() { return 1n; },
+}), '1');
+{
+  const value = Object(Symbol());
+  Object.defineProperty(value, Symbol.toPrimitive, {
+    __proto__: null,
+    value() { return 'symbol object'; },
+  });
+  assert.strictEqual(converters.DOMString(value), 'symbol object');
+}
+
+{
+  const calls = [];
+  const value = {
+    [Symbol.toPrimitive](hint) {
+      calls.push(hint);
+      return 7;
+    },
+    toString() {
+      calls.push('toString');
+      return '1';
+    },
+    valueOf() {
+      calls.push('valueOf');
+      return 1;
+    },
+  };
+
+  assert.strictEqual(converters.DOMString(value), '7');
+  assert.deepStrictEqual(calls, ['string']);
+}
+
+for (const { value, expected } of [
+  {
+    value: {
+      [Symbol.toPrimitive]: undefined,
+      toString() { return 'eight'; },
+    },
+    expected: 'eight',
+  },
+  {
+    value: {
+      [Symbol.toPrimitive]: null,
+      toString() { return 'nine'; },
+    },
+    expected: 'nine',
+  },
+]) {
+  assert.strictEqual(converters.DOMString(value), expected);
+}
+
+{
+  const calls = [];
+  const value = {
+    toString: 1,
+    valueOf() {
+      calls.push('valueOf');
+      return 10;
+    },
+  };
+
+  assert.strictEqual(converters.DOMString(value), '10');
+  assert.deepStrictEqual(calls, ['valueOf']);
+}
+
+{
+  const calls = [];
+  const value = {
+    toString() {
+      calls.push('toString');
+      return {};
+    },
+    valueOf() {
+      calls.push('valueOf');
+      return 11;
+    },
+  };
+
+  assert.strictEqual(converters.DOMString(value), '11');
+  assert.deepStrictEqual(calls, ['toString', 'valueOf']);
+}
+
+for (const value of [
+  { [Symbol.toPrimitive]: 1 },
+  { [Symbol.toPrimitive]() { return {}; } },
+  {
+    toString() { return {}; },
+    valueOf() { return {}; },
+  },
+]) {
+  assertPlainTypeError(() => converters.DOMString(value, opts));
+}
+
+{
+  const sentinel = new TypeError('sentinel');
+  assertSameError(() => converters.DOMString({
+    get [Symbol.toPrimitive]() {
+      throw sentinel;
+    },
+  }), sentinel);
+}
+
+{
+  const sentinel = new TypeError('sentinel');
+  assertSameError(() => converters.DOMString({
+    get toString() {
+      throw sentinel;
+    },
+    valueOf() {
+      return 1;
+    },
+  }), sentinel);
+}
+
+{
+  const sentinel = new TypeError('sentinel');
+  assertSameError(() => converters.DOMString({
+    toString() {
+      throw sentinel;
+    },
+    valueOf() {
+      return 1;
+    },
+  }), sentinel);
+}
+
+{
+  assert.strictEqual(converters.octet(-1), 255);
+  assert.strictEqual(converters['unsigned short'](-1), 0xFFFF);
+  assert.strictEqual(converters['unsigned long'](-1), 0xFFFF_FFFF);
+  assert.strictEqual(converters['long long'](-1), -1);
+  assert.strictEqual(converters.octet(2.5, {
+    __proto__: null,
+    clamp: true,
+  }), 2);
+  assert.throws(() => converters.octet(256, {
+    __proto__: null,
+    ...opts,
+    enforceRange: true,
+  }), {
+    name: 'TypeError',
+    code: 'ERR_OUT_OF_RANGE',
+    message: 'Prefix: Context is outside the expected range of 0 to 255.',
+  });
+}
+
+{
+  const converter = webidl.createEnumConverter('Example', ['one', 'two']);
+
+  assert.strictEqual(converter('one'), 'one');
+  assert.throws(() => converter(Symbol(), opts), {
+    name: 'TypeError',
+    code: 'ERR_INVALID_ARG_TYPE',
+    message: 'Prefix: Context is a Symbol and cannot be converted to a string.',
+  });
+  assert.throws(() => converter('three', opts), {
+    name: 'TypeError',
+    code: 'ERR_INVALID_ARG_VALUE',
+    message: "Prefix: Context 'three' is not a valid enum value " +
+      'of type Example.',
+  });
+}
+
+assert.throws(() => webidl.requiredArguments(1, 2, opts), {
+  name: 'TypeError',
+  code: 'ERR_MISSING_ARGS',
+  message: 'Prefix: 2 arguments required, but only 1 present.',
+});
+
+{
+  const ab = new ArrayBuffer(8, { maxByteLength: 16 });
+  const view = new Uint8Array(ab);
+  const dataView = new DataView(ab);
+
+  assert.strictEqual(ab.resizable, true);
+  assertInvalidArgType(() => converters.BufferSource(ab));
+  assertInvalidArgType(() => converters.BufferSource(view));
+  assertInvalidArgType(() => converters.BufferSource(dataView));
+  assertInvalidArgType(() => converters.Uint8Array(view));
+
+  const disallowResizable = {
+    __proto__: null,
+    allowResizable: false,
+  };
+  assertInvalidArgType(() => converters.BufferSource(ab, disallowResizable));
+  assertInvalidArgType(() => converters.BufferSource(view, disallowResizable));
+  assertInvalidArgType(() => converters.BufferSource(dataView,
+                                                     disallowResizable));
+
+  const allowResizable = {
+    __proto__: null,
+    allowResizable: true,
+  };
+  assert.strictEqual(converters.BufferSource(ab, allowResizable), ab);
+  assert.strictEqual(converters.BufferSource(view, allowResizable), view);
+  assert.strictEqual(converters.BufferSource(dataView, allowResizable),
+                     dataView);
+  assert.strictEqual(converters.Uint8Array(view, allowResizable), view);
+}
+
+{
+  const ab = new ArrayBuffer(8);
+  const view = new Uint8Array(ab);
+  const dataView = new DataView(ab);
+
+  structuredClone(ab, { transfer: [ab] });
+  assert.strictEqual(ab.detached, true);
+  assert.strictEqual(converters.BufferSource(ab), ab);
+  assert.strictEqual(converters.BufferSource(view), view);
+  assert.strictEqual(converters.BufferSource(dataView), dataView);
+}
+
+{
+  const ab = new ArrayBuffer(8, { maxByteLength: 16 });
+  const view = new Uint8Array(ab);
+  const dataView = new DataView(ab);
+  const allowResizable = {
+    __proto__: null,
+    allowResizable: true,
+  };
+
+  structuredClone(ab, { transfer: [ab] });
+  assert.strictEqual(ab.detached, true);
+  assert.strictEqual(ab.resizable, true);
+  assertInvalidArgType(() => converters.BufferSource(ab));
+  assertInvalidArgType(() => converters.BufferSource(view));
+  assertInvalidArgType(() => converters.BufferSource(dataView));
+  assertInvalidArgType(() => converters.Uint8Array(view));
+
+  const disallowResizable = {
+    __proto__: null,
+    allowResizable: false,
+  };
+  assertInvalidArgType(() => converters.BufferSource(ab, disallowResizable));
+  assertInvalidArgType(() => converters.BufferSource(view, disallowResizable));
+  assertInvalidArgType(() => converters.BufferSource(dataView,
+                                                     disallowResizable));
+
+  assert.strictEqual(converters.BufferSource(ab, allowResizable), ab);
+  assert.strictEqual(converters.BufferSource(view, allowResizable), view);
+  assert.strictEqual(converters.BufferSource(dataView, allowResizable),
+                     dataView);
+  assert.strictEqual(converters.Uint8Array(view, allowResizable), view);
+}
+
+{
+  const ab = new ArrayBuffer(8, { maxByteLength: 16 });
+  const view = new Uint8Array(ab);
+
+  assert.strictEqual(converters.BufferSource(ab, {
+    __proto__: null,
+    allowResizable: true,
+  }), ab);
+  assert.strictEqual(converters.BufferSource(view, {
+    __proto__: null,
+    allowResizable: true,
+  }), view);
+
+  ab.resize(4);
+  assert.strictEqual(ab.byteLength, 4);
+  assert.strictEqual(view.byteLength, 4);
+
+  ab.resize(12);
+  assert.strictEqual(ab.byteLength, 12);
+  assert.strictEqual(view.byteLength, 12);
+}
+
+{
+  const converter = webidl.createDictionaryConverter('Example', [
+    {
+      key: 'value',
+      converter: converters.DOMString,
+      required: true,
+    },
+  ]);
+
+  const idlDict = converter({ value: 1 });
+  assert.deepStrictEqual(idlDict, { __proto__: null, value: '1' });
+
+  assert.throws(() => converter({}, opts), {
+    name: 'TypeError',
+    code: 'ERR_MISSING_OPTION',
+    message: "Prefix: Context cannot be converted to 'Example' because " +
+      "'value' is required in 'Example'.",
+  });
+}
+
+{
+  const calls = [];
+  const converter = webidl.createDictionaryConverter('Derived', [
+    [
+      {
+        key: 'zBase',
+        converter(value) {
+          calls.push(`base z:${value}`);
+          return value;
+        },
+      },
+      {
+        key: 'aBase',
+        converter(value) {
+          calls.push(`base a:${value}`);
+          return value;
+        },
+      },
+    ],
+    [
+      {
+        key: 'zDerived',
+        converter(value) {
+          calls.push(`derived z:${value}`);
+          return value;
+        },
+      },
+      {
+        key: 'aDerived',
+        converter(value) {
+          calls.push(`derived a:${value}`);
+          return value;
+        },
+      },
+    ],
+  ]);
+
+  assert.deepStrictEqual(converter({
+    zBase: 1,
+    aBase: 2,
+    zDerived: 3,
+    aDerived: 4,
+  }), {
+    __proto__: null,
+    aBase: 2,
+    zBase: 1,
+    aDerived: 4,
+    zDerived: 3,
+  });
+  assert.deepStrictEqual(calls, [
+    'base a:2',
+    'base z:1',
+    'derived a:4',
+    'derived z:3',
+  ]);
+}
+
+{
+  const converter = webidl.createDictionaryConverter('Example', [
+    {
+      key: 'same',
+      converter(value) {
+        return `first:${value}`;
+      },
+    },
+    {
+      key: 'same',
+      converter(value) {
+        return `second:${value}`;
+      },
+    },
+  ]);
+
+  assert.deepStrictEqual(converter({ same: 1 }), {
+    __proto__: null,
+    same: 'second:1',
+  });
+}
+
+{
+  const converter = converters['sequence<DOMString>'];
+  assert.deepStrictEqual(converter([1, 2]), ['1', '2']);
+
+  assert.throws(() => converter([Symbol()]), {
+    name: 'TypeError',
+    code: 'ERR_INVALID_ARG_TYPE',
+    message: 'Value[0] is a Symbol and cannot be converted to a string.',
+  });
+
+  assert.throws(() => converter({ [Symbol.iterator]: 1 }, opts), {
+    name: 'TypeError',
+    code: 'ERR_INVALID_ARG_TYPE',
+    message: 'Prefix: Context cannot be converted to sequence.',
+  });
+
+  assert.throws(() => converter({
+    [Symbol.iterator]() {
+      return {};
+    },
+  }, opts), {
+    name: 'TypeError',
+    code: 'ERR_INVALID_ARG_TYPE',
+    message: 'Prefix: Context cannot be converted to sequence.',
+  });
+
+  assert.throws(() => converter({
+    [Symbol.iterator]() {
+      return {
+        next() {
+          return null;
+        },
+      };
+    },
+  }, opts), {
+    name: 'TypeError',
+    code: 'ERR_INVALID_ARG_TYPE',
+    message: 'Prefix: Context cannot be converted to sequence.',
+  });
+
+  assert.throws(() => converter([Symbol()], opts), {
+    name: 'TypeError',
+    code: 'ERR_INVALID_ARG_TYPE',
+    message: 'Prefix: Context[0] is a Symbol and cannot be converted ' +
+      'to a string.',
+  });
+
+  assert.deepStrictEqual(converter({
+    [Symbol.iterator]() {
+      return {
+        next() {
+          return { done: 1, value: Symbol() };
+        },
+      };
+    },
+  }), []);
+}
+
+{
+  class Example {}
+  const converter = webidl.createInterfaceConverter(
+    'Example',
+    Example.prototype);
+  const example = new Example();
+
+  assert.strictEqual(converter(example), example);
+  assert.throws(() => converter({}, opts), {
+    name: 'TypeError',
+    code: 'ERR_INVALID_ARG_TYPE',
+    message: 'Prefix: Context is not of type Example.',
+  });
+}
+
+{
+  const context = vm.createContext();
+  const view = vm.runInContext(
+    'new Uint8Array(new ArrayBuffer(0))',
+    context,
+  );
+  assert.strictEqual(converters.Uint8Array(view), view);
+
+  for (const value of [
+    new ArrayBuffer(0),
+    new SharedArrayBuffer(0),
+    new DataView(new ArrayBuffer(0)),
+    new Int8Array(0),
+    Object.create(Uint8Array.prototype, {
+      [Symbol.toStringTag]: { value: 'Uint8Array' },
+    }),
+  ]) {
+    assertInvalidArgType(() => converters.Uint8Array(value));
+  }
+}
+
+{
+  const sab = new SharedArrayBuffer(4);
+  const view = new Uint8Array(sab);
+
+  assertInvalidArgType(() => converters.BufferSource(sab));
+  assertInvalidArgType(() => converters.BufferSource(view));
+  assertInvalidArgType(() => converters.Uint8Array(view));
+
+  const allowShared = {
+    __proto__: null,
+    allowShared: true,
+  };
+  assertInvalidArgType(() => converters.BufferSource(sab, allowShared));
+  assertInvalidArgType(() => converters.BufferSource(view, allowShared));
+  assert.strictEqual(converters.AllowSharedBufferSource(sab), sab);
+  assert.strictEqual(converters.AllowSharedBufferSource(view), view);
+  assert.strictEqual(converters.Uint8Array(view, allowShared), view);
+
+  const growableView = createGrowableSharedArrayBufferView();
+
+  assertInvalidArgType(() => converters.BufferSource(growableView, {
+    __proto__: null,
+    allowShared: true,
+    allowResizable: true,
+  }));
+  assert.throws(() => converters.AllowSharedBufferSource(growableView.buffer, {
+    __proto__: null,
+    ...opts,
+  }), {
+    name: 'TypeError',
+    code: 'ERR_INVALID_ARG_TYPE',
+    message: 'Prefix: Context is backed by a growable ' +
+      'SharedArrayBuffer, which is not allowed.',
+  });
+  assert.throws(() => converters.AllowSharedBufferSource(growableView, {
+    __proto__: null,
+    ...opts,
+    allowResizable: false,
+  }), {
+    name: 'TypeError',
+    code: 'ERR_INVALID_ARG_TYPE',
+    message: 'Prefix: Context is backed by a growable ' +
+      'SharedArrayBuffer, which is not allowed.',
+  });
+  assert.throws(() => converters.Uint8Array(growableView, {
+    __proto__: null,
+    ...opts,
+    allowShared: true,
+  }), {
+    name: 'TypeError',
+    code: 'ERR_INVALID_ARG_TYPE',
+    message: 'Prefix: Context is backed by a growable ' +
+      'SharedArrayBuffer, which is not allowed.',
+  });
+  assert.strictEqual(converters.AllowSharedBufferSource(growableView.buffer, {
+    __proto__: null,
+    allowResizable: true,
+  }), growableView.buffer);
+  assert.strictEqual(converters.AllowSharedBufferSource(growableView, {
+    __proto__: null,
+    allowResizable: true,
+  }), growableView);
+  assert.strictEqual(converters.Uint8Array(growableView, {
+    __proto__: null,
+    allowShared: true,
+    allowResizable: true,
+  }), growableView);
+}
diff --git a/test/js/node/test/parallel/test-macos-app-sandbox.js b/test/js/node/test/parallel/test-macos-app-sandbox.js
new file mode 100644
index 000000000000..60ad67b3db37
--- /dev/null
+++ b/test/js/node/test/parallel/test-macos-app-sandbox.js
@@ -0,0 +1,71 @@
+'use strict';
+const common = require('../common');
+if (process.platform !== 'darwin')
+  common.skip('App Sandbox is only available on Darwin');
+if (process.config.variables.node_builtin_modules_path)
+  common.skip('App Sandbox cannot load modules from outside the sandbox');
+
+const fixtures = require('../common/fixtures');
+const tmpdir = require('../common/tmpdir');
+const assert = require('assert');
+const child_process = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+const nodeBinary = process.execPath;
+
+tmpdir.refresh();
+
+if (!tmpdir.hasEnoughSpace(120 * 1024 * 1024)) {
+  common.skip('Available disk space < 120MB');
+}
+
+const appBundlePath = tmpdir.resolve('node_sandboxed.app');
+const appBundleContentPath = path.join(appBundlePath, 'Contents');
+const appExecutablePath = path.join(
+  appBundleContentPath, 'MacOS', 'node');
+
+// Construct the app bundle and put the node executable in it:
+// node_sandboxed.app/
+// └── Contents
+//     ├── Info.plist
+//     ├── MacOS
+//     │   └── node
+fs.mkdirSync(appBundlePath);
+fs.mkdirSync(appBundleContentPath);
+fs.mkdirSync(path.join(appBundleContentPath, 'MacOS'));
+fs.copyFileSync(
+  fixtures.path('macos-app-sandbox', 'Info.plist'),
+  path.join(appBundleContentPath, 'Info.plist'));
+fs.copyFileSync(
+  nodeBinary,
+  appExecutablePath);
+
+
+// Sign the app bundle with sandbox entitlements:
+assert.strictEqual(
+  child_process.spawnSync('/usr/bin/codesign', [
+    '--entitlements', fixtures.path(
+      'macos-app-sandbox', 'node_sandboxed.entitlements'),
+    '--force', '-s', '-',
+    appBundlePath,
+  ]).status,
+  0);
+
+// Sandboxed app shouldn't be able to read the home dir
+assert.notStrictEqual(
+  child_process.spawnSync(appExecutablePath, [
+    '-e', 'fs.readdirSync(process.argv[1])', os.homedir(),
+  ]).status,
+  0);
+
+if (process.stdin.isTTY) {
+  // Run the sandboxed node instance with inherited tty stdin
+  const spawnResult = child_process.spawnSync(
+    appExecutablePath, ['-e', ''],
+    { stdio: 'inherit' }
+  );
+
+  assert.strictEqual(spawnResult.signal, null);
+}
diff --git a/test/js/node/test/parallel/test-net-normalize-args.js b/test/js/node/test/parallel/test-net-normalize-args.js
new file mode 100644
index 000000000000..65d569d5d5fd
--- /dev/null
+++ b/test/js/node/test/parallel/test-net-normalize-args.js
@@ -0,0 +1,55 @@
+'use strict';
+// Flags: --expose-internals
+const common = require('../common');
+const assert = require('assert');
+const net = require('net');
+const { normalizedArgsSymbol } = require('internal/net');
+
+function validateNormalizedArgs(input, output) {
+  const args = net._normalizeArgs(input);
+
+  assert.deepStrictEqual(args, output);
+  assert.strictEqual(args[normalizedArgsSymbol], true);
+}
+
+// Test creation of normalized arguments.
+const res = [{}, null];
+res[normalizedArgsSymbol] = true;
+validateNormalizedArgs([], res);
+res[0].port = 1234;
+validateNormalizedArgs([{ port: 1234 }], res);
+res[1] = assert.fail;
+validateNormalizedArgs([{ port: 1234 }, assert.fail], res);
+
+// Connecting to the server should fail with a standard array.
+{
+  const server = net.createServer(common.mustNotCall('should not connect'));
+
+  server.listen(common.mustCall(() => {
+    const port = server.address().port;
+    const socket = new net.Socket();
+
+    assert.throws(() => {
+      socket.connect([{ port }, assert.fail]);
+    }, {
+      code: 'ERR_MISSING_ARGS'
+    });
+    server.close();
+  }));
+}
+
+// Connecting to the server should succeed with a normalized array.
+{
+  const server = net.createServer(common.mustCall((connection) => {
+    connection.end();
+    server.close();
+  }));
+
+  server.listen(common.mustCall(() => {
+    const port = server.address().port;
+    const socket = new net.Socket();
+    const args = net._normalizeArgs([{ port }, common.mustCall()]);
+
+    socket.connect(args);
+  }));
+}
diff --git a/test/js/node/test/parallel/test-options-binding.js b/test/js/node/test/parallel/test-options-binding.js
new file mode 100644
index 000000000000..5c910360d00f
--- /dev/null
+++ b/test/js/node/test/parallel/test-options-binding.js
@@ -0,0 +1,16 @@
+// Flags: --expose-internals
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { getOptionValue } = require('internal/options');
+
+Map.prototype.get =
+  common.mustNotCall('`getOptionValue` must not call user-mutable method');
+assert.strictEqual(getOptionValue('--expose-internals'), true);
+
+Object.prototype['--nonexistent-option'] = 'foo';
+assert.strictEqual(getOptionValue('--nonexistent-option'), undefined);
+
+// Make the test common global leak test happy.
+delete Object.prototype['--nonexistent-option'];
diff --git a/test/js/node/test/parallel/test-parse-test-envs.js b/test/js/node/test/parallel/test-parse-test-envs.js
new file mode 100644
index 000000000000..501db4b758de
--- /dev/null
+++ b/test/js/node/test/parallel/test-parse-test-envs.js
@@ -0,0 +1,26 @@
+'use strict';
+
+// Env: A_SET_ENV_VAR=A_SET_ENV_VAR_VALUE B_SET_ENV_VAR=B_SET_ENV_VAR_VALUE
+// Flags: --test-isolation=none --expose-internals
+
+require('../common');
+const assert = require('node:assert');
+const { describe, it } = require('node:test');
+
+
+// This test verifies that a test file that requires 'common' can set environment variables
+// via comments in the test file, similar to how we set flags via comments.
+// Ref: https://github.com/nodejs/node/issues/58179
+describe('env var via comment', () => {
+  it('should set env var A_SET_ENV_VAR', () => {
+    assert.strictEqual(process.env.A_SET_ENV_VAR, 'A_SET_ENV_VAR_VALUE');
+  });
+  it('should set env var B_SET_ENV_VAR', () => {
+    assert.strictEqual(process.env.B_SET_ENV_VAR, 'B_SET_ENV_VAR_VALUE');
+  });
+
+  it('should interop with flags', () => {
+    const flag = require('internal/options').getOptionValue('--test-isolation');
+    assert.strictEqual(flag, 'none');
+  });
+});
diff --git a/test/js/node/test/parallel/test-parse-test-only-envs.js b/test/js/node/test/parallel/test-parse-test-only-envs.js
new file mode 100644
index 000000000000..0eafec719325
--- /dev/null
+++ b/test/js/node/test/parallel/test-parse-test-only-envs.js
@@ -0,0 +1,20 @@
+'use strict';
+
+// Env: A_SET_ENV_VAR=A_SET_ENV_VAR_VALUE B_SET_ENV_VAR=B_SET_ENV_VAR_VALUE
+
+require('../common');
+const assert = require('node:assert');
+const { describe, it } = require('node:test');
+
+
+// This test verifies that a test file that requires 'common' can set environment variables
+// via comments in the test file, similar to how we set flags via comments.
+// Ref: https://github.com/nodejs/node/issues/58179
+describe('env var via comment', () => {
+  it('should set env var A_SET_ENV_VAR', () => {
+    assert.strictEqual(process.env.A_SET_ENV_VAR, 'A_SET_ENV_VAR_VALUE');
+  });
+  it('should set env var B_SET_ENV_VAR', () => {
+    assert.strictEqual(process.env.B_SET_ENV_VAR, 'B_SET_ENV_VAR_VALUE');
+  });
+});
diff --git a/test/js/node/test/parallel/test-pipe-stream.js b/test/js/node/test/parallel/test-pipe-stream.js
new file mode 100644
index 000000000000..85560ffc98b4
--- /dev/null
+++ b/test/js/node/test/parallel/test-pipe-stream.js
@@ -0,0 +1,63 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const net = require('net');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+
+function test(clazz, cb) {
+  let have_ping = false;
+  let have_pong = false;
+
+  function check() {
+    assert.ok(have_ping);
+    assert.ok(have_pong);
+  }
+
+  function ping() {
+    const conn = new clazz();
+
+    conn.on('error', function(err) {
+      throw err;
+    });
+
+    conn.connect(common.PIPE, function() {
+      conn.write('PING', 'utf-8');
+    });
+
+    conn.on('data', common.mustCallAtLeast((data) => {
+      assert.strictEqual(data.toString(), 'PONG');
+      have_pong = true;
+      conn.destroy();
+    }));
+  }
+
+  function pong(conn) {
+    conn.on('error', function(err) {
+      throw err;
+    });
+
+    conn.on('data', common.mustCall((data) => {
+      assert.strictEqual(data.toString(), 'PING');
+      have_ping = true;
+      conn.write('PONG', 'utf-8');
+    }));
+
+    conn.on('close', function() {
+      server.close();
+    });
+  }
+
+  const server = net.Server();
+  server.listen(common.PIPE, ping);
+  server.on('connection', pong);
+  server.on('close', function() {
+    check();
+    cb && cb();
+  });
+}
+
+test(net.Stream, function() {
+  test(net.Socket);
+});
diff --git a/test/js/node/test/parallel/test-preload-worker.js b/test/js/node/test/parallel/test-preload-worker.js
new file mode 100644
index 000000000000..552698c2fce4
--- /dev/null
+++ b/test/js/node/test/parallel/test-preload-worker.js
@@ -0,0 +1,10 @@
+'use strict';
+
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+const worker = fixtures.path('worker-preload.js');
+const { exec } = require('child_process');
+const kNodeBinary = process.argv[0];
+
+
+exec(...common.escapePOSIXShell`"${kNodeBinary}" -r "${worker}" -pe "1+1"`, common.mustSucceed());
diff --git a/test/js/node/test/parallel/test-process-binding.js b/test/js/node/test/parallel/test-process-binding.js
new file mode 100644
index 000000000000..05bb0e6aa07d
--- /dev/null
+++ b/test/js/node/test/parallel/test-process-binding.js
@@ -0,0 +1,14 @@
+'use strict';
+// Flags: --expose-internals
+require('../common');
+const assert = require('assert');
+const { internalBinding } = require('internal/test/binding');
+
+assert.throws(
+  function() {
+    process.binding('test');
+  },
+  /No such module: test/
+);
+
+internalBinding('buffer');
diff --git a/test/js/node/test/parallel/test-process-exception-capture-should-abort-on-uncaught-setflagsfromstring.js b/test/js/node/test/parallel/test-process-exception-capture-should-abort-on-uncaught-setflagsfromstring.js
new file mode 100644
index 000000000000..de14177b45a6
--- /dev/null
+++ b/test/js/node/test/parallel/test-process-exception-capture-should-abort-on-uncaught-setflagsfromstring.js
@@ -0,0 +1,13 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const v8 = require('v8');
+
+assert.strictEqual(process.hasUncaughtExceptionCaptureCallback(), false);
+
+v8.setFlagsFromString('--abort-on-uncaught-exception');
+// This should make the process not crash even though the flag was passed.
+process.setUncaughtExceptionCaptureCallback(common.mustCall((err) => {
+  assert.strictEqual(err.message, 'foo');
+}));
+throw new Error('foo');
diff --git a/test/js/node/test/parallel/test-require-resolve-invalid-paths.js b/test/js/node/test/parallel/test-require-resolve-invalid-paths.js
new file mode 100644
index 000000000000..efe929d0c308
--- /dev/null
+++ b/test/js/node/test/parallel/test-require-resolve-invalid-paths.js
@@ -0,0 +1,18 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+
+// Test invalid `paths` entries: Ensure non-string entries throw an error
+{
+  const paths = [1, false, null, undefined, () => {}, {}];
+  paths.forEach((value) => {
+    assert.throws(
+      () => require.resolve('.', { paths: [value] }),
+      {
+        name: 'TypeError',
+        code: 'ERR_INVALID_ARG_TYPE',
+      }
+    );
+  });
+}
diff --git a/test/js/node/test/parallel/test-safe-get-env.js b/test/js/node/test/parallel/test-safe-get-env.js
new file mode 100644
index 000000000000..01bd6423b2c8
--- /dev/null
+++ b/test/js/node/test/parallel/test-safe-get-env.js
@@ -0,0 +1,19 @@
+'use strict';
+// Flags: --expose-internals
+
+require('../common');
+const assert = require('assert');
+const { internalBinding } = require('internal/test/binding');
+const { safeGetenv } = internalBinding('credentials');
+
+// Upstream note (joyeecheung): this test is not entirely useful. To properly
+// test this we could create a mismatch between the effective/real
+// group/user id of a Node.js process and see if the environment variables
+// are no longer available - but that might be tricky to set up reliably.
+
+for (const oneEnv in process.env) {
+  assert.strictEqual(
+    safeGetenv(oneEnv),
+    process.env[oneEnv]
+  );
+}
diff --git a/test/js/node/test/parallel/test-testpy-env-var-via-comment.js b/test/js/node/test/parallel/test-testpy-env-var-via-comment.js
new file mode 100644
index 000000000000..fea2e788e174
--- /dev/null
+++ b/test/js/node/test/parallel/test-testpy-env-var-via-comment.js
@@ -0,0 +1,26 @@
+'use strict';
+
+// Env: A_SET_ENV_VAR=A_SET_ENV_VAR_VALUE B_SET_ENV_VAR=B_SET_ENV_VAR_VALUE
+// Flags: --test-isolation=none --expose-internals
+
+require('../common');
+const assert = require('node:assert');
+const { describe, it } = require('node:test');
+
+
+// This test verifies that the Python test runner can set environment variables
+// via comments in the test file, similar to how we set flags via comments.
+// Ref: https://github.com/nodejs/node/issues/58179
+describe('testpy env var via comment', () => {
+  it('should set env var A_SET_ENV_VAR', () => {
+    assert.strictEqual(process.env.A_SET_ENV_VAR, 'A_SET_ENV_VAR_VALUE');
+  });
+  it('should set env var B_SET_ENV_VAR', () => {
+    assert.strictEqual(process.env.B_SET_ENV_VAR, 'B_SET_ENV_VAR_VALUE');
+  });
+
+  it('should interop with flags', () => {
+    const flag = require('internal/options').getOptionValue('--test-isolation');
+    assert.strictEqual(flag, 'none');
+  });
+});
diff --git a/test/js/node/test/parallel/test-url-fileurltopath.js b/test/js/node/test/parallel/test-url-fileurltopath.js
new file mode 100644
index 000000000000..e042e1aa6c22
--- /dev/null
+++ b/test/js/node/test/parallel/test-url-fileurltopath.js
@@ -0,0 +1,159 @@
+'use strict';
+const { isWindows } = require('../common');
+
+const { test } = require('node:test');
+const assert = require('node:assert');
+const url = require('node:url');
+
+test('invalid arguments', () => {
+  for (const arg of [null, undefined, 1, {}, true]) {
+    assert.throws(() => url.fileURLToPath(arg), {
+      code: 'ERR_INVALID_ARG_TYPE'
+    });
+  }
+});
+
+test('input must be a file URL', () => {
+  assert.throws(() => url.fileURLToPath('https://a/b/c'), {
+    code: 'ERR_INVALID_URL_SCHEME'
+  });
+});
+
+test('fileURLToPath with host', () => {
+  const withHost = new URL('file://host/a');
+
+  if (isWindows) {
+    assert.strictEqual(url.fileURLToPath(withHost), '\\\\host\\a');
+  } else {
+    assert.throws(() => url.fileURLToPath(withHost), {
+      code: 'ERR_INVALID_FILE_URL_HOST'
+    });
+  }
+});
+
+const windowsTestCases = [
+  // Lowercase ascii alpha
+  { path: 'C:\\foo', fileURL: 'file:///C:/foo' },
+  // Uppercase ascii alpha
+  { path: 'C:\\FOO', fileURL: 'file:///C:/FOO' },
+  // dir
+  { path: 'C:\\dir\\foo', fileURL: 'file:///C:/dir/foo' },
+  // trailing separator
+  { path: 'C:\\dir\\', fileURL: 'file:///C:/dir/' },
+  // dot
+  { path: 'C:\\foo.mjs', fileURL: 'file:///C:/foo.mjs' },
+  // space
+  { path: 'C:\\foo bar', fileURL: 'file:///C:/foo%20bar' },
+  // question mark
+  { path: 'C:\\foo?bar', fileURL: 'file:///C:/foo%3Fbar' },
+  // number sign
+  { path: 'C:\\foo#bar', fileURL: 'file:///C:/foo%23bar' },
+  // ampersand
+  { path: 'C:\\foo&bar', fileURL: 'file:///C:/foo&bar' },
+  // equals
+  { path: 'C:\\foo=bar', fileURL: 'file:///C:/foo=bar' },
+  // colon
+  { path: 'C:\\foo:bar', fileURL: 'file:///C:/foo:bar' },
+  // semicolon
+  { path: 'C:\\foo;bar', fileURL: 'file:///C:/foo;bar' },
+  // percent
+  { path: 'C:\\foo%bar', fileURL: 'file:///C:/foo%25bar' },
+  // backslash
+  { path: 'C:\\foo\\bar', fileURL: 'file:///C:/foo/bar' },
+  // backspace
+  { path: 'C:\\foo\bbar', fileURL: 'file:///C:/foo%08bar' },
+  // tab
+  { path: 'C:\\foo\tbar', fileURL: 'file:///C:/foo%09bar' },
+  // newline
+  { path: 'C:\\foo\nbar', fileURL: 'file:///C:/foo%0Abar' },
+  // carriage return
+  { path: 'C:\\foo\rbar', fileURL: 'file:///C:/foo%0Dbar' },
+  // latin1
+  { path: 'C:\\fóóbàr', fileURL: 'file:///C:/f%C3%B3%C3%B3b%C3%A0r' },
+  // Euro sign (BMP code point)
+  { path: 'C:\\€', fileURL: 'file:///C:/%E2%82%AC' },
+  // Rocket emoji (non-BMP code point)
+  { path: 'C:\\🚀', fileURL: 'file:///C:/%F0%9F%9A%80' },
+  // UNC path (see https://docs.microsoft.com/en-us/archive/blogs/ie/file-uris-in-windows)
+  { path: '\\\\nas\\My Docs\\File.doc', fileURL: 'file://nas/My%20Docs/File.doc' },
+];
+
+const posixTestCases = [
+  // Lowercase ascii alpha
+  { path: '/foo', fileURL: 'file:///foo' },
+  // Uppercase ascii alpha
+  { path: '/FOO', fileURL: 'file:///FOO' },
+  // dir
+  { path: '/dir/foo', fileURL: 'file:///dir/foo' },
+  // trailing separator
+  { path: '/dir/', fileURL: 'file:///dir/' },
+  // dot
+  { path: '/foo.mjs', fileURL: 'file:///foo.mjs' },
+  // space
+  { path: '/foo bar', fileURL: 'file:///foo%20bar' },
+  // question mark
+  { path: '/foo?bar', fileURL: 'file:///foo%3Fbar' },
+  // number sign
+  { path: '/foo#bar', fileURL: 'file:///foo%23bar' },
+  // ampersand
+  { path: '/foo&bar', fileURL: 'file:///foo&bar' },
+  // equals
+  { path: '/foo=bar', fileURL: 'file:///foo=bar' },
+  // colon
+  { path: '/foo:bar', fileURL: 'file:///foo:bar' },
+  // semicolon
+  { path: '/foo;bar', fileURL: 'file:///foo;bar' },
+  // percent
+  { path: '/foo%bar', fileURL: 'file:///foo%25bar' },
+  // backslash
+  { path: '/foo\\bar', fileURL: 'file:///foo%5Cbar' },
+  // backspace
+  { path: '/foo\bbar', fileURL: 'file:///foo%08bar' },
+  // tab
+  { path: '/foo\tbar', fileURL: 'file:///foo%09bar' },
+  // newline
+  { path: '/foo\nbar', fileURL: 'file:///foo%0Abar' },
+  // carriage return
+  { path: '/foo\rbar', fileURL: 'file:///foo%0Dbar' },
+  // latin1
+  { path: '/fóóbàr', fileURL: 'file:///f%C3%B3%C3%B3b%C3%A0r' },
+  // Euro sign (BMP code point)
+  { path: '/€', fileURL: 'file:///%E2%82%AC' },
+  // Rocket emoji (non-BMP code point)
+  { path: '/🚀', fileURL: 'file:///%F0%9F%9A%80' },
+];
+
+test('fileURLToPath with windows path', { skip: !isWindows }, () => {
+
+  for (const { path, fileURL } of windowsTestCases) {
+    const fromString = url.fileURLToPath(fileURL, { windows: true });
+    assert.strictEqual(fromString, path);
+    const fromURL = url.fileURLToPath(new URL(fileURL), { windows: true });
+    assert.strictEqual(fromURL, path);
+  }
+});
+
+test('fileURLToPath with posix path', { skip: isWindows }, () => {
+  for (const { path, fileURL } of posixTestCases) {
+    const fromString = url.fileURLToPath(fileURL, { windows: false });
+    assert.strictEqual(fromString, path);
+    const fromURL = url.fileURLToPath(new URL(fileURL), { windows: false });
+    assert.strictEqual(fromURL, path);
+  }
+});
+
+const defaultTestCases = isWindows ? windowsTestCases : posixTestCases;
+
+test('options is null', () => {
+  const whenNullActual = url.fileURLToPath(new URL(defaultTestCases[0].fileURL), null);
+  assert.strictEqual(whenNullActual, defaultTestCases[0].path);
+});
+
+test('defaultTestCases', () => {
+  for (const { path, fileURL } of defaultTestCases) {
+    const fromString = url.fileURLToPath(fileURL);
+    assert.strictEqual(fromString, path);
+    const fromURL = url.fileURLToPath(new URL(fileURL));
+    assert.strictEqual(fromURL, path);
+  }
+});
diff --git a/test/js/node/test/parallel/test-url-invalid-file-url-path-input.js b/test/js/node/test/parallel/test-url-invalid-file-url-path-input.js
new file mode 100644
index 000000000000..f47df380d7ef
--- /dev/null
+++ b/test/js/node/test/parallel/test-url-invalid-file-url-path-input.js
@@ -0,0 +1,25 @@
+'use strict';
+
+// This tests that url.fileURLToPath() throws ERR_INVALID_FILE_URL_PATH
+// for invalid file URL paths along with the input property.
+
+const { isWindows } = require('../common');
+const assert = require('assert');
+const url = require('url');
+
+const inputs = [];
+
+if (isWindows) {
+  inputs.push('file:///C:/a%2F/', 'file:///C:/a%5C/', 'file:///?:/');
+} else {
+  inputs.push('file:///a%2F/');
+}
+
+for (const input of inputs) {
+  assert.throws(() => url.fileURLToPath(input), (err) => {
+    assert.strictEqual(err.code, 'ERR_INVALID_FILE_URL_PATH');
+    assert(err.input instanceof URL);
+    assert.strictEqual(err.input.href, input);
+    return true;
+  });
+}
diff --git a/test/js/node/test/parallel/test-url-parse-invalid-input.js b/test/js/node/test/parallel/test-url-parse-invalid-input.js
index 8f8a4d40f8c0..d14bce96d684 100644
--- a/test/js/node/test/parallel/test-url-parse-invalid-input.js
+++ b/test/js/node/test/parallel/test-url-parse-invalid-input.js
@@ -96,8 +96,7 @@ if (common.hasIntl) {
   // Warning should only happen once per process.
   common.expectWarning({
     DeprecationWarning: {
-      // NOTE: this warning is noisy and annoying. We've disabled it intentionally.
-      // DEP0169: '`url.parse()` behavior is not standardized and prone to errors that have security implications. Use the WHATWG URL API instead. CVEs are not issued for `url.parse()` vulnerabilities.',
+      DEP0169: '`url.parse()` behavior is not standardized and prone to errors that have security implications. Use the WHATWG URL API instead. CVEs are not issued for `url.parse()` vulnerabilities.',
       DEP0170: `The URL ${badURLs[0]} is invalid. Future versions of Node.js will throw an error.`,
     },
   });
diff --git a/test/js/node/test/parallel/test-url-pathtofileurl.js b/test/js/node/test/parallel/test-url-pathtofileurl.js
new file mode 100644
index 000000000000..01d27f2b736d
--- /dev/null
+++ b/test/js/node/test/parallel/test-url-pathtofileurl.js
@@ -0,0 +1,233 @@
+'use strict';
+
+const { isWindows } = require('../common');
+const assert = require('assert');
+const url = require('url');
+
+{
+  const fileURL = url.pathToFileURL('test/').href;
+  assert.ok(fileURL.startsWith('file:///'));
+  assert.ok(fileURL.endsWith('/'));
+}
+
+{
+  const fileURL = url.pathToFileURL('test\\').href;
+  assert.ok(fileURL.startsWith('file:///'));
+  assert.match(fileURL, isWindows ? /\/$/ : /%5C$/);
+}
+
+{
+  const fileURL = url.pathToFileURL('test/%').href;
+  assert.ok(fileURL.includes('%25'));
+}
+
+{
+  assert.throws(() => {
+    url.pathToFileURL('\\\\exa mple\\share\\file.txt', { windows: true });
+  }, {
+    code: 'ERR_INVALID_URL',
+  });
+}
+
+{
+  if (isWindows) {
+    // UNC path: \\server\share\resource
+
+    // Missing server:
+    assert.throws(() => url.pathToFileURL('\\\\\\no-server'), {
+      code: 'ERR_INVALID_ARG_VALUE',
+    });
+
+    // Missing share or resource:
+    assert.throws(() => url.pathToFileURL('\\\\host'), {
+      code: 'ERR_INVALID_ARG_VALUE',
+    });
+
+    // Regression test for direct String.prototype.startsWith call
+    assert.throws(() => url.pathToFileURL([
+      '\\\\',
+      { [Symbol.toPrimitive]: () => 'blep\\blop' },
+    ]), {
+      code: 'ERR_INVALID_ARG_TYPE',
+    });
+    assert.throws(() => url.pathToFileURL(['\\\\', 'blep\\blop']), {
+      code: 'ERR_INVALID_ARG_TYPE',
+    });
+    assert.throws(() => url.pathToFileURL({
+      [Symbol.toPrimitive]: () => '\\\\blep\\blop',
+    }), {
+      code: 'ERR_INVALID_ARG_TYPE',
+    });
+
+  } else {
+    // UNC paths on posix are considered a single path that has backslashes:
+    const fileURL = url.pathToFileURL('\\\\nas\\share\\path.txt').href;
+    assert.match(fileURL, /file:\/\/.+%5C%5Cnas%5Cshare%5Cpath\.txt$/);
+  }
+}
+
+const windowsTestCases = [
+  // Lowercase ascii alpha
+  { path: 'C:\\foo', expected: 'file:///C:/foo' },
+  // Uppercase ascii alpha
+  { path: 'C:\\FOO', expected: 'file:///C:/FOO' },
+  // dir
+  { path: 'C:\\dir\\foo', expected: 'file:///C:/dir/foo' },
+  // trailing separator
+  { path: 'C:\\dir\\', expected: 'file:///C:/dir/' },
+  // dot
+  { path: 'C:\\foo.mjs', expected: 'file:///C:/foo.mjs' },
+  // space
+  { path: 'C:\\foo bar', expected: 'file:///C:/foo%20bar' },
+  // question mark
+  { path: 'C:\\foo?bar', expected: 'file:///C:/foo%3Fbar' },
+  // number sign
+  { path: 'C:\\foo#bar', expected: 'file:///C:/foo%23bar' },
+  // ampersand
+  { path: 'C:\\foo&bar', expected: 'file:///C:/foo&bar' },
+  // equals
+  { path: 'C:\\foo=bar', expected: 'file:///C:/foo=bar' },
+  // colon
+  { path: 'C:\\foo:bar', expected: 'file:///C:/foo:bar' },
+  // semicolon
+  { path: 'C:\\foo;bar', expected: 'file:///C:/foo;bar' },
+  // percent
+  { path: 'C:\\foo%bar', expected: 'file:///C:/foo%25bar' },
+  // backslash
+  { path: 'C:\\foo\\bar', expected: 'file:///C:/foo/bar' },
+  // backspace
+  { path: 'C:\\foo\bbar', expected: 'file:///C:/foo%08bar' },
+  // tab
+  { path: 'C:\\foo\tbar', expected: 'file:///C:/foo%09bar' },
+  // newline
+  { path: 'C:\\foo\nbar', expected: 'file:///C:/foo%0Abar' },
+  // carriage return
+  { path: 'C:\\foo\rbar', expected: 'file:///C:/foo%0Dbar' },
+  // latin1
+  { path: 'C:\\fóóbàr', expected: 'file:///C:/f%C3%B3%C3%B3b%C3%A0r' },
+  // Euro sign (BMP code point)
+  { path: 'C:\\€', expected: 'file:///C:/%E2%82%AC' },
+  // Rocket emoji (non-BMP code point)
+  { path: 'C:\\🚀', expected: 'file:///C:/%F0%9F%9A%80' },
+  // caret
+  { path: 'C:\\foo^bar', expected: 'file:///C:/foo%5Ebar' },
+  // left bracket
+  { path: 'C:\\foo[bar', expected: 'file:///C:/foo%5Bbar' },
+  // right bracket
+  { path: 'C:\\foo]bar', expected: 'file:///C:/foo%5Dbar' },
+  // Local extended path
+  { path: '\\\\?\\C:\\path\\to\\file.txt', expected: 'file:///C:/path/to/file.txt' },
+  // UNC path (see https://docs.microsoft.com/en-us/archive/blogs/ie/file-uris-in-windows)
+  { path: '\\\\nas\\My Docs\\File.doc', expected: 'file://nas/My%20Docs/File.doc' },
+  // Extended UNC path
+  { path: '\\\\?\\UNC\\server\\share\\folder\\file.txt', expected: 'file://server/share/folder/file.txt' },
+];
+const alphabet = String.fromCharCode(...Array.from({ length: 26 }, (_, i) => 'a'.charCodeAt() + i));
+const posixTestCases = [
+  // Lowercase ascii alpha
+  { path: '/foo', expected: 'file:///foo' },
+  // Uppercase ascii alpha
+  { path: '/FOO', expected: 'file:///FOO' },
+  // dir
+  { path: '/dir/foo', expected: 'file:///dir/foo' },
+  // trailing separator
+  { path: '/dir/', expected: 'file:///dir/' },
+  // dot
+  { path: '/foo.mjs', expected: 'file:///foo.mjs' },
+  // space
+  { path: '/foo bar', expected: 'file:///foo%20bar' },
+  // question mark
+  { path: '/foo?bar', expected: 'file:///foo%3Fbar' },
+  // number sign
+  { path: '/foo#bar', expected: 'file:///foo%23bar' },
+  // ampersand
+  { path: '/foo&bar', expected: 'file:///foo&bar' },
+  // equals
+  { path: '/foo=bar', expected: 'file:///foo=bar' },
+  // colon
+  { path: '/foo:bar', expected: 'file:///foo:bar' },
+  // semicolon
+  { path: '/foo;bar', expected: 'file:///foo;bar' },
+  // percent
+  { path: '/foo%bar', expected: 'file:///foo%25bar' },
+  // backslash
+  { path: '/foo\\bar', expected: 'file:///foo%5Cbar' },
+  // backspace
+  { path: '/foo\bbar', expected: 'file:///foo%08bar' },
+  // tab
+  { path: '/foo\tbar', expected: 'file:///foo%09bar' },
+  // newline
+  { path: '/foo\nbar', expected: 'file:///foo%0Abar' },
+  // carriage return
+  { path: '/foo\rbar', expected: 'file:///foo%0Dbar' },
+  // latin1
+  { path: '/fóóbàr', expected: 'file:///f%C3%B3%C3%B3b%C3%A0r' },
+  // Euro sign (BMP code point)
+  { path: '/€', expected: 'file:///%E2%82%AC' },
+  // Rocket emoji (non-BMP code point)
+  { path: '/🚀', expected: 'file:///%F0%9F%9A%80' },
+  // "unsafe" chars
+  { path: '/foo\r\n\t<>"#%{}|^[\\~]`?bar', expected: 'file:///foo%0D%0A%09%3C%3E%22%23%25%7B%7D%7C%5E%5B%5C%7E%5D%60%3Fbar' },
+  // All of the 16-bit UTF-16 chars
+  {
+    path: `/${Array.from({ length: 0x7FFF }, (_, i) => String.fromCharCode(i)).join('')}`,
+    expected: `file:///${
+      Array.from({ length: 0x21 }, (_, i) => `%${i.toString(16).toUpperCase().padStart(2, '0')}`).join('')
+    }!%22%23$%25&'()*+,-./0123456789:;%3C=%3E%3F@${
+      alphabet.toUpperCase()
+    }%5B%5C%5D%5E_%60${alphabet}%7B%7C%7D%7E%7F${
+      Array.from({ length: 0x800 - 0x80 }, (_, i) => `%${
+        (Math.floor((i - 0x80) / 0x40) + 0xC4).toString(16).toUpperCase()
+      }%${
+        ((i % 0x40) + 0x80).toString(16).toUpperCase()
+      }`).join('')
+    }${
+      Array.from({ length: 0x7FFF - 0x800 }, (_, i) => i + 0x800).map((i) => `%E${
+        (i >> 12).toString(16).toUpperCase()
+      }%${
+        (((i >> 6) % 0x40) + 0x80).toString(16).toUpperCase()
+      }%${
+        ((i % 0x40) + 0x80).toString(16).toUpperCase()
+      }`).join('')
+    }`
+  },
+  // Trying with some pair of 16-bit surrogate pseudo-characters
+  { path: `/${String.fromCodePoint(0x1F303)}`, expected: 'file:///%F0%9F%8C%83' },
+];
+
+for (const { path, expected } of windowsTestCases) {
+  const actual = url.pathToFileURL(path, { windows: true }).href;
+  assert.strictEqual(actual, expected);
+}
+
+for (const { path, expected } of posixTestCases) {
+  const actual = url.pathToFileURL(path, { windows: false }).href;
+  assert.strictEqual(actual, expected);
+}
+
+const testCases = isWindows ? windowsTestCases : posixTestCases;
+
+// Test when `options` is null
+const whenNullActual = url.pathToFileURL(testCases[0].path, null);
+assert.strictEqual(whenNullActual.href, testCases[0].expected);
+
+for (const { path, expected } of testCases) {
+  const actual = url.pathToFileURL(path).href;
+  assert.strictEqual(actual, expected);
+}
+
+// Test for non-string parameter
+{
+  for (const badPath of [
+    undefined, null, true, 42, 42n, Symbol('42'), NaN, {}, [], () => {},
+    Promise.resolve('foo'),
+    new Date(),
+    new String('notPrimitive'),
+    { toString() { return 'amObject'; } },
+    { [Symbol.toPrimitive]: (hint) => 'amObject' },
+  ]) {
+    assert.throws(() => url.pathToFileURL(badPath), {
+      code: 'ERR_INVALID_ARG_TYPE',
+    });
+  }
+}
diff --git a/test/js/node/test/parallel/test-urlpattern.js b/test/js/node/test/parallel/test-urlpattern.js
new file mode 100644
index 000000000000..96c431f5b87f
--- /dev/null
+++ b/test/js/node/test/parallel/test-urlpattern.js
@@ -0,0 +1,28 @@
+'use strict';
+
+require('../common');
+
+const assert = require('assert');
+const { URLPattern } = require('url');
+
+// Verify that if an error is thrown while accessing any of the
+// init options, the error is appropriately propagated.
+assert.throws(() => {
+  new URLPattern({
+    get protocol() {
+      throw new Error('boom');
+    }
+  });
+}, {
+  message: 'boom',
+});
+
+// Verify that if an error is thrown while accessing the ignoreCase
+// option, the error is appropriately propagated.
+assert.throws(() => {
+  new URLPattern({}, { get ignoreCase() {
+    throw new Error('boom');
+  } });
+}, {
+  message: 'boom'
+});
diff --git a/test/js/node/test/parallel/test-util-isDeepStrictEqual.js b/test/js/node/test/parallel/test-util-isDeepStrictEqual.js
new file mode 100644
index 000000000000..458d1446aea5
--- /dev/null
+++ b/test/js/node/test/parallel/test-util-isDeepStrictEqual.js
@@ -0,0 +1,157 @@
+'use strict';
+
+// Confirm functionality of `util.isDeepStrictEqual()`.
+
+require('../common');
+
+const assert = require('assert');
+const util = require('util');
+const { test } = require('node:test');
+
+function utilIsDeepStrict(a, b) {
+  assert.strictEqual(util.isDeepStrictEqual(a, b), true);
+  assert.strictEqual(util.isDeepStrictEqual(b, a), true);
+}
+
+function notUtilIsDeepStrict(a, b) {
+  assert.strictEqual(util.isDeepStrictEqual(a, b), false);
+  assert.strictEqual(util.isDeepStrictEqual(b, a), false);
+}
+
+// Handle boxed primitives
+{
+  const boxedString = new String('test');
+  const boxedSymbol = Object(Symbol());
+  notUtilIsDeepStrict(new Boolean(true), Object(false));
+  notUtilIsDeepStrict(Object(true), new Number(1));
+  notUtilIsDeepStrict(new Number(2), new Number(1));
+  notUtilIsDeepStrict(boxedSymbol, Object(Symbol()));
+  notUtilIsDeepStrict(boxedSymbol, {});
+  utilIsDeepStrict(boxedSymbol, boxedSymbol);
+  utilIsDeepStrict(Object(true), Object(true));
+  utilIsDeepStrict(Object(2), Object(2));
+  utilIsDeepStrict(boxedString, Object('test'));
+  boxedString.slow = true;
+  notUtilIsDeepStrict(boxedString, Object('test'));
+  boxedSymbol.slow = true;
+  notUtilIsDeepStrict(boxedSymbol, {});
+  utilIsDeepStrict(Object(BigInt(1)), Object(BigInt(1)));
+  notUtilIsDeepStrict(Object(BigInt(1)), Object(BigInt(2)));
+
+  const booleanish = new Boolean(true);
+  Object.defineProperty(booleanish, Symbol.toStringTag, { value: 'String' });
+  Object.setPrototypeOf(booleanish, String.prototype);
+  notUtilIsDeepStrict(booleanish, new String('true'));
+
+  const numberish = new Number(42);
+  Object.defineProperty(numberish, Symbol.toStringTag, { value: 'String' });
+  Object.setPrototypeOf(numberish, String.prototype);
+  notUtilIsDeepStrict(numberish, new String('42'));
+
+  const stringish = new String('0');
+  Object.defineProperty(stringish, Symbol.toStringTag, { value: 'Number' });
+  Object.setPrototypeOf(stringish, Number.prototype);
+  notUtilIsDeepStrict(stringish, new Number(0));
+
+  const bigintish = new Object(BigInt(42));
+  Object.defineProperty(bigintish, Symbol.toStringTag, { value: 'String' });
+  Object.setPrototypeOf(bigintish, String.prototype);
+  notUtilIsDeepStrict(bigintish, new String('42'));
+
+  const symbolish = new Object(Symbol('fhqwhgads'));
+  Object.defineProperty(symbolish, Symbol.toStringTag, { value: 'String' });
+  Object.setPrototypeOf(symbolish, String.prototype);
+  notUtilIsDeepStrict(symbolish, new String('fhqwhgads'));
+}
+
+// Handle symbols (enumerable only)
+{
+  const symbol1 = Symbol();
+  const obj1 = { [symbol1]: 1 };
+  const obj2 = { [symbol1]: 1 };
+  const obj3 = { [Symbol()]: 1 };
+  const obj4 = { };
+  // Add a non enumerable symbol as well. It is going to be ignored!
+  Object.defineProperty(obj2, Symbol(), { value: 1 });
+  Object.defineProperty(obj4, symbol1, { value: 1 });
+  notUtilIsDeepStrict(obj1, obj3);
+  utilIsDeepStrict(obj1, obj2);
+  notUtilIsDeepStrict(obj1, obj4);
+  // TypedArrays have a fast path. Test for this as well.
+  const a = new Uint8Array(4);
+  const b = new Uint8Array(4);
+  a[symbol1] = true;
+  b[symbol1] = false;
+  notUtilIsDeepStrict(a, b);
+  b[symbol1] = true;
+  utilIsDeepStrict(a, b);
+  // The same as TypedArrays is valid for boxed primitives
+  const boxedStringA = new String('test');
+  const boxedStringB = new String('test');
+  boxedStringA[symbol1] = true;
+  notUtilIsDeepStrict(boxedStringA, boxedStringB);
+  boxedStringA[symbol1] = true;
+  utilIsDeepStrict(a, b);
+}
+
+// Handle `skipPrototype` for isDeepStrictEqual
+{
+  test('util.isDeepStrictEqual with skipPrototype', () => {
+    function ClassA(value) { this.value = value; }
+
+    function ClassB(value) { this.value = value; }
+
+    const objA = new ClassA(42);
+    const objB = new ClassB(42);
+
+    assert.strictEqual(util.isDeepStrictEqual(objA, objB), false);
+    assert.strictEqual(util.isDeepStrictEqual(objA, objB, true), true);
+
+    const objC = new ClassB(99);
+    assert.strictEqual(util.isDeepStrictEqual(objA, objC, true), false);
+
+    const nestedA = { obj: new ClassA('test'), num: 123 };
+    const nestedB = { obj: new ClassB('test'), num: 123 };
+
+    assert.strictEqual(util.isDeepStrictEqual(nestedA, nestedB), false);
+    assert.strictEqual(util.isDeepStrictEqual(nestedA, nestedB, true), true);
+
+    const uint8Array = new Uint8Array([1, 2, 3]);
+    const buffer = Buffer.from([1, 2, 3]);
+
+    assert.strictEqual(util.isDeepStrictEqual(uint8Array, buffer), false);
+    assert.strictEqual(util.isDeepStrictEqual(uint8Array, buffer, true), true);
+  });
+
+  test('util.isDeepStrictEqual skipPrototype with complex scenarios', () => {
+    class Parent { constructor(x) { this.x = x; } }
+    class Child extends Parent { constructor(x, y) { super(x); this.y = y; } }
+
+    function LegacyParent(x) { this.x = x; }
+
+    function LegacyChild(x, y) { this.x = x; this.y = y; }
+
+    const modernParent = new Parent(1);
+    const legacyParent = new LegacyParent(1);
+
+    assert.strictEqual(util.isDeepStrictEqual(modernParent, legacyParent), false);
+    assert.strictEqual(util.isDeepStrictEqual(modernParent, legacyParent, true), true);
+
+    const modern = new Child(1, 2);
+    const legacy = new LegacyChild(1, 2);
+
+    assert.strictEqual(util.isDeepStrictEqual(modern, legacy), false);
+    assert.strictEqual(util.isDeepStrictEqual(modern, legacy, true), true);
+
+    const literal = { name: 'test', values: [1, 2, 3] };
+    function Constructor(name, values) { this.name = name; this.values = values; }
+    const constructed = new Constructor('test', [1, 2, 3]);
+
+    assert.strictEqual(util.isDeepStrictEqual(literal, constructed), false);
+    assert.strictEqual(util.isDeepStrictEqual(literal, constructed, true), true);
+
+    assert.strictEqual(util.isDeepStrictEqual(literal, constructed, false), false);
+    assert.strictEqual(util.isDeepStrictEqual(literal, constructed, null), false);
+    assert.strictEqual(util.isDeepStrictEqual(literal, constructed, undefined), false);
+  });
+}
diff --git a/test/js/node/test/parallel/test-uv-errmap.js b/test/js/node/test/parallel/test-uv-errmap.js
new file mode 100644
index 000000000000..6a077551b63d
--- /dev/null
+++ b/test/js/node/test/parallel/test-uv-errmap.js
@@ -0,0 +1,24 @@
+// Flags: --expose-internals
+'use strict';
+
+require('../common');
+const assert = require('assert');
+const {
+  getSystemErrorMap,
+  _errnoException
+} = require('util');
+
+const { internalBinding } = require('internal/test/binding');
+const uv = internalBinding('uv');
+const uvKeys = Object.keys(uv);
+
+const errMap = getSystemErrorMap();
+
+uvKeys.forEach((key) => {
+  if (!key.startsWith('UV_'))
+    return;
+
+  const err = _errnoException(uv[key]);
+  const name = uv.errname(uv[key]);
+  assert.strictEqual(errMap.get(err.errno)[0], name);
+});
diff --git a/test/js/node/test/parallel/test-uv-errno.js b/test/js/node/test/parallel/test-uv-errno.js
new file mode 100644
index 000000000000..1ca0ee6c759d
--- /dev/null
+++ b/test/js/node/test/parallel/test-uv-errno.js
@@ -0,0 +1,60 @@
+// Flags: --expose-internals
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const {
+  getSystemErrorName,
+  getSystemErrorMessage,
+  _errnoException
+} = require('util');
+
+const { internalBinding } = require('internal/test/binding');
+const uv = internalBinding('uv');
+const keys = Object.keys(uv);
+
+assert.strictEqual(uv.errname(-111111), 'Unknown system error -111111');
+assert.strictEqual(uv.getErrorMessage(-111111), 'Unknown system error -111111');
+
+keys.forEach((key) => {
+  if (!key.startsWith('UV_'))
+    return;
+
+  const err = _errnoException(uv[key], 'test');
+  const name = uv.errname(uv[key]);
+  assert.strictEqual(getSystemErrorName(uv[key]), name);
+  assert.notStrictEqual(getSystemErrorMessage(uv[key]),
+                        `Unknown system error ${key}`);
+  assert.strictEqual(err.code, name);
+  assert.strictEqual(err.code, getSystemErrorName(err.errno));
+  assert.strictEqual(err.message, `test ${name}`);
+});
+
+function runTest(fn) {
+  ['test', {}, []].forEach((err) => {
+    assert.throws(
+      () => fn(err),
+      {
+        code: 'ERR_INVALID_ARG_TYPE',
+        name: 'TypeError',
+        message: 'The "err" argument must be of type number.' +
+                 common.invalidArgTypeHelper(err)
+      });
+  });
+
+  [0, 1, Infinity, -Infinity, NaN].forEach((err) => {
+    assert.throws(
+      () => fn(err),
+      {
+        code: 'ERR_OUT_OF_RANGE',
+        name: 'RangeError',
+        message: 'The value of "err" is out of range. ' +
+                 'It must be a negative integer. ' +
+                 `Received ${err}`
+      });
+  });
+}
+
+runTest(_errnoException);
+runTest(getSystemErrorName);
+runTest(getSystemErrorMessage);
diff --git a/test/js/node/test/parallel/test-v8-startup-snapshot-api.js b/test/js/node/test/parallel/test-v8-startup-snapshot-api.js
new file mode 100644
index 000000000000..c3738911540f
--- /dev/null
+++ b/test/js/node/test/parallel/test-v8-startup-snapshot-api.js
@@ -0,0 +1,26 @@
+'use strict';
+
+require('../common');
+const assert = require('assert');
+
+const {
+  isBuildingSnapshot,
+  addSerializeCallback,
+  addDeserializeCallback,
+  setDeserializeMainFunction
+} = require('v8').startupSnapshot;
+
+// This test verifies that the v8.startupSnapshot APIs are not available when
+// it is not building snapshot.
+
+assert(!isBuildingSnapshot());
+
+assert.throws(() => addSerializeCallback(() => {}), {
+  code: 'ERR_NOT_BUILDING_SNAPSHOT',
+});
+assert.throws(() => addDeserializeCallback(() => {}), {
+  code: 'ERR_NOT_BUILDING_SNAPSHOT',
+});
+assert.throws(() => setDeserializeMainFunction(() => {}), {
+  code: 'ERR_NOT_BUILDING_SNAPSHOT',
+});
diff --git a/test/js/node/test/parallel/test-v8-stats.js b/test/js/node/test/parallel/test-v8-stats.js
new file mode 100644
index 000000000000..5ee4c5aeb31a
--- /dev/null
+++ b/test/js/node/test/parallel/test-v8-stats.js
@@ -0,0 +1,66 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const v8 = require('v8');
+
+const s = v8.getHeapStatistics();
+const keys = [
+  'does_zap_garbage',
+  'external_memory',
+  'heap_size_limit',
+  'malloced_memory',
+  'number_of_detached_contexts',
+  'number_of_native_contexts',
+  'peak_malloced_memory',
+  'total_allocated_bytes',
+  'total_available_size',
+  'total_global_handles_size',
+  'total_heap_size',
+  'total_heap_size_executable',
+  'total_physical_size',
+  'used_global_handles_size',
+  'used_heap_size'];
+assert.deepStrictEqual(Object.keys(s).sort(), keys);
+keys.forEach(function(key) {
+  assert.strictEqual(typeof s[key], 'number');
+});
+
+
+const heapCodeStatistics = v8.getHeapCodeStatistics();
+const heapCodeStatisticsKeys = [
+  'bytecode_and_metadata_size',
+  'code_and_metadata_size',
+  'cpu_profiler_metadata_size',
+  'external_script_source_size'];
+assert.deepStrictEqual(Object.keys(heapCodeStatistics).sort(),
+                       heapCodeStatisticsKeys);
+heapCodeStatisticsKeys.forEach(function(key) {
+  assert.strictEqual(typeof heapCodeStatistics[key], 'number');
+});
+
+
+const expectedHeapSpaces = [
+  'code_large_object_space',
+  'code_space',
+  'large_object_space',
+  'new_large_object_space',
+  'new_space',
+  'old_space',
+  'read_only_space',
+  'shared_large_object_space',
+  'shared_space',
+  'shared_trusted_large_object_space',
+  'shared_trusted_space',
+  'trusted_large_object_space',
+  'trusted_space',
+];
+const heapSpaceStatistics = v8.getHeapSpaceStatistics();
+const actualHeapSpaceNames = heapSpaceStatistics.map((s) => s.space_name);
+assert.deepStrictEqual(actualHeapSpaceNames.sort(), expectedHeapSpaces.sort());
+heapSpaceStatistics.forEach((heapSpace) => {
+  assert.strictEqual(typeof heapSpace.space_name, 'string');
+  assert.strictEqual(typeof heapSpace.space_size, 'number');
+  assert.strictEqual(typeof heapSpace.space_used_size, 'number');
+  assert.strictEqual(typeof heapSpace.space_available_size, 'number');
+  assert.strictEqual(typeof heapSpace.physical_space_size, 'number');
+});
diff --git a/test/js/node/test/parallel/test-v8-version-tag.js b/test/js/node/test/parallel/test-v8-version-tag.js
new file mode 100644
index 000000000000..ec57b82fac6d
--- /dev/null
+++ b/test/js/node/test/parallel/test-v8-version-tag.js
@@ -0,0 +1,19 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const v8 = require('v8');
+
+const versionTag1 = v8.cachedDataVersionTag();
+assert.strictEqual(typeof versionTag1, 'number');
+assert.strictEqual(v8.cachedDataVersionTag(), versionTag1);
+
+// The value returned by v8.cachedDataVersionTag() is derived from the V8
+// version, command-line flags, and detected CPU features. Test that the value
+// does indeed update when flags are toggled.
+v8.setFlagsFromString('--allow_natives_syntax');
+
+const versionTag2 = v8.cachedDataVersionTag();
+assert.strictEqual(typeof versionTag2, 'number');
+assert.strictEqual(v8.cachedDataVersionTag(), versionTag2);
+
+assert.notStrictEqual(versionTag1, versionTag2);
diff --git a/test/js/node/test/parallel/test-warn-tls-common-deprecation.js b/test/js/node/test/parallel/test-warn-tls-common-deprecation.js
new file mode 100644
index 000000000000..00ce2690a956
--- /dev/null
+++ b/test/js/node/test/parallel/test-warn-tls-common-deprecation.js
@@ -0,0 +1,11 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto) common.skip('missing crypto');
+
+// _tls_common is deprecated.
+
+common.expectWarning('DeprecationWarning',
+                     'The _tls_common module is deprecated. Use `node:tls` instead.', 'DEP0192');
+
+require('_tls_common');
diff --git a/test/js/node/test/parallel/test-warn-tls-wrap-deprecation.js b/test/js/node/test/parallel/test-warn-tls-wrap-deprecation.js
new file mode 100644
index 000000000000..53fc1e69830f
--- /dev/null
+++ b/test/js/node/test/parallel/test-warn-tls-wrap-deprecation.js
@@ -0,0 +1,11 @@
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto) common.skip('missing crypto');
+
+// _tls_wrap is deprecated.
+
+common.expectWarning('DeprecationWarning',
+                     'The _tls_wrap module is deprecated. Use `node:tls` instead.', 'DEP0192');
+
+require('_tls_wrap');
diff --git a/test/js/node/test/parallel/test-watch-mode-kill-signal-default.mjs b/test/js/node/test/parallel/test-watch-mode-kill-signal-default.mjs
new file mode 100644
index 000000000000..c5323283be8b
--- /dev/null
+++ b/test/js/node/test/parallel/test-watch-mode-kill-signal-default.mjs
@@ -0,0 +1,67 @@
+// Test that the kill signal sent by --watch defaults to SIGTERM.
+
+import '../common/index.mjs';
+import assert from 'node:assert';
+import { writeFileSync } from 'node:fs';
+import { spawn } from 'node:child_process';
+import { once } from 'node:events';
+import tmpdir from '../common/tmpdir.js';
+import fixtures from '../common/fixtures.js';
+import { skipIfNoWatchModeSignals } from '../common/watch.js';
+
+skipIfNoWatchModeSignals();
+
+tmpdir.refresh();
+const indexPath = tmpdir.resolve('kill-signal-for-watch.js');
+const indexContents = fixtures.readSync('kill-signal-for-watch.js', 'utf8');
+writeFileSync(indexPath, indexContents);
+
+const child = spawn(
+  process.execPath,
+  ['--watch', indexPath],
+  {
+    cwd: tmpdir.path,
+    stdio: ['inherit', 'pipe', 'inherit', 'ipc'],
+  }
+);
+
+let stdout = '';
+let firstGrandchildPid;
+child.stdout.on('data', (data) => {
+  const dataStr = data.toString();
+  console.log(`[STDOUT] ${dataStr}`);
+  stdout += `${dataStr}`;
+  const match = dataStr.match(/__(SIGINT|SIGTERM) received__ (\d+)/);
+  if (match && match[2] === firstGrandchildPid) {
+    console.log(`[PARENT] Sending kill signal to watcher process: ${child.pid}`);
+    child.kill();
+  }
+});
+
+// After the write triggers a restart of the grandchild, the newly spawned second
+// grandchild can post another 'script ready' message before the stdout from the first
+// grandchild is relayed by the watcher and processed by this parent process to kill
+// the watcher. If we write again and trigger another restart, we can
+// end up in an infinite loop and never receive the stdout of the grandchildren in time.
+// Only write once to verify the first grandchild process receives the expected signal.
+// We don't care about the subsequent grandchild processes.
+child.on('message', (msg) => {
+  console.log(`[MESSAGE]`, msg);
+  if (!firstGrandchildPid && typeof msg === 'string') {
+    const match = msg.match(/script ready (\d+)/);
+    if (match) {
+      firstGrandchildPid = match[1];  // This is the first grandchild
+      const writeDelay = 1000;  // Delay to reduce the chance of fs events coalescing
+      console.log(`[PARENT] writing to restart ${firstGrandchildPid} after ${writeDelay}ms`);
+      setTimeout(() => {
+        console.log(`[PARENT] writing to ${indexPath} to restart ${firstGrandchildPid}`);
+        writeFileSync(indexPath, indexContents);
+      }, writeDelay);
+    }
+  }
+});
+
+await once(child, 'exit');
+
+assert.match(stdout, new RegExp(`__SIGTERM received__ ${RegExp.escape(firstGrandchildPid)}`));
+assert.doesNotMatch(stdout, new RegExp(`__SIGINT received__ ${RegExp.escape(firstGrandchildPid)}`));
diff --git a/test/js/node/test/parallel/test-watch-mode-kill-signal-invalid.mjs b/test/js/node/test/parallel/test-watch-mode-kill-signal-invalid.mjs
new file mode 100644
index 000000000000..e2f32ba978e2
--- /dev/null
+++ b/test/js/node/test/parallel/test-watch-mode-kill-signal-invalid.mjs
@@ -0,0 +1,39 @@
+// Test that --watch-kill-signal errors when an invalid kill signal is provided.
+
+import '../common/index.mjs';
+import assert from 'node:assert';
+import { writeFileSync } from 'node:fs';
+import { spawn } from 'node:child_process';
+import tmpdir from '../common/tmpdir.js';
+import fixtures from '../common/fixtures.js';
+import { skipIfNoWatchModeSignals } from '../common/watch.js';
+
+skipIfNoWatchModeSignals();
+
+tmpdir.refresh();
+const indexPath = tmpdir.resolve('kill-signal-for-watch.js');
+const indexContents = fixtures.readSync('kill-signal-for-watch.js', 'utf8');
+writeFileSync(indexPath, indexContents);
+
+const currentRun = Promise.withResolvers();
+const child = spawn(
+  process.execPath,
+  ['--watch', '--watch-kill-signal', 'invalid_signal', indexPath],
+  {
+    cwd: tmpdir.path,
+    stdio: ['inherit', 'inherit', 'pipe'],
+  }
+);
+let stderr = '';
+
+child.stderr.on('data', (data) => {
+  stderr += data.toString();
+  currentRun.resolve();
+});
+
+await currentRun.promise;
+
+assert.match(
+  stderr,
+  /TypeError \[ERR_UNKNOWN_SIGNAL\]: Unknown signal: invalid_signal/
+);
diff --git a/test/js/node/test/parallel/test-watch-mode-kill-signal-override.mjs b/test/js/node/test/parallel/test-watch-mode-kill-signal-override.mjs
new file mode 100644
index 000000000000..ca49b4880f90
--- /dev/null
+++ b/test/js/node/test/parallel/test-watch-mode-kill-signal-override.mjs
@@ -0,0 +1,71 @@
+// Test that the kill signal sent by --watch can be overridden to SIGINT
+// by using --watch-kill-signal.
+
+import '../common/index.mjs';
+import assert from 'node:assert';
+import { writeFileSync } from 'node:fs';
+import { spawn } from 'node:child_process';
+import { once } from 'node:events';
+import tmpdir from '../common/tmpdir.js';
+import fixtures from '../common/fixtures.js';
+import { skipIfNoWatchModeSignals } from '../common/watch.js';
+
+skipIfNoWatchModeSignals();
+
+tmpdir.refresh();
+const indexPath = tmpdir.resolve('kill-signal-for-watch.js');
+const indexContents = fixtures.readSync('kill-signal-for-watch.js', 'utf8');
+writeFileSync(indexPath, indexContents);
+
+const child = spawn(
+  process.execPath,
+  ['--watch', '--watch-kill-signal', 'SIGINT', indexPath],
+  {
+    cwd: tmpdir.path,
+    stdio: ['inherit', 'pipe', 'inherit', 'ipc'],
+  }
+);
+
+let stdout = '';
+let firstGrandchildPid;
+child.stdout.on('data', (data) => {
+  const dataStr = data.toString();
+  console.log(`[STDOUT] ${dataStr}`);
+  stdout += `${dataStr}`;
+  const match = dataStr.match(/__(SIGINT|SIGTERM) received__ (\d+)/);
+  if (match && match[2] === firstGrandchildPid) {
+    console.log(`[PARENT] Sending kill signal to watcher process: ${child.pid}`);
+    child.kill();
+  }
+});
+
+// After the write triggers a restart of the grandchild, the newly spawned second
+// grandchild can post another 'script ready' message before the stdout from the first
+// grandchild is relayed by the watcher and processed by this parent process to kill
+// the watcher. If we write again and trigger another restart, we can
+// end up in an infinite loop and never receive the stdout of the grandchildren in time.
+// Only write once to verify the first grandchild process receives the expected signal.
+// We don't care about the subsequent grandchild processes.
+child.on('message', (msg) => {
+  console.log(`[MESSAGE]`, msg);
+  if (!firstGrandchildPid && typeof msg === 'string') {
+    const match = msg.match(/script ready (\d+)/);
+    if (match) {
+      firstGrandchildPid = match[1];  // This is the first grandchild
+      const writeDelay = 1000;  // Delay to reduce the chance of fs events coalescing
+      console.log(`[PARENT] writing to restart ${firstGrandchildPid} after ${writeDelay}ms`);
+      setTimeout(() => {
+        console.log(`[PARENT] writing to ${indexPath} to restart ${firstGrandchildPid}`);
+        writeFileSync(indexPath, indexContents);
+      }, writeDelay);
+    }
+  }
+});
+
+await once(child, 'exit');
+
+// The second grandchild, if there is one, could receive SIGTERM if it's killed as a
+// consequence of the parent being killed in this process instead of being killed by the
+// parent for file changes. Here we only care about the first grandchild.
+assert.match(stdout, new RegExp(`__SIGINT received__ ${RegExp.escape(firstGrandchildPid)}`));
+assert.doesNotMatch(stdout, new RegExp(`__SIGTERM received__ ${RegExp.escape(firstGrandchildPid)}`));
diff --git a/test/js/node/test/parallel/test-webcrypto-util.js b/test/js/node/test/parallel/test-webcrypto-util.js
new file mode 100644
index 000000000000..9763acfb71e0
--- /dev/null
+++ b/test/js/node/test/parallel/test-webcrypto-util.js
@@ -0,0 +1,80 @@
+// Flags: --expose-internals
+'use strict';
+
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+
+const {
+  bigIntArrayToUnsignedInt,
+  normalizeAlgorithm,
+  validateKeyOps,
+} = require('internal/crypto/util');
+
+// bigIntArrayToUnsignedInt must return an unsigned 32-bit value even when
+// the most significant byte has its top bit set. Otherwise the signed `<<`
+// operator yields a negative Int32 for inputs like [0x80, 0x00, 0x00, 0x01].
+{
+  assert.strictEqual(
+    bigIntArrayToUnsignedInt(new Uint8Array([0x80, 0x00, 0x00, 0x01])),
+    0x80000001);
+  assert.strictEqual(
+    bigIntArrayToUnsignedInt(new Uint8Array([0xff, 0xff, 0xff, 0xff])),
+    0xffffffff);
+  assert.strictEqual(
+    bigIntArrayToUnsignedInt(new Uint8Array([1, 0, 1])),
+    65537);
+  assert.strictEqual(
+    bigIntArrayToUnsignedInt(new Uint8Array([1, 0, 0, 0, 0])),
+    undefined);
+}
+
+{
+  // Check that normalizeAlgorithm does not mutate object inputs.
+  const algorithm = { name: 'ECDSA', hash: 'SHA-256' };
+  assert.strictEqual(normalizeAlgorithm(algorithm, 'sign') !== algorithm, true);
+  assert.deepStrictEqual(algorithm, { name: 'ECDSA', hash: 'SHA-256' });
+}
+
+// The algorithm name getter should only be invoked once during
+// normalizeAlgorithm, including for algorithms with a non-null desiredType
+// where step 6 runs the specialized dictionary converter.
+// Refs: https://github.com/web-platform-tests/wpt/pull/57614#pullrequestreview-3808145365
+{
+  let nameReadCount = 0;
+  const algorithm = {
+    get name() {
+      nameReadCount++;
+      return 'AES-GCM';
+    },
+    iv: new Uint8Array(12),
+  };
+  const normalized = normalizeAlgorithm(algorithm, 'encrypt');
+  assert.strictEqual(normalized.name, 'AES-GCM');
+  assert.strictEqual(nameReadCount, 1);
+}
+
+{
+  let nameReadCount = 0;
+  const algorithm = {
+    get name() {
+      nameReadCount++;
+      return 'ECDSA';
+    },
+    hash: 'SHA-256',
+  };
+  const normalized = normalizeAlgorithm(algorithm, 'sign');
+  assert.strictEqual(normalized.name, 'ECDSA');
+  assert.strictEqual(nameReadCount, 1);
+}
+
+{
+  for (const ops of [
+    ['sign', 'toString', 'constructor'],
+    ['sign', '__proto__', 'constructor'],
+  ]) {
+    validateKeyOps(ops);
+  }
+}
diff --git a/test/js/node/test/parallel/test-whatwg-encoding-singlebyte.mjs b/test/js/node/test/parallel/test-whatwg-encoding-singlebyte.mjs
new file mode 100644
index 000000000000..89aa7c62964c
--- /dev/null
+++ b/test/js/node/test/parallel/test-whatwg-encoding-singlebyte.mjs
@@ -0,0 +1,84 @@
+// Test that single-byte encodings mappings are correct and match spec
+// Works without Intl
+
+// From: https://github.com/ExodusOSS/bytes/blob/master/tests/single-byte.test.js
+// Copyright Exodus Movement. Licensed under MIT License.
+
+import '../common/index.mjs';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { test, describe } from 'node:test';
+import raw from '../fixtures/encoding/encodings.json' with { type: 'json' };
+
+const groups = new Map(raw.map((x) => [x.heading, x.encodings.map((x) => x.name.toLowerCase())]));
+const encodings = groups.get('Legacy single-byte encodings');
+
+describe('single-byte encodings are supersets of ascii', () => {
+  for (const encoding of encodings) {
+    test(encoding, (t) => {
+      const loose = new TextDecoder(encoding);
+      const fatal = new TextDecoder(encoding, { fatal: true });
+      for (let i = 0; i < 128; i++) {
+        const str = String.fromCodePoint(i);
+        t.assert.strictEqual(loose.decode(Uint8Array.of(i)), str, i);
+        t.assert.strictEqual(fatal.decode(Uint8Array.of(i)), str, i);
+      }
+    });
+  }
+});
+
+describe('single-byte encodings index', () => {
+  for (const encoding of encodings) {
+    test(encoding, (t) => {
+      const loose = new TextDecoder(encoding);
+      const fatal = new TextDecoder(encoding, { fatal: true });
+      const file = encoding === 'iso-8859-8-i' ? `index-iso-8859-8.txt` : `index-${encoding}.txt`;
+      const text = readFileSync(join(import.meta.dirname, '../fixtures/encoding/single-byte', file), 'utf8');
+      const rows = text
+        .split('\n')
+        .map((x) => x.trim())
+        .filter((x) => x && x[0] !== '#')
+        .map((x) => x.split('\t'))
+        .map(([istr, codeHex, description]) => {
+          const i = Number(istr);
+          t.assert.ok(i < 128);
+          const code = parseInt(codeHex.slice(2), 16);
+          t.assert.strictEqual(`${i}`, istr);
+          t.assert.strictEqual('0x' + code.toString(16).padStart(4, '0').toUpperCase(), codeHex);
+          t.assert.ok(code && code !== 0xff_fd && code <= 0xff_ff); // Can't be a replacement char, has to be <= 16-bit
+          t.assert.ok(code < 0xd8_00 || code >= 0xe0_00); // not a surrogate
+          return [i, { i, code, description }];
+        });
+
+      t.assert.ok(rows.length <= 128);
+      const known = new Map(rows);
+      t.assert.strictEqual(rows.length, known.size); // all unique
+
+      for (let i = 0; i < 128; i++) {
+        const row = known.get(i);
+        const byte = i + 128;
+        if (row) {
+          t.assert.strictEqual(i, row.i);
+          const str = String.fromCodePoint(row.code);
+          t.assert.strictEqual(fatal.decode(Uint8Array.of(byte)), str, row.description);
+          t.assert.strictEqual(loose.decode(Uint8Array.of(byte)), str, row.description);
+        } else {
+          t.assert.throws(() => fatal.decode(Uint8Array.of(byte)), TypeError);
+          t.assert.strictEqual(loose.decode(Uint8Array.of(byte)), '\uFFFD');
+        }
+      }
+    });
+  }
+});
+
+// https://encoding.spec.whatwg.org/#x-user-defined-decoder
+test('x-user-defined', (t) => {
+  const encoding = 'x-user-defined';
+  const loose = new TextDecoder(encoding);
+  const fatal = new TextDecoder(encoding, { fatal: true });
+  for (let byte = 0; byte < 256; byte++) {
+    const str = String.fromCodePoint(byte >= 0x80 ? 0xF780 + byte - 0x80 : byte);
+    t.assert.strictEqual(fatal.decode(Uint8Array.of(byte)), str, byte);
+    t.assert.strictEqual(loose.decode(Uint8Array.of(byte)), str, byte);
+  }
+});
diff --git a/test/js/node/test/parallel/test-whatwg-url-custom-searchparams-append.js b/test/js/node/test/parallel/test-whatwg-url-custom-searchparams-append.js
index 350a7e79cf48..50bc4577a2fc 100644
--- a/test/js/node/test/parallel/test-whatwg-url-custom-searchparams-append.js
+++ b/test/js/node/test/parallel/test-whatwg-url-custom-searchparams-append.js
@@ -30,7 +30,7 @@ const assert = require('assert');
   assert.throws(() => params.set(obj, 'b'), /^Error: toString$/);
   assert.throws(() => params.set('a', obj), /^Error: toString$/);
   assert.throws(() => params.set(sym, 'b'),
-                /^TypeError: Cannot convert a symbol to a string$/);
+                /^TypeError: Cannot convert a Symbol value to a string$/);
   assert.throws(() => params.set('a', sym),
-                /^TypeError: Cannot convert a symbol to a string$/);
+                /^TypeError: Cannot convert a Symbol value to a string$/);
 }
diff --git a/test/js/node/test/parallel/test-whatwg-url-custom-searchparams-delete.js b/test/js/node/test/parallel/test-whatwg-url-custom-searchparams-delete.js
index 3dfde8678fb7..802e9ba01ba2 100644
--- a/test/js/node/test/parallel/test-whatwg-url-custom-searchparams-delete.js
+++ b/test/js/node/test/parallel/test-whatwg-url-custom-searchparams-delete.js
@@ -29,7 +29,7 @@ const assert = require('assert');
   const sym = Symbol();
   assert.throws(() => params.delete(obj), /^Error: toString$/);
   assert.throws(() => params.delete(sym),
-                /^TypeError: Cannot convert a symbol to a string$/);
+                /^TypeError: Cannot convert a Symbol value to a string$/);
 }
 
 // https://github.com/nodejs/node/issues/10480
diff --git a/test/js/node/test/parallel/test-whatwg-url-custom-searchparams-get.js b/test/js/node/test/parallel/test-whatwg-url-custom-searchparams-get.js
index 832defd56495..d718876c2f8d 100644
--- a/test/js/node/test/parallel/test-whatwg-url-custom-searchparams-get.js
+++ b/test/js/node/test/parallel/test-whatwg-url-custom-searchparams-get.js
@@ -29,5 +29,5 @@ const assert = require('assert');
   const sym = Symbol();
   assert.throws(() => params.get(obj), /^Error: toString$/);
   assert.throws(() => params.get(sym),
-                /^TypeError: Cannot convert a symbol to a string$/);
+                /^TypeError: Cannot convert a Symbol value to a string$/);
 }
diff --git a/test/js/node/test/parallel/test-whatwg-url-custom-searchparams-getall.js b/test/js/node/test/parallel/test-whatwg-url-custom-searchparams-getall.js
index f475d0346da3..457c9add4f54 100644
--- a/test/js/node/test/parallel/test-whatwg-url-custom-searchparams-getall.js
+++ b/test/js/node/test/parallel/test-whatwg-url-custom-searchparams-getall.js
@@ -29,5 +29,5 @@ const assert = require('assert');
   const sym = Symbol();
   assert.throws(() => params.getAll(obj), /^Error: toString$/);
   assert.throws(() => params.getAll(sym),
-                /^TypeError: Cannot convert a symbol to a string$/);
+                /^TypeError: Cannot convert a Symbol value to a string$/);
 }
diff --git a/test/js/node/test/parallel/test-whatwg-url-custom-searchparams-has.js b/test/js/node/test/parallel/test-whatwg-url-custom-searchparams-has.js
index 451758867f2a..f8940dbdafa7 100644
--- a/test/js/node/test/parallel/test-whatwg-url-custom-searchparams-has.js
+++ b/test/js/node/test/parallel/test-whatwg-url-custom-searchparams-has.js
@@ -29,5 +29,5 @@ const assert = require('assert');
   const sym = Symbol();
   assert.throws(() => params.has(obj), /^Error: toString$/);
   assert.throws(() => params.has(sym),
-                /^TypeError: Cannot convert a symbol to a string$/);
+                /^TypeError: Cannot convert a Symbol value to a string$/);
 }
diff --git a/test/js/node/test/parallel/test-whatwg-url-custom-searchparams-set.js b/test/js/node/test/parallel/test-whatwg-url-custom-searchparams-set.js
index b5573ed86bc4..a892b2267a8f 100644
--- a/test/js/node/test/parallel/test-whatwg-url-custom-searchparams-set.js
+++ b/test/js/node/test/parallel/test-whatwg-url-custom-searchparams-set.js
@@ -30,7 +30,7 @@ const assert = require('assert');
   assert.throws(() => params.append(obj, 'b'), /^Error: toString$/);
   assert.throws(() => params.append('a', obj), /^Error: toString$/);
   assert.throws(() => params.append(sym, 'b'),
-                /^TypeError: Cannot convert a symbol to a string$/);
+                /^TypeError: Cannot convert a Symbol value to a string$/);
   assert.throws(() => params.append('a', sym),
-                /^TypeError: Cannot convert a symbol to a string$/);
+                /^TypeError: Cannot convert a Symbol value to a string$/);
 }
diff --git a/test/js/node/test/parallel/test-whatwg-webstreams-adapters-to-writablestream.js b/test/js/node/test/parallel/test-whatwg-webstreams-adapters-to-writablestream.js
new file mode 100644
index 000000000000..60c0538a0c1e
--- /dev/null
+++ b/test/js/node/test/parallel/test-whatwg-webstreams-adapters-to-writablestream.js
@@ -0,0 +1,222 @@
+// Flags: --no-warnings --expose-internals
+
+'use strict';
+
+const common = require('../common');
+
+const assert = require('assert');
+
+const {
+  newWritableStreamFromStreamWritable,
+} = require('internal/webstreams/adapters');
+
+const {
+  Duplex,
+  Writable,
+  PassThrough,
+} = require('stream');
+
+class TestWritable extends Writable {
+  constructor(asyncWrite = false) {
+    super();
+    this.chunks = [];
+    this.asyncWrite = asyncWrite;
+  }
+
+  _write(chunk, encoding, callback) {
+    this.chunks.push({ chunk, encoding });
+    if (this.asyncWrite) {
+      setImmediate(() => callback());
+      return;
+    }
+    callback();
+  }
+}
+
+[1, {}, false, []].forEach((arg) => {
+  assert.throws(() => newWritableStreamFromStreamWritable(arg), {
+    code: 'ERR_INVALID_ARG_TYPE',
+  });
+});
+
+{
+  // Closing the WritableStream normally closes the stream.Writable
+  // without errors.
+
+  const writable = new TestWritable();
+  writable.on('error', common.mustNotCall());
+  writable.on('finish', common.mustCall());
+  writable.on('close', common.mustCall());
+
+  const writableStream = newWritableStreamFromStreamWritable(writable);
+
+  writableStream.close().then(common.mustCall(() => {
+    assert(writable.destroyed);
+  }));
+}
+
+{
+  // Aborting the WritableStream errors the stream.Writable
+
+  const error = new Error('boom');
+  const writable = new TestWritable();
+  writable.on('error', common.mustCall((reason) => {
+    assert.strictEqual(reason, error);
+  }));
+  writable.on('finish', common.mustNotCall());
+  writable.on('close', common.mustCall());
+
+  const writableStream = newWritableStreamFromStreamWritable(writable);
+
+  writableStream.abort(error).then(common.mustCall(() => {
+    assert(writable.destroyed);
+  }));
+}
+
+{
+  // Destroying the stream.Writable prematurely errors the
+  // WritableStream
+
+  const error = new Error('boom');
+  const writable = new TestWritable();
+
+  const writableStream = newWritableStreamFromStreamWritable(writable);
+  assert.rejects(writableStream.close(), error).then(common.mustCall());
+  writable.destroy(error);
+}
+
+{
+  // Ending the stream.Writable directly errors the WritableStream
+  const writable = new TestWritable();
+
+  const writableStream = newWritableStreamFromStreamWritable(writable);
+
+  assert.rejects(writableStream.close(), {
+    code: 'ABORT_ERR'
+  }).then(common.mustCall());
+
+  writable.end();
+}
+
+{
+  const writable = new TestWritable();
+  const writableStream = newWritableStreamFromStreamWritable(writable);
+  const writer = writableStream.getWriter();
+  const ec = new TextEncoder();
+  writer.write(ec.encode('hello')).then(common.mustCall(() => {
+    assert.strictEqual(writable.chunks.length, 1);
+    assert.deepStrictEqual(
+      writable.chunks[0],
+      {
+        chunk: Buffer.from('hello'),
+        encoding: 'buffer'
+      });
+  }));
+}
+
+{
+  const writable = new TestWritable(true);
+
+  writable.on('error', common.mustNotCall());
+  writable.on('close', common.mustCall());
+  writable.on('finish', common.mustCall());
+
+  const writableStream = newWritableStreamFromStreamWritable(writable);
+  const writer = writableStream.getWriter();
+  const ec = new TextEncoder();
+  writer.write(ec.encode('hello')).then(common.mustCall(() => {
+    assert.strictEqual(writable.chunks.length, 1);
+    assert.deepStrictEqual(
+      writable.chunks[0],
+      {
+        chunk: Buffer.from('hello'),
+        encoding: 'buffer'
+      });
+    writer.close().then(common.mustCall());
+  }));
+}
+
+{
+  const duplex = new PassThrough();
+  duplex.setEncoding('utf8');
+  const writableStream = newWritableStreamFromStreamWritable(duplex);
+  const ec = new TextEncoder();
+  writableStream
+    .getWriter()
+    .write(ec.encode('hello'))
+    .then(common.mustCall());
+
+  duplex.on('data', common.mustCall((chunk) => {
+    assert.strictEqual(chunk, 'hello');
+  }));
+}
+
+{
+  const writable = new Writable();
+  writable.destroy();
+  const writableStream = newWritableStreamFromStreamWritable(writable);
+  const writer = writableStream.getWriter();
+  writer.closed.then(common.mustCall());
+}
+
+{
+  const duplex = new Duplex({ writable: false });
+  const writableStream = newWritableStreamFromStreamWritable(duplex);
+  const writer = writableStream.getWriter();
+  writer.closed.then(common.mustCall());
+}
+
+{
+  const duplex = new PassThrough();
+  const writableStream = newWritableStreamFromStreamWritable(duplex);
+  const ec = new TextEncoder();
+  const arrayBuffer = ec.encode('hello').buffer;
+  writableStream
+    .getWriter()
+    .write(arrayBuffer)
+    .then(common.mustCall());
+
+  duplex.on('data', common.mustCall((chunk) => {
+    assert(chunk instanceof Buffer);
+    assert(chunk.equals(Buffer.from('hello')));
+  }));
+}
+
+{
+  const duplex = new PassThrough({ objectMode: true });
+  const writableStream = newWritableStreamFromStreamWritable(duplex);
+  const ec = new TextEncoder();
+  const arrayBuffer = ec.encode('hello').buffer;
+  writableStream
+    .getWriter()
+    .write(arrayBuffer)
+    .then(common.mustCall());
+
+  duplex.on('data', common.mustCall((chunk) => {
+    assert(chunk instanceof ArrayBuffer);
+    assert.strictEqual(chunk, arrayBuffer);
+  }));
+}
+
+{
+  // Test that the stream doesn't hang when the underlying Writable
+  // emits 'drain' synchronously during write().
+  // Fixes: https://github.com/nodejs/node/issues/61145
+  const writable = new Writable({
+    write(chunk, encoding, callback) {
+      callback();
+    },
+  });
+
+  // Force synchronous 'drain' emission during write()
+  // to simulate a stream that doesn't have Node.js's built-in kSync protection.
+  writable.write = function(chunk) {
+    this.emit('drain');
+    return false;
+  };
+
+  const writableStream = newWritableStreamFromStreamWritable(writable);
+  const writer = writableStream.getWriter();
+  writer.write(new Uint8Array([1, 2, 3])).then(common.mustCall());
+  writer.write(new Uint8Array([4, 5, 6])).then(common.mustCall());
+}
diff --git a/test/js/node/test/parallel/test-worker-dns-terminate.js b/test/js/node/test/parallel/test-worker-dns-terminate.js
new file mode 100644
index 000000000000..da9d543c3b0b
--- /dev/null
+++ b/test/js/node/test/parallel/test-worker-dns-terminate.js
@@ -0,0 +1,14 @@
+'use strict';
+const common = require('../common');
+const { Worker } = require('worker_threads');
+
+const w = new Worker(`
+const dns = require('dns');
+dns.lookup('nonexistent.org', () => {});
+require('worker_threads').parentPort.postMessage('0');
+`, { eval: true });
+
+w.on('message', common.mustCall(() => {
+  // This should not crash the worker during a DNS request.
+  w.terminate().then(common.mustCall());
+}));
diff --git a/test/js/node/test/sequential/test-cpu-prof-default.js b/test/js/node/test/sequential/test-cpu-prof-default.js
new file mode 100644
index 000000000000..efd929469a6a
--- /dev/null
+++ b/test/js/node/test/sequential/test-cpu-prof-default.js
@@ -0,0 +1,36 @@
+'use strict';
+
+// Test --cpu-prof without --cpu-prof-interval. Here we just verify that
+// we manage to generate a profile since it's hard to tell whether we
+// can sample our target function with the default sampling rate across
+// different platforms and machine configurations.
+
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+common.skipIfInspectorDisabled();
+
+const assert = require('assert');
+const { spawnSync } = require('child_process');
+
+const tmpdir = require('../common/tmpdir');
+const {
+  getCpuProfiles,
+  env,
+} = require('../common/cpu-prof');
+
+{
+  tmpdir.refresh();
+  const output = spawnSync(process.execPath, [
+    '--cpu-prof',
+    fixtures.path('workload', 'fibonacci.js'),
+  ], {
+    cwd: tmpdir.path,
+    env,
+  });
+  if (output.status !== 0) {
+    console.log(output.stderr.toString());
+  }
+  assert.strictEqual(output.status, 0);
+  const profiles = getCpuProfiles(tmpdir.path);
+  assert.strictEqual(profiles.length, 1);
+}
diff --git a/test/js/node/test/sequential/test-cpu-prof-dir-absolute.js b/test/js/node/test/sequential/test-cpu-prof-dir-absolute.js
new file mode 100644
index 000000000000..1747ba3b1f11
--- /dev/null
+++ b/test/js/node/test/sequential/test-cpu-prof-dir-absolute.js
@@ -0,0 +1,44 @@
+'use strict';
+
+// This tests that relative --cpu-prof-dir works.
+
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+common.skipIfInspectorDisabled();
+
+const assert = require('assert');
+const fs = require('fs');
+const { spawnSync } = require('child_process');
+
+const tmpdir = require('../common/tmpdir');
+const {
+  getCpuProfiles,
+  kCpuProfInterval,
+  env,
+  verifyFrames,
+} = require('../common/cpu-prof');
+
+// relative --cpu-prof-dir
+{
+  tmpdir.refresh();
+  const dir = tmpdir.resolve('prof');
+  const output = spawnSync(process.execPath, [
+    '--cpu-prof',
+    '--cpu-prof-interval',
+    kCpuProfInterval,
+    '--cpu-prof-dir',
+    dir,
+    fixtures.path('workload', 'fibonacci.js'),
+  ], {
+    cwd: tmpdir.path,
+    env,
+  });
+  if (output.status !== 0) {
+    console.log(output.stderr.toString());
+  }
+  assert.strictEqual(output.status, 0);
+  assert(fs.existsSync(dir));
+  const profiles = getCpuProfiles(dir);
+  assert.strictEqual(profiles.length, 1);
+  verifyFrames(output, profiles[0], 'fibonacci.js');
+}
diff --git a/test/js/node/test/sequential/test-cpu-prof-dir-and-name.js b/test/js/node/test/sequential/test-cpu-prof-dir-and-name.js
new file mode 100644
index 000000000000..17395e678f35
--- /dev/null
+++ b/test/js/node/test/sequential/test-cpu-prof-dir-and-name.js
@@ -0,0 +1,47 @@
+'use strict';
+
+// This tests that --cpu-prof-dir and --cpu-prof-name works together.
+
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+common.skipIfInspectorDisabled();
+
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const tmpdir = require('../common/tmpdir');
+const {
+  getCpuProfiles,
+  kCpuProfInterval,
+  env,
+  verifyFrames,
+} = require('../common/cpu-prof');
+
+{
+  tmpdir.refresh();
+  const dir = tmpdir.resolve('prof');
+  const file = path.join(dir, 'test.cpuprofile');
+  const output = spawnSync(process.execPath, [
+    '--cpu-prof',
+    '--cpu-prof-interval',
+    kCpuProfInterval,
+    '--cpu-prof-name',
+    'test.cpuprofile',
+    '--cpu-prof-dir',
+    dir,
+    fixtures.path('workload', 'fibonacci.js'),
+  ], {
+    cwd: tmpdir.path,
+    env,
+  });
+  if (output.status !== 0) {
+    console.log(output.stderr.toString());
+  }
+  assert.strictEqual(output.status, 0);
+  assert(fs.existsSync(dir));
+  const profiles = getCpuProfiles(dir);
+  assert.deepStrictEqual(profiles, [file]);
+  verifyFrames(output, file, 'fibonacci.js');
+}
diff --git a/test/js/node/test/sequential/test-cpu-prof-dir-relative.js b/test/js/node/test/sequential/test-cpu-prof-dir-relative.js
new file mode 100644
index 000000000000..89684ae1c24b
--- /dev/null
+++ b/test/js/node/test/sequential/test-cpu-prof-dir-relative.js
@@ -0,0 +1,44 @@
+'use strict';
+
+// This tests that relative --cpu-prof-dir works.
+
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+common.skipIfInspectorDisabled();
+
+const assert = require('assert');
+const fs = require('fs');
+const { spawnSync } = require('child_process');
+
+const tmpdir = require('../common/tmpdir');
+const {
+  getCpuProfiles,
+  kCpuProfInterval,
+  env,
+  verifyFrames,
+} = require('../common/cpu-prof');
+
+// relative --cpu-prof-dir
+{
+  tmpdir.refresh();
+  const output = spawnSync(process.execPath, [
+    '--cpu-prof',
+    '--cpu-prof-interval',
+    kCpuProfInterval,
+    '--cpu-prof-dir',
+    'prof',
+    fixtures.path('workload', 'fibonacci.js'),
+  ], {
+    cwd: tmpdir.path,
+    env,
+  });
+  if (output.status !== 0) {
+    console.log(output.stderr.toString());
+  }
+  assert.strictEqual(output.status, 0);
+  const dir = tmpdir.resolve('prof');
+  assert(fs.existsSync(dir));
+  const profiles = getCpuProfiles(dir);
+  assert.strictEqual(profiles.length, 1);
+  verifyFrames(output, profiles[0], 'fibonacci.js');
+}
diff --git a/test/js/node/test/sequential/test-cpu-prof-exit.js b/test/js/node/test/sequential/test-cpu-prof-drained.js
similarity index 67%
rename from test/js/node/test/sequential/test-cpu-prof-exit.js
rename to test/js/node/test/sequential/test-cpu-prof-drained.js
index 403af352dfee..d111e51d3f4e 100644
--- a/test/js/node/test/sequential/test-cpu-prof-exit.js
+++ b/test/js/node/test/sequential/test-cpu-prof-drained.js
@@ -1,7 +1,8 @@
 'use strict';
 
-// This tests that --cpu-prof generates CPU profile when
-// process.exit(55) exits the process.
+// This tests that --cpu-prof generates CPU profile when event
+// loop is drained.
+// Upstream note (joyeecheung): share the fixtures with v8 coverage tests
 
 const common = require('../common');
 const fixtures = require('../common/fixtures');
@@ -24,16 +25,16 @@ const {
     '--cpu-prof',
     '--cpu-prof-interval',
     kCpuProfInterval,
-    fixtures.path('workload', 'fibonacci-exit.js'),
+    fixtures.path('workload', 'fibonacci.js'),
   ], {
     cwd: tmpdir.path,
     env,
   });
-  if (output.status !== 55) {
+  if (output.status !== 0) {
     console.log(output.stderr.toString());
   }
-  assert.strictEqual(output.status, 55);
+  assert.strictEqual(output.status, 0);
   const profiles = getCpuProfiles(tmpdir.path);
   assert.strictEqual(profiles.length, 1);
-  verifyFrames(output, profiles[0], 'fibonacci-exit.js');
+  verifyFrames(output, profiles[0], 'fibonacci.js');
 }
diff --git a/test/js/node/test/sequential/test-cpu-prof-invalid-options.js b/test/js/node/test/sequential/test-cpu-prof-invalid-options.js
new file mode 100644
index 000000000000..5106dea6f7ba
--- /dev/null
+++ b/test/js/node/test/sequential/test-cpu-prof-invalid-options.js
@@ -0,0 +1,79 @@
+'use strict';
+
+// This tests that invalid --cpu-prof options are rejected.
+
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+common.skipIfInspectorDisabled();
+
+const assert = require('assert');
+const { spawnSync } = require('child_process');
+
+const tmpdir = require('../common/tmpdir');
+const {
+  kCpuProfInterval,
+  env,
+} = require('../common/cpu-prof');
+
+// --cpu-prof-name without --cpu-prof
+{
+  tmpdir.refresh();
+  const output = spawnSync(process.execPath, [
+    '--cpu-prof-name',
+    'test.cpuprofile',
+    fixtures.path('workload', 'fibonacci.js'),
+  ], {
+    cwd: tmpdir.path,
+    env,
+  });
+  const stderr = output.stderr.toString().trim();
+  if (output.status !== 9) {
+    console.log(stderr);
+  }
+  assert.strictEqual(output.status, 9);
+  assert.strictEqual(
+    stderr,
+    `${process.execPath}: --cpu-prof-name must be used with --cpu-prof`);
+}
+
+// --cpu-prof-dir without --cpu-prof
+{
+  tmpdir.refresh();
+  const output = spawnSync(process.execPath, [
+    '--cpu-prof-dir',
+    'prof',
+    fixtures.path('workload', 'fibonacci.js'),
+  ], {
+    cwd: tmpdir.path,
+    env,
+  });
+  const stderr = output.stderr.toString().trim();
+  if (output.status !== 9) {
+    console.log(stderr);
+  }
+  assert.strictEqual(output.status, 9);
+  assert.strictEqual(
+    stderr,
+    `${process.execPath}: --cpu-prof-dir must be used with --cpu-prof`);
+}
+
+// --cpu-prof-interval without --cpu-prof
+for (const arg of [kCpuProfInterval, 'crashme']) {
+  tmpdir.refresh();
+  const output = spawnSync(process.execPath, [
+    '--cpu-prof-interval',
+    arg,
+    fixtures.path('workload', 'fibonacci.js'),
+  ], {
+    cwd: tmpdir.path,
+    env,
+  });
+  const stderr = output.stderr.toString().trim();
+  if (output.status !== 9) {
+    console.log(stderr);
+  }
+  assert.strictEqual(output.status, 9);
+  assert.strictEqual(
+    stderr,
+    `${process.execPath}: --cpu-prof-interval must be used with --cpu-prof`);
+}
diff --git a/test/js/node/test/sequential/test-cpu-prof-kill.js b/test/js/node/test/sequential/test-cpu-prof-kill.js
new file mode 100644
index 000000000000..8d37e7fbfa53
--- /dev/null
+++ b/test/js/node/test/sequential/test-cpu-prof-kill.js
@@ -0,0 +1,41 @@
+'use strict';
+
+// This tests that --cpu-prof generates CPU profile when
+// process.kill(process.pid, "SIGINT"); exits the process.
+
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+common.skipIfInspectorDisabled();
+
+const assert = require('assert');
+const { spawnSync } = require('child_process');
+
+const tmpdir = require('../common/tmpdir');
+const {
+  getCpuProfiles,
+  kCpuProfInterval,
+  env,
+  verifyFrames,
+} = require('../common/cpu-prof');
+
+{
+  tmpdir.refresh();
+  const output = spawnSync(process.execPath, [
+    '--cpu-prof',
+    '--cpu-prof-interval',
+    kCpuProfInterval,
+    fixtures.path('workload', 'fibonacci-sigint.js'),
+  ], {
+    cwd: tmpdir.path,
+    env,
+  });
+  if (!common.isWindows) {
+    if (output.signal !== 'SIGINT') {
+      console.log(output.stderr.toString());
+    }
+    assert.strictEqual(output.signal, 'SIGINT');
+  }
+  const profiles = getCpuProfiles(tmpdir.path);
+  assert.strictEqual(profiles.length, 1);
+  verifyFrames(output, profiles[0], 'fibonacci-sigint.js');
+}
diff --git a/test/js/node/test/sequential/test-cpu-prof-name.js b/test/js/node/test/sequential/test-cpu-prof-name.js
new file mode 100644
index 000000000000..f79c3af8eeda
--- /dev/null
+++ b/test/js/node/test/sequential/test-cpu-prof-name.js
@@ -0,0 +1,78 @@
+'use strict';
+
+// This tests that --cpu-prof-name can be used to specify the
+// name of the generated CPU profile.
+
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+common.skipIfInspectorDisabled();
+
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const tmpdir = require('../common/tmpdir');
+const {
+  getCpuProfiles,
+  kCpuProfInterval,
+  env,
+  verifyFrames,
+} = require('../common/cpu-prof');
+
+// --cpu-prof-name
+{
+  tmpdir.refresh();
+  const file = tmpdir.resolve('test.cpuprofile');
+  const output = spawnSync(process.execPath, [
+    '--cpu-prof',
+    '--cpu-prof-interval',
+    kCpuProfInterval,
+    '--cpu-prof-name',
+    'test.cpuprofile',
+    fixtures.path('workload', 'fibonacci.js'),
+  ], {
+    cwd: tmpdir.path,
+    env,
+  });
+  if (output.status !== 0) {
+    console.log(output.stderr.toString());
+  }
+  assert.strictEqual(output.status, 0);
+  const profiles = getCpuProfiles(tmpdir.path);
+  assert.deepStrictEqual(profiles, [file]);
+  verifyFrames(output, file, 'fibonacci.js');
+}
+
+// --cpu-prof-name with ${pid} placeholder
+{
+  tmpdir.refresh();
+  // eslint-disable-next-line no-template-curly-in-string
+  const profName = 'CPU.${pid}.cpuprofile';
+  const dir = tmpdir.path;
+
+  const output = spawnSync(process.execPath, [
+    '--cpu-prof',
+    '--cpu-prof-interval',
+    kCpuProfInterval,
+    '--cpu-prof-name',
+    profName,
+    fixtures.path('workload', 'fibonacci.js'),
+  ], {
+    cwd: dir,
+    env,
+  });
+
+  if (output.status !== 0) {
+    console.error(output.stderr.toString());
+  }
+
+  assert.strictEqual(output.status, 0);
+
+  const expectedFile = path.join(dir, `CPU.${output.pid}.cpuprofile`);
+  assert.ok(fs.existsSync(expectedFile), `Expected file ${expectedFile} not found.`);
+
+  verifyFrames(output, expectedFile, 'fibonacci.js');
+
+  fs.unlinkSync(expectedFile);
+}
diff --git a/test/js/node/test/sequential/test-worker-fshandles-error-on-termination.js b/test/js/node/test/sequential/test-worker-fshandles-error-on-termination.js
new file mode 100644
index 000000000000..e7438c0cc7b2
--- /dev/null
+++ b/test/js/node/test/sequential/test-worker-fshandles-error-on-termination.js
@@ -0,0 +1,51 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const fs = require('fs/promises');
+const { scheduler } = require('timers/promises');
+const { parentPort, Worker } = require('worker_threads');
+
+const MAX_ITERATIONS = 5;
+const MAX_THREADS = 6;
+
+// Do not use isMainThread so that this test itself can be run inside a Worker.
+if (!process.env.HAS_STARTED_WORKER) {
+  process.env.HAS_STARTED_WORKER = 1;
+
+  function spinWorker(iter) {
+    const w = new Worker(__filename);
+    w.on('message', common.mustCall((msg) => {
+      assert.strictEqual(msg, 'terminate');
+      w.terminate();
+    }));
+
+    w.on('exit', common.mustCall(() => {
+      if (iter < MAX_ITERATIONS)
+        spinWorker(++iter);
+    }));
+  }
+
+  for (let i = 0; i < MAX_THREADS; i++) {
+    spinWorker(0);
+  }
+} else {
+  async function open_nok() {
+    await assert.rejects(
+      fs.open('this file does not exist'),
+      {
+        code: 'ENOENT',
+        syscall: 'open',
+      }
+    );
+    await scheduler.yield();
+    await open_nok();
+  }
+
+  // These async function calls never return as they are meant to continually
+  // open nonexistent files until the worker is terminated.
+  open_nok();
+  open_nok();
+
+  parentPort.postMessage('terminate');
+}
diff --git a/test/js/node/test/sequential/test-worker-fshandles-open-close-on-termination.js b/test/js/node/test/sequential/test-worker-fshandles-open-close-on-termination.js
new file mode 100644
index 000000000000..db7c0221fcc1
--- /dev/null
+++ b/test/js/node/test/sequential/test-worker-fshandles-open-close-on-termination.js
@@ -0,0 +1,46 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const fs = require('fs/promises');
+const { scheduler } = require('timers/promises');
+const { parentPort, Worker } = require('worker_threads');
+
+const MAX_ITERATIONS = 5;
+const MAX_THREADS = 6;
+
+// Do not use isMainThread so that this test itself can be run inside a Worker.
+if (!process.env.HAS_STARTED_WORKER) {
+  process.env.HAS_STARTED_WORKER = 1;
+
+  function spinWorker(iter) {
+    const w = new Worker(__filename);
+    w.on('message', common.mustCall((msg) => {
+      assert.strictEqual(msg, 'terminate');
+      w.terminate();
+    }));
+
+    w.on('exit', common.mustCall(() => {
+      if (iter < MAX_ITERATIONS)
+        spinWorker(++iter);
+    }));
+  }
+
+  for (let i = 0; i < MAX_THREADS; i++) {
+    spinWorker(0);
+  }
+} else {
+  async function open_close() {
+    const fh = await fs.open(__filename);
+    await fh.close();
+    await scheduler.yield();
+    await open_close();
+  }
+
+  // These async function calls never return as they are meant to continually
+  // open and close files until the worker is terminated.
+  open_close();
+  open_close();
+
+  parentPort.postMessage('terminate');
+}
diff --git a/test/js/node/url/pathToFileURL-leak-fixture.js b/test/js/node/url/pathToFileURL-leak-fixture.js
index 48ec6497ca5e..ba6f327ed82f 100644
--- a/test/js/node/url/pathToFileURL-leak-fixture.js
+++ b/test/js/node/url/pathToFileURL-leak-fixture.js
@@ -1,5 +1,5 @@
 var longPath = Buffer.alloc(1021, "Z").toString();
-const isDebugBuildOfBun = globalThis?.Bun?.revision?.includes("debug");
+const isDebugBuildOfBun = globalThis?.Bun?.version?.includes("debug");
 // ASAN's quarantine retains freed allocations (default 256 MB) and shadow
 // memory raises the absolute RSS floor; widen the cap to avoid false positives.
 const isASAN = process.execPath.includes("bun-asan");
@@ -8,11 +8,11 @@ const rss =
     ? Bun.unsafe.memoryFootprint
     : process.memoryUsage.rss;
 import { pathToFileURL } from "url";
-for (let i = 0; i < 1024 * (isDebugBuildOfBun ? 32 : 256); i++) {
+for (let i = 0; i < 1024 * (isDebugBuildOfBun ? 2 : 256); i++) {
   pathToFileURL(longPath);
 }
 Bun.gc(true);
-const limitMB = isASAN ? 700 : 250;
+const limitMB = isASAN || isDebugBuildOfBun ? 700 : 250;
 const rssMB = (rss() / 1024 / 1024) | 0;
 console.log("RSS", rssMB, "MB");
 if (rssMB > limitMB) {
diff --git a/test/js/node/url/url-domain-ascii-unicode.test.js b/test/js/node/url/url-domain-ascii-unicode.test.js
index d46b30f8c2e0..912c93637f79 100644
--- a/test/js/node/url/url-domain-ascii-unicode.test.js
+++ b/test/js/node/url/url-domain-ascii-unicode.test.js
@@ -67,8 +67,9 @@ const pairs = [
 const invalids = [
   ["@", ""],
   ["a@b", ""],
-  [null, null],
-  [undefined, undefined],
+  // Node stringifies the argument, so these parse as the domains "null"/"undefined".
+  [null, "null"],
+  [undefined, "undefined"],
   ["2001:0db8:85a3:0000:0000:8a2e:0370:7334", ""],
 ];
 
diff --git a/test/js/node/url/url-fileurltopathbuffer.test.ts b/test/js/node/url/url-fileurltopathbuffer.test.ts
index 791e91369e42..80a4cad70c86 100644
--- a/test/js/node/url/url-fileurltopathbuffer.test.ts
+++ b/test/js/node/url/url-fileurltopathbuffer.test.ts
@@ -28,7 +28,7 @@ describe("fileURLToPathBuffer", () => {
   });
 
   test("round-trips a path node's way", () => {
-    const url = pathToFileURL("/tmp/some dir/file.txt");
+    const url = pathToFileURL("/tmp/some dir/file.txt", { windows: false });
     expect(fileURLToPathBuffer(url, { windows: false }).toString()).toBe("/tmp/some dir/file.txt");
   });
 
diff --git a/test/js/node/url/url-format-whatwg.test.js b/test/js/node/url/url-format-whatwg.test.js
index 91c6535ffb51..5a9d50fdb960 100644
--- a/test/js/node/url/url-format-whatwg.test.js
+++ b/test/js/node/url/url-format-whatwg.test.js
@@ -6,22 +6,18 @@ describe("url.format", () => {
   test("WHATWG", () => {
     const myURL = new URL("http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b#c");
 
-    // TODO: Support these.
-    //
-    // assert.strictEqual(url.format(myURL), "http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b#c");
-
-    // assert.strictEqual(url.format(myURL, {}), "http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b#c");
-
-    // TODO: Support this kind of assert.throws.
-    // {
-    //   [true, 1, "test", Infinity].forEach(value => {
-    //     assert.throws(() => url.format(myURL, value), {
-    //       code: "ERR_INVALID_ARG_TYPE",
-    //       name: "TypeError",
-    //       message: 'The "options" argument must be of type object.',
-    //     });
-    //   });
-    // }
+    assert.strictEqual(url.format(myURL), "http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b#c");
+
+    assert.strictEqual(url.format(myURL, {}), "http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b#c");
+
+    {
+      [true, 1, "test", Infinity].forEach(value => {
+        assert.throws(() => url.format(myURL, value), {
+          code: "ERR_INVALID_ARG_TYPE",
+          name: "TypeError",
+        });
+      });
+    }
 
     // Any falsy value other than undefined will be treated as false.
     // Any truthy value will be treated as true.
@@ -32,47 +28,58 @@ describe("url.format", () => {
 
     assert.strictEqual(url.format(myURL, { auth: 0 }), "http://xn--lck1c3crb1723bpq4a.com/a?a=b#c");
 
-    // TODO: Support these.
-    //
-    // assert.strictEqual(url.format(myURL, { auth: 1 }), "http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b#c");
+    assert.strictEqual(url.format(myURL, { auth: 1 }), "http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b#c");
 
-    // assert.strictEqual(url.format(myURL, { auth: {} }), "http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b#c");
+    assert.strictEqual(url.format(myURL, { auth: {} }), "http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b#c");
 
-    // assert.strictEqual(url.format(myURL, { fragment: false }), "http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b");
+    assert.strictEqual(url.format(myURL, { fragment: false }), "http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b");
 
-    // assert.strictEqual(url.format(myURL, { fragment: "" }), "http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b");
+    assert.strictEqual(url.format(myURL, { fragment: "" }), "http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b");
 
-    // assert.strictEqual(url.format(myURL, { fragment: 0 }), "http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b");
+    assert.strictEqual(url.format(myURL, { fragment: 0 }), "http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b");
 
-    // assert.strictEqual(url.format(myURL, { fragment: 1 }), "http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b#c");
+    assert.strictEqual(url.format(myURL, { fragment: 1 }), "http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b#c");
 
-    // assert.strictEqual(url.format(myURL, { fragment: {} }), "http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b#c");
+    assert.strictEqual(url.format(myURL, { fragment: {} }), "http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b#c");
 
-    // assert.strictEqual(url.format(myURL, { search: false }), "http://user:pass@xn--lck1c3crb1723bpq4a.com/a#c");
+    assert.strictEqual(url.format(myURL, { search: false }), "http://user:pass@xn--lck1c3crb1723bpq4a.com/a#c");
 
-    // assert.strictEqual(url.format(myURL, { search: "" }), "http://user:pass@xn--lck1c3crb1723bpq4a.com/a#c");
+    assert.strictEqual(url.format(myURL, { search: "" }), "http://user:pass@xn--lck1c3crb1723bpq4a.com/a#c");
 
-    // assert.strictEqual(url.format(myURL, { search: 0 }), "http://user:pass@xn--lck1c3crb1723bpq4a.com/a#c");
+    assert.strictEqual(url.format(myURL, { search: 0 }), "http://user:pass@xn--lck1c3crb1723bpq4a.com/a#c");
 
-    // assert.strictEqual(url.format(myURL, { search: 1 }), "http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b#c");
+    assert.strictEqual(url.format(myURL, { search: 1 }), "http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b#c");
 
-    // assert.strictEqual(url.format(myURL, { search: {} }), "http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b#c");
+    assert.strictEqual(url.format(myURL, { search: {} }), "http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b#c");
 
-    // assert.strictEqual(url.format(myURL, { unicode: true }), "http://user:pass@理容ナカムラ.com/a?a=b#c");
+    assert.strictEqual(url.format(myURL, { unicode: true }), "http://user:pass@理容ナカムラ.com/a?a=b#c");
 
-    // assert.strictEqual(url.format(myURL, { unicode: 1 }), "http://user:pass@理容ナカムラ.com/a?a=b#c");
+    assert.strictEqual(url.format(myURL, { unicode: 1 }), "http://user:pass@理容ナカムラ.com/a?a=b#c");
 
-    // assert.strictEqual(url.format(myURL, { unicode: {} }), "http://user:pass@理容ナカムラ.com/a?a=b#c");
+    assert.strictEqual(url.format(myURL, { unicode: {} }), "http://user:pass@理容ナカムラ.com/a?a=b#c");
 
-    // assert.strictEqual(url.format(myURL, { unicode: false }), "http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b#c");
+    assert.strictEqual(url.format(myURL, { unicode: false }), "http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b#c");
 
-    // assert.strictEqual(url.format(myURL, { unicode: 0 }), "http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b#c");
+    assert.strictEqual(url.format(myURL, { unicode: 0 }), "http://user:pass@xn--lck1c3crb1723bpq4a.com/a?a=b#c");
 
-    // assert.strictEqual(
-    //   url.format(new URL("http://user:pass@xn--0zwm56d.com:8080/path"), { unicode: true }),
-    //   "http://user:pass@测试.com:8080/path",
-    // );
+    assert.strictEqual(
+      url.format(new URL("http://user:pass@xn--0zwm56d.com:8080/path"), { unicode: true }),
+      "http://user:pass@测试.com:8080/path",
+    );
 
     assert.strictEqual(url.format(new URL("tel:123")), url.format(new URL("tel:123"), { unicode: true }));
+
+    // Empty-but-present hosts keep their // marker (matches node).
+    assert.strictEqual(url.format(new URL("file:///tmp/x")), "file:///tmp/x");
+    assert.strictEqual(url.format(new URL("file:///tmp/x"), { auth: false }), "file:///tmp/x");
+    assert.strictEqual(url.format(new URL("foo://")), "foo://");
+
+    // Empty-but-present query/fragment keep their ?/# marker on the slow
+    // path too (node reparses the href, so null vs empty-string survives).
+    assert.strictEqual(url.format(new URL("http://x/?"), { unicode: true }), "http://x/?");
+    assert.strictEqual(url.format(new URL("http://x/#"), { auth: false }), "http://x/#");
+    assert.strictEqual(url.format(new URL("http://x/?#"), { unicode: true }), "http://x/?#");
+    assert.strictEqual(url.format(new URL("http://x/?#"), { fragment: false }), "http://x/?");
+    assert.strictEqual(url.format(new URL("http://x/?#"), { search: false }), "http://x/#");
   });
 });
diff --git a/test/js/node/url/url-parse-ipv6.test.ts b/test/js/node/url/url-parse-ipv6.test.ts
index 2a79c83c931c..30697f994010 100644
--- a/test/js/node/url/url-parse-ipv6.test.ts
+++ b/test/js/node/url/url-parse-ipv6.test.ts
@@ -6,12 +6,19 @@ import url from "node:url";
 process.emitWarning = () => {};
 
 describe("Invalid IPv6 addresses", () => {
-  it.each(["https://[::1", "https://[:::1]", "https://[\n::1]", "http://[::banana]"])(
-    "Invalid hostnames - parsing '%s' fails",
-    input => {
-      expect(() => url.parse(input)).toThrowError(TypeError);
-    },
-  );
+  it.each(["https://[::1"])("Invalid hostnames - parsing '%s' fails", input => {
+    expect(() => url.parse(input)).toThrowError(TypeError);
+  });
+
+  // Node only rejects the forbiddenHostCharsIpv6 set inside brackets; these
+  // parse (matching node), with tab/CR/LF stripped like the WHATWG parser.
+  it.each([
+    ["https://[:::1]", "[:::1]"],
+    ["https://[\n::1]", "[::1]"],
+    ["http://[::banana]", "[::banana]"],
+  ])("Lenient hostnames - parsing '%s'", (input, host) => {
+    expect(url.parse(input).host).toBe(host);
+  });
 
   it.each(["https://[::1]::", "https://[::1]:foo"])("Invalid ports - parsing '%s' fails", input => {
     expect(() => url.parse(input)).toThrowError(TypeError);
diff --git a/test/js/node/v8/v8-serdes-buffer.test.ts b/test/js/node/v8/v8-serdes-buffer.test.ts
new file mode 100644
index 000000000000..d35136c39fea
--- /dev/null
+++ b/test/js/node/v8/v8-serdes-buffer.test.ts
@@ -0,0 +1,116 @@
+import { describe, expect, test } from "bun:test";
+import { bunEnv, bunExe } from "harness";
+import v8 from "node:v8";
+
+// Buffer identity through v8.serialize/deserialize, matching node v26.3.0's
+// serializer delegate behavior (DefaultSerializer host objects). Non-Buffer
+// payloads keep the bare JSC-serialized format for backward compatibility.
+describe("v8 serialize/deserialize Buffer identity", () => {
+  test("Buffer round-trips as Buffer", () => {
+    const out = v8.deserialize(v8.serialize(Buffer.from("hi")));
+    expect(Buffer.isBuffer(out)).toBe(true);
+    expect(out.toString()).toBe("hi");
+  });
+
+  test("Uint8Array stays Uint8Array (node preserves the distinction)", () => {
+    const out = v8.deserialize(v8.serialize(new Uint8Array([1, 2])));
+    expect(Buffer.isBuffer(out)).toBe(false);
+    expect(out).toBeInstanceOf(Uint8Array);
+    expect(Array.from(out)).toEqual([1, 2]);
+  });
+
+  test("other typed arrays keep their type", () => {
+    const out = v8.deserialize(v8.serialize(new Float64Array([1.5])));
+    expect(out).toBeInstanceOf(Float64Array);
+    expect(out[0]).toBe(1.5);
+  });
+
+  test("nested Buffers, aliasing preserved", () => {
+    const b = Buffer.from("hello world").subarray(6, 9);
+    const out = v8.deserialize(v8.serialize({ deep: { list: [b, b] } }));
+    expect(Buffer.isBuffer(out.deep.list[0])).toBe(true);
+    expect(out.deep.list[0]).toBe(out.deep.list[1]);
+    expect(out.deep.list[0].toString()).toBe("wor");
+    expect(out.deep.list[0].length).toBe(3);
+  });
+
+  test("Buffers as Map keys and values", () => {
+    const m = new Map([[Buffer.from("k"), { v: Buffer.from("v") }]]);
+    const out = v8.deserialize(v8.serialize(m)) as Map<any, any>;
+    const [key, value] = [...out][0];
+    expect(Buffer.isBuffer(key)).toBe(true);
+    expect(Buffer.isBuffer(value.v)).toBe(true);
+  });
+
+  test("Buffer-free payloads keep the bare format (old readers still work)", () => {
+    const jsc = require("bun:jsc");
+    const bytes = v8.serialize({ n: 1, s: "x" });
+    // Bare JSC bytes deserialize directly — no envelope framing present.
+    expect(jsc.deserialize(bytes)).toEqual({ n: 1, s: "x" });
+    // And deserialize accepts pre-envelope output produced by jsc.serialize.
+    const legacy = jsc.serialize({ buf: new Uint8Array([7]) }, { binaryType: "nodebuffer" });
+    expect(v8.deserialize(legacy)).toEqual({ buf: new Uint8Array([7]) });
+  });
+
+  test("circular structures with Buffers", () => {
+    const obj: any = { buf: Buffer.from("c") };
+    obj.self = obj;
+    const out = v8.deserialize(v8.serialize(obj));
+    expect(out.self).toBe(out);
+    expect(Buffer.isBuffer(out.buf)).toBe(true);
+  });
+
+  test("round-trip survives tampered globals and prototypes", async () => {
+    // Everything the envelope framing touches is captured at module load, so
+    // tampering after the module loads must not reach serialize/deserialize.
+    await using proc = Bun.spawn({
+      cmd: [
+        bunExe(),
+        "-e",
+        `const v8 = require("node:v8");
+        ArrayBuffer.isView = () => false;
+        Buffer.allocUnsafe = () => { throw new Error("tampered allocUnsafe"); };
+        Buffer.prototype.copy = () => { throw new Error("tampered copy"); };
+        const TAProto = Object.getPrototypeOf(Uint8Array.prototype);
+        for (const k of ["buffer", "byteOffset", "byteLength"]) {
+          Object.defineProperty(TAProto, k, { get() { throw new Error("tampered " + k); } });
+        }
+        Uint8Array.prototype.subarray = () => { throw new Error("tampered subarray"); };
+        globalThis.Uint8Array = function Poisoned() { throw new Error("tampered ctor"); };
+        const out = v8.deserialize(v8.serialize({ b: Buffer.from("hi") }));
+        console.log(Buffer.isBuffer(out.b), out.b.toString());`,
+      ],
+      env: bunEnv,
+      stderr: "pipe",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+    expect(stderr).toBe("");
+    expect(stdout).toBe("true hi\n");
+    expect(exitCode).toBe(0);
+  });
+
+  test("DataView and ArrayBuffer inputs survive tampered brand checks", async () => {
+    await using proc = Bun.spawn({
+      cmd: [
+        bunExe(),
+        "-e",
+        `const v8 = require("node:v8");
+        const bytes = v8.serialize({ b: Buffer.from("dv") });
+        const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+        const ab = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+        ArrayBuffer.isView = () => false;
+        Object.defineProperty(ArrayBuffer, Symbol.hasInstance, { value: () => false });
+        Object.defineProperty(SharedArrayBuffer, Symbol.hasInstance, { value: () => false });
+        const a = v8.deserialize(dv);
+        const b = v8.deserialize(ab);
+        console.log(Buffer.isBuffer(a.b), Buffer.isBuffer(b.b));`,
+      ],
+      env: bunEnv,
+      stderr: "pipe",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+    expect(stderr).toBe("");
+    expect(stdout).toBe("true true\n");
+    expect(exitCode).toBe(0);
+  });
+});
diff --git a/test/js/third_party/next-auth/fixture/server.js b/test/js/third_party/next-auth/fixture/server.js
index cf36fccb337f..4a90a234699a 100644
--- a/test/js/third_party/next-auth/fixture/server.js
+++ b/test/js/third_party/next-auth/fixture/server.js
@@ -1,5 +1,4 @@
 import net from "net";
-import { parse } from "url";
 import http from "http";
 import next from "next";
 import { expect } from "bun:test";
@@ -53,8 +52,7 @@ const handle = app.getRequestHandler();
 app.prepare().then(() => {
   const server = http
     .createServer((req, res) => {
-      const parsedUrl = parse(req.url, true);
-      handle(req, res, parsedUrl);
+      handle(req, res);
     })
     .listen(0, "127.0.0.1", () => {
       console.log("server listening", server.address().port);
diff --git a/test/js/web/structured-clone-shared-array-buffer.test.ts b/test/js/web/structured-clone-shared-array-buffer.test.ts
new file mode 100644
index 000000000000..0fe1e595957c
--- /dev/null
+++ b/test/js/web/structured-clone-shared-array-buffer.test.ts
@@ -0,0 +1,51 @@
+import { describe, expect, test } from "bun:test";
+
+// structuredClone stays inside the agent cluster, so SharedArrayBuffers share
+// their backing store like node and the HTML spec's StructuredSerialize.
+describe("structuredClone(SharedArrayBuffer)", () => {
+  test("clone is a SharedArrayBuffer sharing memory", () => {
+    const sab = new SharedArrayBuffer(8);
+    const clone = structuredClone(sab);
+    expect(clone).toBeInstanceOf(SharedArrayBuffer);
+    expect(clone.byteLength).toBe(8);
+    new Uint8Array(sab)[0] = 42;
+    expect(new Uint8Array(clone)[0]).toBe(42);
+    new Uint8Array(clone)[1] = 7;
+    expect(new Uint8Array(sab)[1]).toBe(7);
+  });
+
+  test("SAB nested in an object shares through the clone", () => {
+    const sab = new SharedArrayBuffer(4);
+    const out = structuredClone({ deep: [sab] });
+    expect(out.deep[0]).toBeInstanceOf(SharedArrayBuffer);
+    new Uint8Array(sab)[0] = 9;
+    expect(new Uint8Array(out.deep[0])[0]).toBe(9);
+  });
+
+  test("worker postMessage shares the SAB", async () => {
+    const sab = new SharedArrayBuffer(4);
+    const worker = new Worker(
+      URL.createObjectURL(
+        new Blob(
+          [
+            `self.onmessage = ({ data }) => {
+               new Uint8Array(data)[0] = 42;
+               postMessage("done");
+             };`,
+          ],
+          { type: "application/javascript" },
+        ),
+      ),
+    );
+    try {
+      const { promise, resolve, reject } = Promise.withResolvers();
+      worker.onmessage = resolve;
+      worker.onerror = reject;
+      worker.postMessage(sab);
+      await promise;
+      expect(new Uint8Array(sab)[0]).toBe(42);
+    } finally {
+      worker.terminate();
+    }
+  });
+});
diff --git a/test/js/web/url/url.test.ts b/test/js/web/url/url.test.ts
index 4775e22b8b50..a148dd49d299 100755
--- a/test/js/web/url/url.test.ts
+++ b/test/js/web/url/url.test.ts
@@ -1,24 +1,56 @@
 import { describe, expect, it, test } from "bun:test";
 import { bunEnv, bunExe } from "harness";
 import { resolveObjectURL } from "node:buffer";
+import util from "node:util";
 
 describe("url", () => {
   it("URL throws", () => {
-    expect(() => new URL("")).toThrow('"" cannot be parsed as a URL');
-    expect(() => new URL(" ")).toThrow('" " cannot be parsed as a URL');
-    expect(() => new URL("boop", "http!/example.com")).toThrow(
-      '"boop" cannot be parsed as a URL against "http!/example.com"',
-    );
+    // Node-compatible message: exactly "Invalid URL".
+    expect(() => new URL("")).toThrow("Invalid URL");
+    expect(() => new URL(" ")).toThrow("Invalid URL");
+    expect(() => new URL("boop", "http!/example.com")).toThrow("Invalid URL");
     expect(() => new URL("boop", "http!/example.com")).toThrow(
       expect.objectContaining({
         code: "ERR_INVALID_URL",
       }),
     );
+    expect(() => new URL("boop", "https!!username:password@example.com")).toThrow("Invalid URL");
+  });
 
-    // redact
-    expect(() => new URL("boop", "https!!username:password@example.com")).toThrow(
-      '"boop" cannot be parsed as a URL against <redacted>',
-    );
+  it("ERR_INVALID_URL carries input and, when given, base", () => {
+    try {
+      new URL("//[", "http://x");
+      expect.unreachable();
+    } catch (e: any) {
+      expect(e.code).toBe("ERR_INVALID_URL");
+      expect(e.input).toBe("//[");
+      expect(e.base).toBe("http://x");
+    }
+    // base itself invalid: both still surface, base is the raw string.
+    try {
+      new URL("boop", "http!/example.com");
+      expect.unreachable();
+    } catch (e: any) {
+      expect(e.input).toBe("boop");
+      expect(e.base).toBe("http!/example.com");
+    }
+    // One-arg form: .base must be absent, not undefined-valued.
+    try {
+      new URL("::");
+      expect.unreachable();
+    } catch (e: any) {
+      expect(e.input).toBe("::");
+      expect("base" in e).toBe(false);
+    }
+    // href setter has no base argument, so no .base either.
+    const u = new URL("http://x");
+    try {
+      u.href = "::";
+      expect.unreachable();
+    } catch (e: any) {
+      expect(e.input).toBe("::");
+      expect("base" in e).toBe(false);
+    }
   });
 
   it("should have correct origin and protocol", () => {
@@ -82,22 +114,69 @@ describe("url", () => {
     expect(url.protocol).toBe("blob:");
     expect(url.origin).toBe("file://");
   });
+  it("leaves opaque (non-special-scheme) hosts unchanged", () => {
+    // Non-special schemes never run IDNA; the host is UTF-8 percent-encoded
+    // verbatim per WHATWG and node/ada. U+1E9E is an IDNA delta source for
+    // special schemes only.
+    expect(new URL("foo://\u1E9E.com/").href).toBe("foo://%E1%BA%9E.com/");
+    expect(new URL("foo://a\u180Eb/").href).toBe("foo://a%E1%A0%8Eb/");
+    // special scheme: delta applies, host is IDNA-processed.
+    expect(new URL("http://\u1E9E.com/").href).toBe("http://xn--zca.com/");
+    // Non-canonical special-scheme authority forms reach IDNA too.
+    expect(new URL("http:/\u1E9E.com/").href).toBe("http://xn--zca.com/");
+    expect(new URL("http:\\\\\u1E9E.com/").href).toBe("http://xn--zca.com/");
+    expect(new URL("\t//\u1E9E.com", "http://x/").href).toBe("http://xn--zca.com/");
+    // Same scheme as the base without "//" is relative-state (path, not host):
+    // the delta source stays percent-encoded verbatim.
+    expect(new URL("http:foo\u1E9E", "http://host/").pathname).toBe("/foo%E1%BA%9E");
+    // Cross-scheme reaches the authority state and IDNA runs.
+    expect(new URL("http:\u1E9E.com", "ftp://host/").href).toBe("http://xn--zca.com/");
+    // file: only has a host with exactly two slashes; ///x and /x are path.
+    expect(new URL("file:///\u1E9E.txt").pathname).toBe("/%E1%BA%9E.txt");
+    expect(new URL("file:/\u1E9E.txt").pathname).toBe("/%E1%BA%9E.txt");
+    expect(new URL("file://\u1E9E/x").host).toBe("xn--zca");
+    // Bracketed hosts go to the IPv6 parser, never IDNA.
+    expect(() => new URL("http://[::\u180E1]/")).toThrow();
+    // tab/LF/CR are stripped from anywhere in the input before parsing, so an
+    // embedded tab in the scheme or between : and // must not defeat the delta.
+    expect(new URL("ht\ttp://\u1E9E.com/").href).toBe("http://xn--zca.com/");
+    expect(new URL("http:\n//\u1E9E.com/").href).toBe("http://xn--zca.com/");
+    // The port span is left verbatim: an ignored-class delta source
+    // (U+180E) in the port must still fail the WHATWG port state, not be
+    // stripped into a valid digit run. The same char in the host is fine.
+    expect(() => new URL("http://foo:8\u180E0/")).toThrow();
+    expect(new URL("http://foo\u180E:80/").href).toBe("http://foo/");
+    // setter on a non-special scheme: opaque host stays verbatim.
+    const u = new URL("foo://x/");
+    u.hostname = "\u1E9E";
+    expect(u.hostname).toBe("%E1%BA%9E");
+    // url.host setter: delta applies to the host span only, port stays
+    // verbatim so an ignored-class code point there is not stripped into a
+    // valid digit run.
+    const h1 = new URL("http://x/");
+    h1.host = "foo:8\u206A0";
+    expect(h1.port).toBe("8");
+    const h2 = new URL("http://x/");
+    h2.host = "foo\u1E9E:81";
+    expect(h2.host).toBe("xn--foo-7ka:81");
+  });
+
   it("prints", () => {
+    // URL.prototype carries [Symbol.for("nodejs.util.inspect.custom")], so
+    // Bun.inspect matches node's util.inspect output.
     expect(Bun.inspect(new URL("https://example.com"))).toBe(`URL {
-  href: "https://example.com/",
-  origin: "https://example.com",
-  protocol: "https:",
-  username: "",
-  password: "",
-  host: "example.com",
-  hostname: "example.com",
-  port: "",
-  pathname: "/",
-  hash: "",
-  search: "",
-  searchParams: ${Bun.inspect(new URLSearchParams())},
-  toJSON: [Function: toJSON],
-  toString: [Function: toString],
+  href: 'https://example.com/',
+  origin: 'https://example.com',
+  protocol: 'https:',
+  username: '',
+  password: '',
+  host: 'example.com',
+  hostname: 'example.com',
+  port: '',
+  pathname: '/',
+  search: '',
+  searchParams: URLSearchParams {},
+  hash: ''
 }`);
 
     expect(
@@ -105,21 +184,56 @@ describe("url", () => {
         new URL("https://github.com/oven-sh/bun/issues/135?hello%20i%20have%20spaces%20thank%20you%20good%20night"),
       ),
     ).toBe(`URL {
-  href: "https://github.com/oven-sh/bun/issues/135?hello%20i%20have%20spaces%20thank%20you%20good%20night",
-  origin: "https://github.com",
-  protocol: "https:",
-  username: "",
-  password: "",
-  host: "github.com",
-  hostname: "github.com",
-  port: "",
-  pathname: "/oven-sh/bun/issues/135",
-  hash: "",
-  search: "?hello%20i%20have%20spaces%20thank%20you%20good%20night",
-  searchParams: URLSearchParams {\n    \"hello i have spaces thank you good night\": \"\",\n  },
-  toJSON: [Function: toJSON],
-  toString: [Function: toString],
+  href: 'https://github.com/oven-sh/bun/issues/135?hello%20i%20have%20spaces%20thank%20you%20good%20night',
+  origin: 'https://github.com',
+  protocol: 'https:',
+  username: '',
+  password: '',
+  host: 'github.com',
+  hostname: 'github.com',
+  port: '',
+  pathname: '/oven-sh/bun/issues/135',
+  search: '?hello%20i%20have%20spaces%20thank%20you%20good%20night',
+  searchParams: URLSearchParams { 'hello i have spaces thank you good night' => '' },
+  hash: ''
+}`);
+  });
+
+  it("URLContext offsets account for the /. pathname guard", () => {
+    // URL Standard section 4.5 step 3: null host + empty first path segment
+    // serializes with a /. guard the pathname getter omits, so offsets from
+    // pathname_start on are shifted by 2 in the href.
+    expect(util.inspect(new URL("foo:/.//?x"), { showHidden: true })).toBe(`URL {
+  href: 'foo:/.//?x',
+  origin: 'null',
+  protocol: 'foo:',
+  username: '',
+  password: '',
+  host: '',
+  hostname: '',
+  port: '',
+  pathname: '//',
+  search: '?x',
+  searchParams: URLSearchParams { 'x' => '' },
+  hash: '',
+  Symbol(context): URLContext {
+    href: 'foo:/.//?x',
+    protocol_end: 4,
+    username_end: 4,
+    host_start: 4,
+    host_end: 4,
+    pathname_start: 6,
+    search_start: 8,
+    hash_start: 4294967295,
+    port: 4294967295,
+    scheme_type: 1,
+    [hasPort]: [Getter],
+    [hasSearch]: [Getter],
+    [hasHash]: [Getter]
+  }
 }`);
+    // A path whose first segment merely starts with "." gets no guard.
+    expect(util.inspect(new URL("foo:/.foo"), { showHidden: true })).toContain("pathname_start: 4,");
   });
   it("works", () => {
     const inputs = [
diff --git a/test/js/web/workers/structured-clone.test.ts b/test/js/web/workers/structured-clone.test.ts
index e6a305671110..d78df66bcd49 100644
--- a/test/js/web/workers/structured-clone.test.ts
+++ b/test/js/web/workers/structured-clone.test.ts
@@ -586,13 +586,15 @@ function createBlob(arr: number[]): Blob {
 describe("structuredClone with ArrayBuffer larger than serialization buffer capacity", () => {
   // The serialization buffer is a WTF::Vector<uint8_t> capped at 2GiB. Cloning an
   // ArrayBuffer at or above that size must throw DataCloneError instead of aborting.
-  // Run in a subprocess so the ~2GiB allocation does not bloat the test runner.
-  for (const [label, expr] of [
-    ["ArrayBuffer", "new ArrayBuffer(2 ** 31)"],
-    ["resizable ArrayBuffer", "new ArrayBuffer(2 ** 31, { maxByteLength: 2 ** 31 + 1 })"],
-    ["SharedArrayBuffer", "new SharedArrayBuffer(2 ** 31)"],
-    ["growable SharedArrayBuffer", "new SharedArrayBuffer(2 ** 31, { maxByteLength: 2 ** 31 + 1 })"],
-    ["Uint8Array", "new Uint8Array(2 ** 31)"],
+  // SharedArrayBuffer shares its backing store (no serialization copy), so it
+  // succeeds regardless of size. Run in a subprocess so the ~2GiB allocation
+  // does not bloat the test runner.
+  for (const [label, expr, expected] of [
+    ["ArrayBuffer", "new ArrayBuffer(2 ** 31)", "DataCloneError"],
+    ["resizable ArrayBuffer", "new ArrayBuffer(2 ** 31, { maxByteLength: 2 ** 31 + 1 })", "DataCloneError"],
+    ["SharedArrayBuffer", "new SharedArrayBuffer(2 ** 31)", "SHARED"],
+    ["growable SharedArrayBuffer", "new SharedArrayBuffer(2 ** 31, { maxByteLength: 2 ** 31 + 1 })", "SHARED"],
+    ["Uint8Array", "new Uint8Array(2 ** 31)", "DataCloneError"],
   ] as const) {
     test(label, async () => {
       const script = `
@@ -604,8 +606,8 @@ describe("structuredClone with ArrayBuffer larger than serialization buffer capa
           process.exit(0);
         }
         try {
-          structuredClone(buf);
-          console.log("UNEXPECTED_SUCCESS");
+          const cloned = structuredClone(buf);
+          console.log(cloned instanceof SharedArrayBuffer && cloned.byteLength === buf.byteLength ? "SHARED" : "UNEXPECTED_SUCCESS");
         } catch (e) {
           console.log(e.name);
         }
@@ -617,7 +619,7 @@ describe("structuredClone with ArrayBuffer larger than serialization buffer capa
         stderr: "inherit",
       });
       const [stdout, exitCode] = await Promise.all([proc.stdout.text(), proc.exited]);
-      expect(["DataCloneError", "SKIP"]).toContain(stdout.trim());
+      expect([expected, "SKIP"]).toContain(stdout.trim());
       expect(exitCode).toBe(0);
     });
   }