@agoric/xsnap 0.14.3-dev-dcc80f2.0.dcc80f2 → 0.14.3-dev-4b83f24.0.4b83f24

package/README.md

@@ -18,6 +18,39 @@ await fs.writeFile('bootstrap.xss', worker.makeSnapshotStream());
 await worker.close();
 ```
 
+## Using CI-built binaries from `xsnap-worker-binaries`
+
+Before npm platform packages are wired, CI can consume binaries from GitHub
+releases in `Agoric/xsnap-worker-binaries`.
+
+From `packages/xsnap/`:
+
+```bash
+./scripts/use-github-release-binary.sh 0.0.0-dev /tmp/xsnap-release-assets
+source /tmp/xsnap-release-assets/xsnap-binary.env
+```
+
+This sets:
+
+- `XSNAP_WORKER` for release mode
+- `XSNAP_WORKER_DEBUG` for debug mode
+
+The script verifies SHA256 digests against the release manifest before writing
+the env file.
+
+## Package install behavior
+
+`@agoric/xsnap` postinstall now installs prebuilt binaries from GitHub releases
+instead of compiling native sources locally.
+
+Optional environment overrides:
+
+- `XSNAP_BINARY_VERSION` (default: package version)
+- `XSNAP_BINARY_REPO` (default: `Agoric/xsnap-worker-binaries`)
+- `XSNAP_BINARY_BASE_URL` (advanced override)
+- `XSNAP_BINARY_MANIFEST_SHA256` (required trust anchor for unpinned versions)
+- `XSNAP_CACHE_DIR` (advanced override for cached downloads)
+
 Some time later, possibly on a different computer…
 
 ```js

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agoric/xsnap",
-  "version": "0.14.3-dev-dcc80f2.0.dcc80f2",
+  "version": "0.14.3-dev-4b83f24.0.4b83f24",
   "description": "Snapshotting VM worker based on Moddable's XS Javascript engine",
   "author": "Agoric",
   "license": "Apache-2.0",
@@ -12,12 +12,10 @@
   },
   "scripts": {
     "repl": "node src/xsrepl.js",
-    "build:bin": "/bin/sh -c 'if test -d ./test; then node src/build.js; else yarn build:from-env; fi'",
-    "build:env": "/bin/sh -c 'node src/build.js --show-env > build.env.new && mv build.env.new build.env'",
-    "build:from-env": "{ cat build.env; echo node src/build.js; } | xargs env",
-    "build": "yarn build:bin && yarn build:env",
+    "install:prebuilt": "node src/install-prebuilt.js",
+    "build": "yarn install:prebuilt",
     "check-version": "/bin/sh -c 'if test \"${npm_package_version}\" != \"$(./scripts/get_xsnap_version.sh)\"; then echo \"xsnap version mismatch; expected '${npm_package_version}'\"; exit 1; fi'",
-    "postinstall": "npm run build:from-env",
+    "postinstall": "npm run install:prebuilt",
     "clean": "rm -rf xsnap-native/xsnap/build",
     "lint": "yarn run -T run-s --continue-on-error 'lint:*'",
     "lint:eslint": "yarn run -T eslint 'src/**/*.js' 'test/**/*.js' api.js",
@@ -28,8 +26,8 @@
     "test:xs": "exit 0"
   },
   "dependencies": {
-    "@agoric/internal": "0.3.3-dev-dcc80f2.0.dcc80f2",
-    "@agoric/xsnap-lockdown": "0.14.1-dev-dcc80f2.0.dcc80f2",
+    "@agoric/internal": "0.3.3-dev-4b83f24.0.4b83f24",
+    "@agoric/xsnap-lockdown": "0.14.1-dev-4b83f24.0.4b83f24",
     "@endo/bundle-source": "^4.1.2",
     "@endo/errors": "^1.2.13",
     "@endo/eventual-send": "^1.3.4",
@@ -51,16 +49,8 @@
   "files": [
     "LICENSE*",
     "api.js",
-    "build.env",
-    "moddable/modules/data/**",
-    "moddable/xs/includes/**",
-    "moddable/xs/makefiles/**",
-    "moddable/xs/sources/**",
-    "moddable/xs/platforms/*.h",
     "scripts/**",
-    "src/**",
-    "xsnap-native/xsnap/makefiles/**",
-    "xsnap-native/xsnap/sources/**"
+    "src/**"
   ],
   "publishConfig": {
     "access": "public"
@@ -80,5 +70,5 @@
   "engines": {
     "node": "^20.9 || ^22.11"
   },
-  "gitHead": "dcc80f24250a2f7221c8ffbc913d6f289c366313"
+  "gitHead": "4b83f243d627e8214b1b33338566dff420259339"
 }

package/scripts/use-github-release-binary.sh

@@ -0,0 +1,160 @@
+#!/usr/bin/env bash
+
+set -euo pipefail
+
+version="${1:-}"
+out_dir="${2:-}"
+repo="${XSNAP_BINARY_REPO:-Agoric/xsnap-worker-binaries}"
+
+if [[ -z "$version" || -z "$out_dir" ]]; then
+  echo "Usage: $0 <version> <output-dir>" >&2
+  echo "Environment:" >&2
+  echo "  XSNAP_BINARY_REPO (default: Agoric/xsnap-worker-binaries)" >&2
+  echo "  XSNAP_ENV_FILE (default: <output-dir>/xsnap-binary.env)" >&2
+  exit 1
+fi
+
+mkdir -p "$out_dir"
+tag="v$version"
+tarball="xsnap-worker-binaries-$version.tar.gz"
+manifest_name="xsnap-worker-manifest-$version.json"
+env_file="${XSNAP_ENV_FILE:-$out_dir/xsnap-binary.env}"
+
+case "$(uname -s)" in
+  Linux) os="linux" ;;
+  Darwin) os="darwin" ;;
+  *)
+    echo "Unsupported host OS: $(uname -s)" >&2
+    exit 1
+    ;;
+esac
+
+case "$(uname -m)" in
+  x86_64|amd64) arch="x64" ;;
+  arm64|aarch64) arch="arm64" ;;
+  *)
+    echo "Unsupported host architecture: $(uname -m)" >&2
+    exit 1
+    ;;
+esac
+
+target="$os-$arch"
+
+gh release download "$tag" \
+  --repo "$repo" \
+  --pattern "$tarball" \
+  --pattern "$manifest_name" \
+  --dir "$out_dir"
+
+release_entry="dist/$target/release/xsnap-worker"
+debug_entry="dist/$target/debug/xsnap-worker"
+found_release=false
+found_debug=false
+
+mapfile -t tar_entries < <(tar -tvzf "$out_dir/$tarball")
+for line in "${tar_entries[@]}"; do
+  [[ -n "$line" ]] || continue
+  type="${line:0:1}"
+  entry="${line##* }"
+  entry="${entry%/}"
+  if [[ -z "$entry" || "$entry" = /* || "$entry" == *'\'* ]]; then
+    echo "Refusing to extract unsafe archive path: $entry" >&2
+    exit 1
+  fi
+  IFS='/' read -r -a parts <<<"$entry"
+  for part in "${parts[@]}"; do
+    if [[ "$part" == ".." ]]; then
+      echo "Refusing to extract archive path traversal: $entry" >&2
+      exit 1
+    fi
+  done
+  allowed=false
+  for expected in "${expected_entries[@]}"; do
+    if [[ "$entry" == "$expected" ]]; then
+      allowed=true
+      break
+    fi
+  done
+  if [[ "$allowed" != true ]]; then
+    echo "Refusing to extract unexpected archive path: $entry" >&2
+    exit 1
+  fi
+  if [[ "$type" != "-" && "$type" != "d" ]]; then
+    echo "Refusing to extract non-regular archive entry: $entry" >&2
+    exit 1
+  fi
+
+  if [[ "$entry" == "$release_entry" ]]; then
+    found_release=true
+  fi
+  if [[ "$entry" == "$debug_entry" ]]; then
+    found_debug=true
+  fi
+done
+
+if [[ "$found_release" != true || "$found_debug" != true ]]; then
+  echo "Missing binaries for target $target in release bundle" >&2
+  exit 1
+fi
+
+tar -xzf "$out_dir/$tarball" -C "$out_dir" "$release_entry" "$debug_entry"
+
+release_bin="$out_dir/dist/$target/release/xsnap-worker"
+debug_bin="$out_dir/dist/$target/debug/xsnap-worker"
+
+if [[ ! -f "$release_bin" || ! -f "$debug_bin" ]]; then
+  echo "Missing binaries for target $target in release bundle" >&2
+  exit 1
+fi
+
+chmod +x "$release_bin" "$debug_bin"
+
+manifest_path="$out_dir/$manifest_name"
+
+release_expected="$(
+  node -e '
+    const fs = require("fs");
+    const manifest = JSON.parse(fs.readFileSync(process.argv[1], "utf8"));
+    const target = process.argv[2];
+    process.stdout.write(manifest.targets[target].release.sha256);
+  ' "$manifest_path" "$target"
+)"
+
+debug_expected="$(
+  node -e '
+    const fs = require("fs");
+    const manifest = JSON.parse(fs.readFileSync(process.argv[1], "utf8"));
+    const target = process.argv[2];
+    process.stdout.write(manifest.targets[target].debug.sha256);
+  ' "$manifest_path" "$target"
+)"
+
+sha256_file() {
+  local path="$1"
+  if command -v sha256sum >/dev/null 2>&1; then
+    sha256sum "$path" | awk '{print $1}'
+  else
+    shasum -a 256 "$path" | awk '{print $1}'
+  fi
+}
+
+release_actual="$(sha256_file "$release_bin")"
+debug_actual="$(sha256_file "$debug_bin")"
+
+if [[ "$release_expected" != "$release_actual" ]]; then
+  echo "Release binary hash mismatch for $target" >&2
+  exit 1
+fi
+
+if [[ "$debug_expected" != "$debug_actual" ]]; then
+  echo "Debug binary hash mismatch for $target" >&2
+  exit 1
+fi
+
+cat >"$env_file" <<EOF
+XSNAP_WORKER=$release_bin
+XSNAP_WORKER_DEBUG=$debug_bin
+EOF
+
+echo "Prepared xsnap binaries for $target"
+echo "Env file: $env_file"

package/src/install-prebuilt.js

@@ -0,0 +1,358 @@
+#!/usr/bin/env node
+/* eslint-env node */
+
+import { createHash } from 'crypto';
+import fsTop from 'fs';
+import osTop from 'os';
+import pathTop from 'path';
+import { fileURLToPath } from 'url';
+import * as childProcess from 'child_process';
+import { manifestHashes } from './prebuilt-manifest-sha256.js';
+
+/**
+ * @import {promises as fsPromises} from 'fs';
+ * @import {spawn} from 'child_process';
+ * @import {ReadStream} from 'fs';
+ */
+
+/** @param {string} path */
+const asset = path => fileURLToPath(new URL(path, import.meta.url));
+
+/**
+ * @param {string} osType
+ * @param {string} arch
+ */
+export const mapOsArchToTarget = (osType, arch) => {
+  const osName = {
+    Linux: 'linux',
+    Darwin: 'darwin',
+  }[osType];
+  if (!osName) {
+    throw Error(`Unsupported OS for prebuilt xsnap: ${osType}`);
+  }
+
+  const archName = {
+    x64: 'x64',
+    arm64: 'arm64',
+    amd64: 'x64',
+    aarch64: 'arm64',
+  }[arch];
+  if (!archName) {
+    throw Error(`Unsupported architecture for prebuilt xsnap: ${arch}`);
+  }
+
+  return `${osName}-${archName}`;
+};
+
+/** @param {string} target */
+export const targetToBuildPlatform = target => {
+  if (target.startsWith('linux-')) {
+    return 'lin';
+  }
+  if (target.startsWith('darwin-')) {
+    return 'mac';
+  }
+  throw Error(`Unsupported target for build platform mapping: ${target}`);
+};
+
+/**
+ * @param {string} command
+ * @param {string[]} args
+ * @param {{ cwd?: string }} [opts]
+ */
+const run = (command, args, opts = {}) =>
+  new Promise((resolve, reject) => {
+    const child = childProcess.spawn(command, args, {
+      cwd: opts.cwd || '.',
+      stdio: ['ignore', 'inherit', 'inherit'],
+    });
+    child.once('error', reject);
+    child.once('exit', code => {
+      if (code === 0) {
+        resolve(undefined);
+      } else {
+        reject(Error(`${command} exited with code ${code}`));
+      }
+    });
+  });
+
+/**
+ * @param {string} command
+ * @param {string[]} args
+ * @param {{ cwd?: string }} [opts]
+ * @returns {Promise<string>}
+ */
+const capture = (command, args, opts = {}) =>
+  new Promise((resolve, reject) => {
+    const child = childProcess.spawn(command, args, {
+      cwd: opts.cwd || '.',
+      stdio: ['ignore', 'pipe', 'inherit'],
+    });
+    let stdout = '';
+    child.stdout.setEncoding('utf8');
+    child.stdout.on('data', chunk => {
+      stdout += chunk;
+    });
+    child.once('error', reject);
+    child.once('exit', code => {
+      if (code === 0) {
+        resolve(stdout);
+      } else {
+        reject(Error(`${command} exited with code ${code}`));
+      }
+    });
+  });
+
+/**
+ * @param {string} url
+ * @param {string} destPath
+ */
+const downloadFile = async (url, destPath) => {
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw Error(`Download failed for ${url}: HTTP ${res.status}`);
+  }
+  if (!res.body) {
+    throw Error(`Download failed for ${url}: missing response body`);
+  }
+
+  await fsTop.promises.mkdir(pathTop.dirname(destPath), { recursive: true });
+  await fsTop.promises.writeFile(
+    destPath,
+    Buffer.from(await res.arrayBuffer()),
+  );
+};
+
+/**
+ * @param {string} path
+ * @returns {Promise<string>}
+ */
+const sha256File = async path => {
+  const hash = createHash('sha256');
+  await new Promise((resolve, reject) => {
+    const stream = fsTop.createReadStream(path);
+    stream.once('error', reject);
+    stream.on('data', chunk => hash.update(chunk));
+    stream.once('end', resolve);
+  });
+  return hash.digest('hex');
+};
+
+/**
+ * @param {string} manifestPath
+ * @param {string} target
+ * @returns {Promise<{ release: string, debug: string }>}
+ */
+const readExpectedHashes = async (manifestPath, target) => {
+  const text = await fsTop.promises.readFile(manifestPath, 'utf8');
+  const manifest = JSON.parse(text);
+  const entry = manifest?.targets?.[target];
+  if (!entry?.release?.sha256 || !entry?.debug?.sha256) {
+    throw Error(`Manifest missing hashes for target ${target}`);
+  }
+  return {
+    release: entry.release.sha256,
+    debug: entry.debug.sha256,
+  };
+};
+
+const getDefaultCacheRoot = () => {
+  if (process.platform === 'darwin') {
+    return pathTop.join(osTop.homedir(), 'Library', 'Caches', 'agoric-sdk');
+  }
+  return pathTop.join(
+    process.env.XDG_CACHE_HOME || pathTop.join(osTop.homedir(), '.cache'),
+    'agoric-sdk',
+  );
+};
+
+/** @param {string} entry */
+const isSafeTarEntry = entry =>
+  entry !== '' &&
+  !pathTop.isAbsolute(entry) &&
+  !entry.split('/').includes('..') &&
+  !entry.includes('\\');
+
+/**
+ * @param {string} tarballPath
+ * @param {string[]} expectedFiles
+ */
+const validateTarball = async (tarballPath, expectedFiles) => {
+  const remaining = new Set(expectedFiles);
+  const listing = await capture('tar', ['-tvzf', tarballPath]);
+  for (const line of listing.split('\n')) {
+    if (!line) {
+      continue;
+    }
+    const type = line[0];
+    const rawEntry = line.split(/\s+/).at(-1) || '';
+    const entry = rawEntry.replace(/\/$/, '');
+    if (!isSafeTarEntry(entry)) {
+      throw Error(`Refusing to extract unsafe archive path: ${rawEntry}`);
+    }
+    if (type !== 'd' && type !== '-') {
+      throw Error(`Refusing to extract non-regular archive entry: ${rawEntry}`);
+    }
+    remaining.delete(entry);
+  }
+  if (remaining.size > 0) {
+    throw Error(
+      `Archive missing expected xsnap binaries: ${Array.from(remaining).join(', ')}`,
+    );
+  }
+};
+
+/**
+ * @param {string} version
+ * @param {NodeJS.ProcessEnv} env
+ */
+const getExpectedManifestHash = (version, env) => {
+  const expected = env.XSNAP_BINARY_MANIFEST_SHA256 || manifestHashes[version];
+  if (!expected) {
+    throw Error(
+      `Missing trusted manifest hash for xsnap binary version ${version}; set XSNAP_BINARY_MANIFEST_SHA256 for explicit overrides`,
+    );
+  }
+  return expected;
+};
+
+const main = async () => {
+  const env = process.env;
+  if (env.XSNAP_WORKER) {
+    console.log('XSNAP_WORKER is set; skipping prebuilt binary install');
+    return;
+  }
+
+  const version = env.XSNAP_BINARY_VERSION || env.npm_package_version;
+  if (!version) {
+    throw Error(
+      'Missing XSNAP_BINARY_VERSION and npm_package_version; cannot resolve prebuilt release',
+    );
+  }
+
+  const repo = env.XSNAP_BINARY_REPO || 'Agoric/xsnap-worker-binaries';
+  const base =
+    env.XSNAP_BINARY_BASE_URL ||
+    `https://github.com/${repo}/releases/download/v${version}`;
+
+  const target = mapOsArchToTarget(osTop.type(), osTop.arch());
+  const platform = targetToBuildPlatform(target);
+
+  const tarballName = `xsnap-worker-binaries-${version}.tar.gz`;
+  const manifestName = `xsnap-worker-manifest-${version}.json`;
+
+  const cacheRoot = pathTop.join(
+    env.XSNAP_CACHE_DIR || getDefaultCacheRoot(),
+    'xsnap',
+    'prebuilt',
+    version,
+  );
+  const tarballPath = pathTop.join(cacheRoot, tarballName);
+  const manifestPath = pathTop.join(cacheRoot, manifestName);
+  const extractRoot = pathTop.join(cacheRoot, 'bundle');
+  const expectedManifestHash = getExpectedManifestHash(version, env);
+
+  const releaseSrc = pathTop.join(
+    extractRoot,
+    `dist/${target}/release/xsnap-worker`,
+  );
+  const debugSrc = pathTop.join(
+    extractRoot,
+    `dist/${target}/debug/xsnap-worker`,
+  );
+  const expectedArchiveFiles = [
+    `dist/${target}/release/xsnap-worker`,
+    `dist/${target}/debug/xsnap-worker`,
+  ];
+
+  await fsTop.promises.mkdir(cacheRoot, { recursive: true });
+
+  const releaseDest = asset(
+    `../xsnap-native/xsnap/build/bin/${platform}/release/xsnap-worker`,
+  );
+  const debugDest = asset(
+    `../xsnap-native/xsnap/build/bin/${platform}/debug/xsnap-worker`,
+  );
+
+  const [manifestAvailable, releaseAvailable, debugAvailable] =
+    await Promise.allSettled([
+      sha256File(manifestPath),
+      sha256File(releaseDest),
+      sha256File(debugDest),
+    ]);
+  if (
+    manifestAvailable.status === 'fulfilled' &&
+    manifestAvailable.value === expectedManifestHash &&
+    releaseAvailable.status === 'fulfilled' &&
+    debugAvailable.status === 'fulfilled'
+  ) {
+    const { release: releaseExpected, debug: debugExpected } =
+      await readExpectedHashes(manifestPath, target);
+    if (
+      releaseAvailable.value === releaseExpected &&
+      debugAvailable.value === debugExpected
+    ) {
+      console.log(
+        `Using cached prebuilt xsnap binaries for ${target} (${version})`,
+      );
+      return;
+    }
+  }
+
+  await downloadFile(`${base}/${manifestName}`, manifestPath);
+  const manifestHash = await sha256File(manifestPath);
+  if (manifestHash !== expectedManifestHash) {
+    throw Error(`Manifest hash mismatch for xsnap binary version ${version}`);
+  }
+
+  await downloadFile(`${base}/${tarballName}`, tarballPath);
+  await validateTarball(tarballPath, expectedArchiveFiles);
+
+  await fsTop.promises.rm(extractRoot, { recursive: true, force: true });
+  await fsTop.promises.mkdir(extractRoot, { recursive: true });
+  await run('tar', [
+    '-xzf',
+    tarballPath,
+    '-C',
+    extractRoot,
+    ...expectedArchiveFiles,
+  ]);
+
+  const [
+    { release: releaseExpected, debug: debugExpected },
+    releaseActual,
+    debugActual,
+  ] = await Promise.all([
+    readExpectedHashes(manifestPath, target),
+    sha256File(releaseSrc),
+    sha256File(debugSrc),
+  ]);
+
+  if (releaseExpected !== releaseActual) {
+    throw Error(`Release binary hash mismatch for ${target}`);
+  }
+  if (debugExpected !== debugActual) {
+    throw Error(`Debug binary hash mismatch for ${target}`);
+  }
+
+  await fsTop.promises.mkdir(pathTop.dirname(releaseDest), { recursive: true });
+  await fsTop.promises.mkdir(pathTop.dirname(debugDest), { recursive: true });
+  await fsTop.promises.copyFile(releaseSrc, releaseDest);
+  await fsTop.promises.copyFile(debugSrc, debugDest);
+  await fsTop.promises.chmod(releaseDest, 0o755);
+  await fsTop.promises.chmod(debugDest, 0o755);
+
+  console.log(`Installed prebuilt xsnap binaries for ${target} (${version})`);
+};
+
+const isMain =
+  process.argv[1] &&
+  pathTop.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+
+if (isMain) {
+  main().catch(err => {
+    console.error('Failed to install prebuilt xsnap binaries');
+    console.error(err);
+    process.exit(1);
+  });
+}

package/src/prebuilt-manifest-sha256.js

@@ -0,0 +1,3 @@
+export const manifestHashes = {
+  '0.14.2': '377030e37b10554e73d0aff655639051d33281c9e17e7da98275fb9efcaae6f2',
+};

package/src/xsnap.js

@@ -44,6 +44,46 @@ const { freeze } = Object;
 
 const noop = freeze(() => {});
 
+/**
+ * Resolve the xsnap worker binary path.
+ *
+ * `XSNAP_WORKER` may override both modes.
+ * `XSNAP_WORKER_DEBUG` overrides debug mode only.
+ *
+ * @param {{
+ *   os: string,
+ *   debug: boolean,
+ *   env: Record<string, string | undefined>,
+ * }} options
+ */
+export function resolveXsnapWorkerPath({ os, debug, env }) {
+  const platform = {
+    Linux: 'lin',
+    Darwin: 'mac',
+    // Windows_NT: 'win', // One can dream.
+  }[os];
+
+  if (platform === undefined) {
+    throw Error(`xsnap does not support platform ${os}`);
+  }
+
+  if (debug && env.XSNAP_WORKER_DEBUG) {
+    return env.XSNAP_WORKER_DEBUG;
+  }
+  if (env.XSNAP_WORKER) {
+    return env.XSNAP_WORKER;
+  }
+
+  return fileURLToPath(
+    new URL(
+      `../xsnap-native/xsnap/build/bin/${platform}/${
+        debug ? 'debug' : 'release'
+      }/xsnap-worker`,
+      import.meta.url,
+    ),
+  );
+}
+
 /**
  * @param {Uint8Array} arg
  * @returns {Uint8Array}
@@ -169,24 +209,7 @@ export async function xsnap(options) {
     env = process.env,
   } = options;
 
-  const platform = {
-    Linux: 'lin',
-    Darwin: 'mac',
-    // Windows_NT: 'win', // One can dream.
-  }[os];
-
-  if (platform === undefined) {
-    throw Error(`xsnap does not support platform ${os}`);
-  }
-
-  let bin = fileURLToPath(
-    new URL(
-      `../xsnap-native/xsnap/build/bin/${platform}/${
-        debug ? 'debug' : 'release'
-      }/xsnap-worker`,
-      import.meta.url,
-    ),
-  );
+  let bin = resolveXsnapWorkerPath({ os, debug, env });
 
   /** @type {PromiseKit<void>} */
   const vatExit = makePromiseKit();

package/build.env

@@ -1,4 +0,0 @@
-MODDABLE_URL=https://github.com/agoric-labs/moddable.git
-MODDABLE_COMMIT_HASH=f6c5951fc055e4ca592b9166b9ae3cbb9cca6bf0
-XSNAP_NATIVE_URL=https://github.com/agoric-labs/xsnap-pub
-XSNAP_NATIVE_COMMIT_HASH=105bc6862050695b1723fa76df91564fe8111a37