diff --git a/.gitignore b/.gitignore
index 8236bc4..618d2d1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,3 +2,8 @@ dist-newstyle/
 node_modules/
 .stack-work/
 .ccls-cache/
+
+adminpass.txt
+secretkey.txt
+pubkey.txt
+trustedkeys.txt
diff --git a/play-haskell-server/example-snippets.txt b/play-haskell-server/example-snippets.txt
index b5e09c8..2ccbaf8 100644
--- a/play-haskell-server/example-snippets.txt
+++ b/play-haskell-server/example-snippets.txt
@@ -1,99 +1,70 @@
-import Data.List (partition)
+module Project where
+import Control.LinearlyVersionedMonad qualified as LVM
+import Prelude.YulDSL
+
+-- | Ethereum contract is a Yul Object in Yolc.
+object = mkYulObject "ERC20" emptyCtor
+  [ staticFn "balanceOf" erc20_balance_of
+  , omniFn   "mint" erc20_mint
+  , omniFn   "transfer" erc20_transfer
+  ]
+
+-- | ERC20 balance storage location for the account.
+--
+-- TODO: this code can be made more palatable in the future versions of Yolc.
+erc20_balance_storage_of = fn @(ADDR -> B32) $locId $
+  \acc -> yulKeccak256 $
+          -- shell$ cast keccak "Yolc.Demo.ERC20.Storage.AccountBalance"
+          (YulEmb (0xc455e3e95e9cd89a306d7619bc5f6406a85b850d31788d0c0fb15e6364be6592 :: U256))
+          `YulFork` acc
+
+balance_ref_of account'p = ver'l $ callFn'lpp erc20_balance_storage_of account'p
+
+balance_of account'p = sget $ balance_ref_of account'p
+
+-- | ERC20 balance of the account.
+erc20_balance_of = lfn $locId $ yulmonad'p @(ADDR -> U256)
+  \account'p -> balance_of account'p
+
+erc20_mint = lfn $locId $ yulmonad'p @(ADDR -> U256 -> ())
+  \account'p mintAmount'p -> LVM.do
+  -- fetch balance of the account
+  (account'p, balanceBefore) <- pass account'p balance_of
+  -- use linear port (naming convention, "*'p") values safely
+  (account'p, mintAmount'p) <- passN_ (account'p, mintAmount'p) \(account'p, mintAmount'p) ->
+    -- update balance
+    sput (balance_ref_of account'p) (balanceBefore + ver'l mintAmount'p)
+  -- call unsafe external contract onTokenMinted
+  externalCall onTokenMinted (ver'l account'p) (ver'l mintAmount'p)
+
+  -- -- fetch balance of the account
+  -- (account'p, balanceBefore) <- pass account'p balance_of
+  -- -- use linear port (naming convention, "*'p") values safely
+  -- (account'p, mintAmount'p) <- passN_ (account'p, mintAmount'p) \(account'p, mintAmount'p) ->
+  --   -- call unsafe external contract onTokenMinted
+  --   externalCall onTokenMinted (ver'l account'p) (ver'l mintAmount'p)
+  -- -- update balance, but using out dated "balanceBefore value" will fail to compile
+  -- sput (balance_ref_of account'p) (balanceBefore + ver'l mintAmount'p)
+
+erc20_transfer = lfn $locId $ yulmonad'p @(ADDR -> ADDR -> U256 -> BOOL)
+  \from'p to'p amount'p -> LVM.do
+  -- get sender balance
+  (from'p, senderBalanceRef) <- pass from'p (ypure . balance_ref_of)
+  -- get receiver balance
+  (to'p, receiverBalanceRef) <- pass to'p (ypure . balance_ref_of)
+  -- calculate new balances
+  (amount, newSenderBalance) <- pass (ver'l amount'p)
+    \amount -> ypure $ callFn'l erc20_balance_of (ver'l from'p) - amount
+  newReceiverBalance <- with amount
+    \amount -> ypure $ callFn'l erc20_balance_of (ver'l to'p) + amount
+  -- update storages
+  sputs $
+    senderBalanceRef   := newSenderBalance   :|
+    receiverBalanceRef := newReceiverBalance : []
+  -- always return true as a silly urban-legendary ERC20 convention
+  embed true
+
+-- TODO: to be abstracted in an interface definition
+--
+onTokenMinted = declareExternalFn @(U256 -> ()) "onTokenMinted"
 
-main :: IO ()
-main = do
-  let unsorted = [10,9..1]
-  putStrLn $ show $ quicksort unsorted
-
-quicksort :: Ord a => [a] -> [a]
-quicksort []     = []
-quicksort (x:xs) = let (lesser, greater) = partition (<= x) xs
-                   in quicksort lesser ++ [x] ++ quicksort greater
-
--- ~~~~ CUT
-
-{-# LANGUAGE OverloadedStrings #-}
-
-import qualified Data.Text as T
-import qualified Data.Time as Time
-
-data Visitor
-  = Member Profile
-  | NonMember (Maybe T.Text)
-  deriving Show
-
-data Profile =
-  Profile
-    { name :: T.Text
-    , birthday :: Time.Day
-    } deriving Show
-
-main :: IO ()
-main = do
-  let haskell = Member Profile
-        { name = "Haskell Curry"
-        , birthday = read "1900-09-12"
-        }
-  greeting <- makeGreeting haskell
-  putStrLn $ T.unpack greeting
-
-makeGreeting :: Visitor -> IO T.Text
-makeGreeting visitor =
-  case visitor of
-    NonMember maybeName ->
-      pure $ case maybeName of
-        Just name -> "Hello, " <> name <> "!"
-        Nothing   -> "Hello, mysterious visitor!"
-    Member profile -> do
-      today <- Time.utctDay <$> Time.getCurrentTime
-      let monthAndDay = (\(_y, m, d) -> (m, d)) . Time.toGregorian
-      if monthAndDay today == monthAndDay (birthday profile)
-      then pure $ "Happy birthday, " <> name profile <> "!"
-      else pure $ "Welcome back, " <> name profile <> "!"
-
--- ~~~~ CUT
-
-import Control.Monad (replicateM)
-import Data.Foldable (foldl')
-import qualified System.Random.Stateful as Rand
-
-data Drone = Drone
-  { xPos :: Int
-  , yPos :: Int
-  , zPos :: Int
-  } deriving Show
-
-data Movement
-  = Forward | Back | ToLeft | ToRight | Up | Down
-  deriving (Show, Enum, Bounded)
-
-main :: IO ()
-main = do
-  let initDrone = Drone { xPos = 0, yPos = 100, zPos = 0 }
-  -- Generate 15 moves randomly
-  randomMoves <- replicateM 15 $ Rand.uniformEnumM Rand.globalStdGen
-  let resultDrone = foldl' moveDrone initDrone randomMoves
-  print resultDrone
-
-moveDrone :: Drone -> Movement -> Drone
-moveDrone drone move =
-  case move of
-    Forward -> drone { zPos = zPos drone + 1 }
-    Back    -> drone { zPos = zPos drone - 1 }
-    ToLeft  -> drone { xPos = xPos drone - 1 }
-    ToRight -> drone { xPos = xPos drone + 1 }
-    Up      -> drone { yPos = yPos drone + 1 }
-    Down    -> drone { yPos = yPos drone - 1 }
-
--- ~~~~ CUT
--- ~~~~ # adapted from @liamzee's https://github.com/haskript/big-book-of-small-haskell-projects/blob/51fd3ac4db30e9df2f14924d66d1469638aed009/35.HexGrid/HexGrid.hs
-
-main :: IO ()
-main = putStr $ unlines $ hexagons 12 17
-
-hexagons :: Int -> Int -> [String]
-hexagons xRepeat yRepeat =
-  yRepeat `times` [xRepeat `times` "/ \\_"
-                  ,xRepeat `times` "\\_/ "]
-  where
-    n `times` l = concat (replicate n l)
diff --git a/play-haskell-server/play.mustache b/play-haskell-server/play.mustache
index a311d82..a2d460b 100644
--- a/play-haskell-server/play.mustache
+++ b/play-haskell-server/play.mustache
@@ -3,8 +3,8 @@
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1">
-<link rel="icon" type="image/png" href="/haskell-play-logo.png">
-<title>Haskell Playground</title>
+<link rel="icon" type="image/png" href="https://yolc.dev/yolc-logo-256x256.png">
+<title>Yolc Playground</title>
 <style>
 html, body {
 	margin: 0;
@@ -460,11 +460,12 @@ preload_ghcopt = {{&preload_ghcopt}};
 	</dialog>
 
 	<div id="header">
-		<img id="title" src="/haskell-logo-tw.svg">
+		<img id="title" src="https://yolc.dev/yolc-logo-256x256.png">
 		<div id="toolbar">
-			<button id="btn-run" class="pure-button">Run</button>
+			<button id="btn-yolc" class="pure-button">Generate Solidity/Yul</button>
+			<!-- <button id="btn-run" class="pure-button">Run</button>
 			<button id="btn-core" class="pure-button">Core</button>
-			<button id="btn-asm" class="pure-button">Asm</button>
+			<button id="btn-asm" class="pure-button">Asm</button> -->
 			<select id="ghcversionselect"></select>
 			<select id="optselect"></select>
 			<button id="btn-save" class="pure-button">Save &amp; share code</button>
diff --git a/play-haskell-server/static/play-index.ts b/play-haskell-server/static/play-index.ts
index 2cdd7d0..51e2933 100644
--- a/play-haskell-server/static/play-index.ts
+++ b/play-haskell-server/static/play-index.ts
@@ -462,15 +462,14 @@ window.addEventListener("load", function() {
 			editor.commands.platform == "mac"
 				? "Press Cmd-Enter to run again"
 				: "Press Ctrl-Enter to run again";
-	document.getElementById("btn-run").setAttribute("title", runTooltip);
-	document.getElementById("btn-core").setAttribute("title", runTooltip);
-	document.getElementById("btn-asm").setAttribute("title", runTooltip);
+	// document.getElementById("btn-run").setAttribute("title", runTooltip);
+	// document.getElementById("btn-core").setAttribute("title", runTooltip);
+	// document.getElementById("btn-asm").setAttribute("title", runTooltip);
 
 	if (editor.commands.platform == "mac") {
 		const l = document.getElementsByClassName("ui-ctrl-cmd");
 		for (let i = 0; i < l.length; i++) l[i].innerHTML = "Cmd";
 	}
-
 	getVersions(function(versions) {
 		const initialGHCver =
 			preload_ghcver == null
@@ -519,9 +518,10 @@ window.addEventListener("load", function() {
 	editor.focus();
 });
 
-document.getElementById("btn-run").addEventListener('click', () => { doRun("run") });
-document.getElementById("btn-core").addEventListener('click', () => { doRun("core") });
-document.getElementById("btn-asm").addEventListener('click', () => { doRun("asm") });
+document.getElementById("btn-yolc").addEventListener('click', () => { doRun("run") });
+// document.getElementById("btn-run").addEventListener('click', () => { doRun("run") });
+// document.getElementById("btn-core").addEventListener('click', () => { doRun("core") });
+// document.getElementById("btn-asm").addEventListener('click', () => { doRun("asm") });
 document.getElementById("btn-save").addEventListener('click', () => { doSave() });
 document.getElementById("btn-close-save-alert").addEventListener('click', () => {
 	(document.getElementById("save-alert") as HTMLDialogElement).close();
diff --git a/play-haskell-types/src/PlayHaskellTypes/Constants.hs b/play-haskell-types/src/PlayHaskellTypes/Constants.hs
index 80f35cb..6185bad 100644
--- a/play-haskell-types/src/PlayHaskellTypes/Constants.hs
+++ b/play-haskell-types/src/PlayHaskellTypes/Constants.hs
@@ -3,4 +3,4 @@ module PlayHaskellTypes.Constants where
 
 
 runTimeoutMicrosecs :: Int
-runTimeoutMicrosecs = 5_000_000
+runTimeoutMicrosecs = 10_000_000
diff --git a/play-haskell-worker/bwrap-files/mkyolcscript.sh b/play-haskell-worker/bwrap-files/mkyolcscript.sh
new file mode 100755
index 0000000..e671b0c
--- /dev/null
+++ b/play-haskell-worker/bwrap-files/mkyolcscript.sh
@@ -0,0 +1,175 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+cd "$(dirname "$0")"
+
+outdir="builders"
+
+function usage() {
+  echo >&2 "Usage: $0 [-t] <yul-dsl-monorepo dir>"
+  echo >&2 "Will create temporary cabal project in $workdir/ghc-<version>/ and"
+  echo >&2 "write build script to $outdir/build-<version>.sh"
+  echo >&2 "If [dependencies] is given, these override the dependency list in"
+  echo >&2 "this script."
+  echo >&2 "  -t   Test mode: stop after writing a freeze file"
+  exit 1
+}
+
+test_mode=0
+ghcversion="9.12.2"
+
+function parse_args() {
+  local num_wordargs_given=0
+
+  for arg; do
+    case "$arg" in
+      -t)
+        test_mode=1; ;;
+      *)
+        case "$num_wordargs_given" in
+          0) yuldsldir="$arg"; ;;
+          *) usage; ;;
+        esac
+        num_wordargs_given=$((num_wordargs_given + 1))
+        ;;
+    esac
+  done
+
+  if [[ $num_wordargs_given -lt 1 ]]; then usage; fi
+}
+
+parse_args "$@"
+
+yolc_ver=$(cd "$yuldsldir" && git rev-parse --short HEAD)
+
+outscript="$outdir/build-Yolc-${yolc_ver}.sh"
+
+workdir="builderprojs/yolc-${yolc_ver}"
+projdir="$workdir/yul-dsl-proj"
+mkdir -p "${workdir}"
+
+printf "\x1B[1m[mkyolcscript] Setting up cabal project directory in %s\x1B[0m\n" "$projdir"
+
+rsync --verbose --archive --exclude=dist-newstyle --delete "$yuldsldir"/ "$projdir"
+
+printf "\x1B[1m[mkyolcscript] Building cabal project\x1B[0m\n"
+
+# TODO: deduplicate between this code and stage-2.sh
+
+chroot="ubuntu-base"
+ghcup_base=$(ghcup whereis basedir)
+
+# These are symlinks to the corresponding folder in /usr in the ubuntu chroot.
+# Just --ro-bind'ing them doesn't work because then the readlink() that gcc
+# does on /bin will fail, and its include path detection will not work
+# correctly (and for example miss c++ include paths, necessary to build
+# simdjson in the Haskell 'text' library). So handle these symlinks correctly.
+#
+# Actually, this should also include /lib64. But if we include that (and remove
+# the corresponding --ro-bind below in args[]), then nothing works: launching
+# /bin/bash says ENOENT, probably referring to the loader not finding some
+# library. I dunno, but it works like this now. Magic.
+chroot_symlinks=( /bin /lib )
+for f in "${chroot_symlinks[@]}"; do
+  if [[ ! -L "${chroot}$f" ]]; then
+    printf >&2 "\x1B[31;1m[mkyolcscript] Expected %s to be a symlink (to %s), but it isn't.\x1B[0m\n" "$chroot$f" "usr$f"
+    exit 1
+  fi
+  if [[ ! "$(readlink "${chroot}$f")" = "usr$f" ]]; then
+    printf >&2 "\x1B[31;1m[mkyolcscript] Expected %s to (be a symlink and) point to %s, but it doesn't.\x1B[0m\n" "$chroot$f" "usr$f"
+    exit 1
+  fi
+done
+
+symlink_bindargs=()
+for f in "${chroot_symlinks[@]}"; do
+  symlink_bindargs[${#symlink_bindargs[@]}]=--symlink
+  symlink_bindargs[${#symlink_bindargs[@]}]=/usr$f
+  symlink_bindargs[${#symlink_bindargs[@]}]=$f
+done
+
+args=(
+  # Need bwrap >=v0.7.0 for --size
+  --size $((100 * 1024 * 1024)) --tmpfs /tmp
+  --ro-bind "${chroot}/usr/bin" /usr/bin
+  --ro-bind "${chroot}/usr/lib" /usr/lib
+  --ro-bind "${chroot}/usr/include" /usr/include
+  --ro-bind "${chroot}/usr/lib64" /lib64  # This is wrong because it's a symlink in the actual image. But if we symlink, nothing works; see above.
+  "${symlink_bindargs[@]}"
+  --ro-bind "${chroot}/etc/alternatives" /etc/alternatives
+  --ro-bind /etc/resolv.conf /etc/resolv.conf
+  --dir "${ghcup_base}"
+  --ro-bind "${ghcup_base}/bin"   "${ghcup_base}/bin"
+  --ro-bind "${ghcup_base}/ghc"   "${ghcup_base}/ghc"
+  --ro-bind "${ghcup_base}/cache" "${ghcup_base}/cache"
+  --ro-bind "${HOME}/.cabal/bin" "${HOME}/.cabal/bin"
+  --ro-bind "${HOME}/.cabal/store" "${HOME}/.cabal/store"
+  --bind "${HOME}/.cabal/packages" "${HOME}/.cabal/packages"  # should be safe to modify this? Just stores downloads
+  --dev-bind /dev/null /dev/null
+  --bind "builderprojs" /builderprojs
+  --bind "${projdir}" /project
+  --setenv PATH "/bin:/usr/bin:${ghcup_base}/bin"
+  --setenv GHCUP_INSTALL_BASE_PREFIX "$(dirname "${ghcup_base}")"
+  --setenv GHCUP_SKIP_UPDATE_CHECK ""
+  --proc /proc
+  --chdir "/tmp"
+  --new-session
+  --unshare-all
+  --share-net
+  --die-with-parent
+  --file 4 "/tmp/script.sh"
+  /bin/bash "/tmp/script.sh"
+)
+
+GHCUP_RUN=(ghcup --no-verbose --offline run --ghc $ghcversion --)
+
+bwrap "${args[@]}" 4<<EOF
+set -xe
+cd /project
+rm -rf ~/.ghc
+test -f cabal.project.freeze && rm cabal.project.freeze
+[[ $test_mode -eq 1 ]] && exit
+${GHCUP_RUN[@]} cabal \\
+  --store-dir=/${workdir}/ghc-'$ghcversion'-cabal/store \\
+  --logs-dir=/${workdir}/ghc-'$ghcversion'-cabal/logs \\
+  build all --enable-tests -j2
+
+# keep the latest yolc libraries
+rm -rf /${workdir}/ghc-'$ghcversion'-cabal/store/{yul-dsl-*,yol-*,eth-abi-*}
+rm -rf /${workdir}/ghc-'$ghcversion'-cabal/store/*/{yul-dsl-*,yol-*,eth-abi-*}
+rm -rf /${workdir}/ghc-'$ghcversion'-cabal/store/*/package.db/{yul-dsl-*,yol-*,eth-abi-*}
+${GHCUP_RUN[@]} ghc-pkg --package-db /${workdir}/ghc-'$ghcversion'-cabal/store/*/package.db recache
+
+${GHCUP_RUN[@]} cabal \\
+  --store-dir=/${workdir}/ghc-'$ghcversion'-cabal/store \\
+  --logs-dir=/${workdir}/ghc-'$ghcversion'-cabal/logs \\
+  install all --lib
+EOF
+
+printf "\x1B[1m[mkyolcscript] Collecting dependencies from cabal plan.json\x1B[0m\n"
+
+#depends=( $( jq -r '.["install-plan"] | .[] | select(.["style"] == "local") | .depends | "-package-id " + .[]' "$projdir"/dist-newstyle/cache/plan.json ) )
+
+depends=( $(
+  for i in $(
+    "${GHCUP_RUN[@]}" ghc-pkg --global list --show-unit-ids --simple-output 2>/dev/null
+    "${GHCUP_RUN[@]}" ghc-pkg --package-db ${workdir}/ghc-${ghcversion}-cabal/store/ghc-${ghcversion}-*/package.db list --show-unit-ids --simple-output 2>/dev/null
+  ); do echo "-package-id " "$i"; done) )
+
+printf "\x1B[1m[mkyolcscript] Writing %s\x1B[0m\n" "$outscript"
+
+cat >"$outscript" <<EOF
+#!/bin/sh
+ghcup --no-verbose --offline run --ghc '$ghcversion' -- ghc \\
+  -static \\
+  -hide-all-packages \\
+  -Wmissing-home-modules \\
+  -no-user-package-db \\
+  -XGHC2024 -XBlockArguments -XQualifiedDo -XOverloadedStrings -XUnicodeSyntax -XRebindableSyntax -XImpredicativeTypes -XLinearTypes -XTemplateHaskell \\
+  -package-db /${workdir}/ghc-'$ghcversion'-cabal/store/ghc-'$ghcversion'-*/package.db \\
+  ${depends[@]} \\
+  -rtsopts \\
+  "\$@"
+EOF
+
+chmod +x "$outscript"
diff --git a/play-haskell-worker/bwrap-files/stage-2.sh b/play-haskell-worker/bwrap-files/stage-2.sh
index 315a83d..beb432d 100755
--- a/play-haskell-worker/bwrap-files/stage-2.sh
+++ b/play-haskell-worker/bwrap-files/stage-2.sh
@@ -19,7 +19,7 @@ ghc_out_fd=100
 # For the --symlink of /bin and /lib, see mkbuildscript.sh
 args=(
   # Need bwrap >=v0.7.0 for --size
-  --size $((100 * 1024 * 1024)) --tmpfs /tmp
+  --size $((500 * 1024 * 1024)) --tmpfs /tmp
   # --ro-bind "${chroot}/bin" /bin
   --symlink /usr/bin /bin
   --ro-bind "${chroot}/usr/bin" /usr/bin
diff --git a/play-haskell-worker/bwrap-files/stage-3.sh b/play-haskell-worker/bwrap-files/stage-3.sh
index 9f2ddb6..134fe67 100755
--- a/play-haskell-worker/bwrap-files/stage-3.sh
+++ b/play-haskell-worker/bwrap-files/stage-3.sh
@@ -16,20 +16,42 @@ IFS="" read -r opt
 IFS="" read -r version
 
 # Check that there are only version-like characters
-if [[ "${version//[0-9.alpha-]/}" != "" ]]; then
-  echo >&2 "Invalid version"
-  exit 1
-fi
+# if [[ "${version//[0-9.alpha-]/}" != "" ]]; then
+#   echo >&2 "Invalid version: $version"
+#   exit 1
+# fi
 
 if [[ ! -f /builders/build-"${version}".sh ]]; then
   echo >&2 "Version ${version} not available"
   exit 1
 fi
 
+yolc_main() {
+echo '
+-- base
+import Prelude
+import System.Exit (exitFailure, exitSuccess)
+import System.IO (stderr)
+-- text
+import qualified Data.Text.Lazy.IO as TIO
+-- yol-suite
+import YolSuite.YOLC.RunYolModes
+--
+import Project
+
+main :: IO ()
+main = yulObjectMode object >>= \case
+  Left  err -> TIO.hPutStrLn stderr err >> exitFailure
+  Right out -> TIO.putStrLn out >> exitSuccess
+'
+}
+
 case "$command" in
   run)
-    cat >Main.hs
-    /builders/build-"${version}".sh "${opt}" Main.hs >/tmp/null 2>&"$ghc_out_fd"
+    export YOLC_DEBUG_LEVEL=0
+    cat > Project.hs
+    yolc_main > Main.hs
+    time /builders/build-"${version}".sh "${opt}" Project.hs Main.hs >/tmp/null 2>&"$ghc_out_fd"
     if [[ -f Main ]]; then
       ./Main +RTS -M500m -RTS
     else
@@ -46,7 +68,6 @@ case "$command" in
     /builders/build-"${version}".sh -ddump-asm -ddump-to-file "${opt}" input.hs >/tmp/null 2>&"$ghc_out_fd"
     cat input.dump-asm
     ;;
-
   *)
     echo >&2 "Unknown command"
     exit 1
diff --git a/play-haskell-worker/bwrap-files/systemd-run-shim.c b/play-haskell-worker/bwrap-files/systemd-run-shim.c
index 8c18d66..c087115 100644
--- a/play-haskell-worker/bwrap-files/systemd-run-shim.c
+++ b/play-haskell-worker/bwrap-files/systemd-run-shim.c
@@ -82,7 +82,7 @@ int main(int argc, char **argv) {
   // Limit memory to 600 MiB. Note that the compiled program gets a 500 MiB memory
   // limit via the GHC RTS, so this limit is 1. to constrain GHC itself (including
   // any TH code), and 2. as a second-layer defense.
-  run_args[13] = xstrdup("--property=MemoryMax=600M");
+  run_args[13] = xstrdup("--property=MemoryMax=2000M");
   run_args[14] = xstrdup("--property=TasksMax=50");
   run_args[15] = xstrdup("--property=LimitCORE=0");
   run_args[16] = xstrdup("--");