23245662 Deliver polkit 0.113 in Solaris
authorNiveditha Rau <Niveditha.Rau@Oracle.COM>
Tue, 14 Jun 2016 20:31:53 -0700
changeset 6217 f2179bfee747
parent 6216 ea79493f75f0
child 6218 aeb522ce4eef
23245662 Deliver polkit 0.113 in Solaris PSARC/2016/312 PolKit
components/desktop/polkit/Makefile
components/desktop/polkit/files/polkit.xml
components/desktop/polkit/files/svc-polkit
components/desktop/polkit/patches/01-procfs.patch
components/desktop/polkit/patches/02-duktape.patch
components/desktop/polkit/patches/03-solaris-port-duktape.patch
components/desktop/polkit/patches/04-fdwalk.patch
components/desktop/polkit/patches/05-mocklibc.patch
components/desktop/polkit/polkit.p5m
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/components/desktop/polkit/Makefile	Tue Jun 14 20:31:53 2016 -0700
@@ -0,0 +1,99 @@
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+# or http://www.opensolaris.org/os/licensing.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+# Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
+#
+
+BUILD_BITS =            64_and_32
+# Also, all components using gobject-introspection must be built with gcc as
+# gobject-introspection does not produce correct results when using Studio.
+COMPILER =              gcc
+include ../../../make-rules/shared-macros.mk
+
+COMPONENT_NAME=		polkit
+COMPONENT_VERSION=	0.113
+COMPONENT_PROJECT_URL=	http://www.freedesktop.org/wiki/Software/polkit/
+COMPONENT_ARCHIVE=	$(COMPONENT_SRC).tar.gz
+COMPONENT_ARCHIVE_HASH= \
+	sha256:e1c095093c654951f78f8618d427faf91cf62abdefed98de40ff65eca6413c81
+COMPONENT_ARCHIVE_URL=	http://www.freedesktop.org/software/polkit/releases/$(COMPONENT_ARCHIVE)
+COMPONENT_SIG_URL=	$(COMPONENT_ARCHIVE_URL).sign
+COMPONENT_BUGDB=	gnome/security
+
+TPNO=			27381
+
+# Test don't work on Solaris
+TEST_TARGET = $(SKIP_TEST)
+
+# Needs gobject-introspection, not available on S11.
+ifeq ($(BUILD_TYPE), evaluation)
+BUILD_32_and_64=
+INSTALL_32_and_64=
+PUBLISH_STAMP=
+endif
+
+include $(WS_MAKE_RULES)/common.mk
+
+# Regenerate configure after patches/02-duktape.patch modifies configure.ac
+COMPONENT_PREP_ACTION += ( cd $(@D); autoreconf -fiv);
+# Make sure we haven't broken the SMF manifest formatting
+COMPONENT_PREP_ACTION += \
+    ( /usr/sbin/svccfg validate $(COMPONENT_DIR)/files/polkit.xml );
+
+# Need C99 or later to get fpclassify() & isfinite() in <math.h>
+CFLAGS += -ggdb
+CFLAGS.gcc += -std=gnu11
+CFLAGS.studio += -std=c11 -xlang=c11
+
+# Solaris doesn't have a defined authpriv facility in syslog, so map it to
+# an unused one for now
+CPPFLAGS += -DLOG_AUTHPRIV='(10<<3)'
+
+CONFIGURE_OPTIONS += --disable-static
+CONFIGURE_OPTIONS += --enable-gtk-doc
+CONFIGURE_OPTIONS += --enable-man-pages
+CONFIGURE_OPTIONS += --enable-shared
+CONFIGURE_OPTIONS += --with-pic
+CONFIGURE_OPTIONS += --with-authfw=pam
+CONFIGURE_OPTIONS += --with-polkitd-user=_polkitd
+CONFIGURE_OPTIONS += --with-os-type=solaris
+CONFIGURE_OPTIONS += --sysconfdir="$(ETCDIR)"
+
+# Largefile support breaks use of <procfs.h> when build environment is older
+# than s12_84 due to Solaris bug 21833491
+ifeq ($(OS_VERSION), 5.11)
+  CONFIGURE_OPTIONS += --disable-largefile
+endif
+
+# Assumes GNU xgettext in PATH
+CONFIGURE_ENV += PATH=$(GNUBIN):$(PATH)
+
+# Tell g-ir-scanner not to cache results in homedir of user running the build
+COMPONENT_BUILD_ENV += GI_SCANNER_DISABLE_CACHE=""
+
+# SMF manifest & method
+PKG_PROTO_DIRS += $(COMPONENT_DIR)/files
+
+REQUIRED_PACKAGES += library/desktop/gobject/gobject-introspection
+REQUIRED_PACKAGES += library/expat
+REQUIRED_PACKAGES += library/glib2
+REQUIRED_PACKAGES += system/core-os
+REQUIRED_PACKAGES += system/library/dbus
+REQUIRED_PACKAGES += system/library/math
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/components/desktop/polkit/files/polkit.xml	Tue Jun 14 20:31:53 2016 -0700
@@ -0,0 +1,90 @@
+<?xml version="1.0" ?>
+<!DOCTYPE service_bundle
+  SYSTEM '/usr/share/lib/xml/dtd/service_bundle.dtd.1'>
+<!--
+    CDDL HEADER START
+
+    The contents of this file are subject to the terms of the
+    Common Development and Distribution License (the "License").
+    You may not use this file except in compliance with the License.
+
+    You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+    or http://www.opensolaris.org/os/licensing.
+    See the License for the specific language governing permissions
+    and limitations under the License.
+
+    When distributing Covered Code, include this CDDL HEADER in each
+    file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+    If applicable, add the following below this CDDL HEADER, with the
+    fields enclosed by brackets "[]" replaced with your own identifying
+    information: Portions Copyright [yyyy] [name of copyright owner]
+
+    CDDL HEADER END
+
+    Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
+
+    NOTE:  This service manifest is not editable; its contents will
+    be overwritten by package or patch operations, including
+    operating system upgrade.  Make customizations in a different
+    file.
+-->
+<service_bundle type="manifest" name="system/polkit">
+    <service version="1" type="service" name="system/polkit">
+
+        <dependency restart_on="none" type="service"
+            name="multi_user_dependency" grouping="require_all">
+            <service_fmri value="svc:/milestone/multi-user"/>
+        </dependency>
+        <dependency restart_on="none" type="service"
+            name="name-services" grouping="require_all">
+            <service_fmri value="svc:/milestone/name-services"/>
+        </dependency>
+        <dependency restart_on="restart" type="service"
+            name="dbus" grouping="require_all">
+            <service_fmri value="svc:/system/dbus"/>
+        </dependency>
+
+        <method_context>
+            <method_credential user='root' clearance='ADMIN_HIGH' />
+        </method_context>
+
+        <exec_method timeout_seconds="60" type="method" name="start"
+            exec="/lib/svc/method/svc-polkit"/>
+        <exec_method timeout_seconds="60" type="method" name="stop"
+            exec=":kill"/>
+        <exec_method timeout_seconds="60" type="method" name="refresh"
+            exec=":true"/>
+
+        <!-- Authorization -->
+        <property_group name='general' type='framework'>
+                <propval name='action_authorization' type='astring'
+                        value='solaris.smf.manage.dt.login' />
+        </property_group>
+
+	<!--
+            We do not need a duration property group, because contract is
+            the default.  Search for duration in svc.startd(1M).
+        -->
+	<property_group name='options' type='application'>
+	    <propval name='debug' type='boolean' value='false' />
+	</property_group>
+
+        <instance enabled="true" name="default"/>
+
+        <template>
+            <common_name>
+                <loctext xml:lang="C">
+                        PolKit
+                </loctext>
+            </common_name>
+            <description>
+                <loctext xml:lang="C">
+                	PolKit is a toolkit for defining and handling authorizations for desktop software.
+                </loctext>
+            </description>
+	    <documentation>
+	        <manpage title='polkitd' section='8' manpath='/usr/share/man' />
+            </documentation>
+        </template>
+    </service>
+</service_bundle>
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/components/desktop/polkit/files/svc-polkit	Tue Jun 14 20:31:53 2016 -0700
@@ -0,0 +1,38 @@
+#! /usr/bin/sh
+#
+# CDDL HEADER START
+#
+# The contents of this file are subject to the terms of the
+# Common Development and Distribution License (the "License").
+# You may not use this file except in compliance with the License.
+#
+# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
+# or http://www.opensolaris.org/os/licensing.
+# See the License for the specific language governing permissions
+# and limitations under the License.
+#
+# When distributing Covered Code, include this CDDL HEADER in each
+# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
+# If applicable, add the following below this CDDL HEADER, with the
+# fields enclosed by brackets "[]" replaced with your own identifying
+# information: Portions Copyright [yyyy] [name of copyright owner]
+#
+# CDDL HEADER END
+#
+
+#
+# Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
+#
+# Start method script for the PolKit daemon.
+#
+
+. /lib/svc/share/smf_include.sh
+
+polkitd_args=""
+
+debug="$(/usr/bin/svcprop -p options/debug "${SMF_FMRI}")"
+[[ "${debug}" != "true" ]] && polkitd_args+=" --no-debug"
+
+/usr/lib/polkit-1/polkitd ${polkitd_args} &
+
+exit $SMF_EXIT_OK
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/components/desktop/polkit/patches/01-procfs.patch	Tue Jun 14 20:31:53 2016 -0700
@@ -0,0 +1,42 @@
+We shouldn't need this now -  should send upstream
+
+--- polkit-0.113/src/polkit/polkitunixprocess.c.~1~	2014-01-14 14:42:25.000000000 -0800
++++ polkit-0.113/src/polkit/polkitunixprocess.c	2015-10-03 00:15:34.441044107 -0700
[email protected]@ -80,7 +80,7 @@
+ 
+ static void subject_iface_init (PolkitSubjectIface *subject_iface);
+ 
+-static guint64 get_start_time_for_pid (gint    pid,
++static guint64 get_start_time_for_pid (pid_t    pid,
+                                        GError **error);
+ 
+ static gint _polkit_unix_process_get_owner (PolkitUnixProcess  *process,
[email protected]@ -512,28 +512,6 @@
+   subject_iface->exists_sync   = polkit_unix_process_exists_sync;
+ }
+ 
+-#ifdef HAVE_SOLARIS
+-static int
+-get_pid_psinfo (pid_t pid, struct psinfo *ps)
+-{
+-  char pname[32];
+-  int  procfd;
+-
+-  (void) snprintf(pname, sizeof(pname), "/proc/%d/psinfo", pid);
+-  if ((procfd = open(pname, O_RDONLY)) == -1)
+-    {
+-      return -1;
+-    }
+-  if (read(procfd, ps, sizeof(struct psinfo)) < 0)
+-    {
+-      (void) close(procfd);
+-      return -1;
+-    }
+-  (void) close(procfd);
+-  return 0;
+-}
+-#endif
+-
+ #ifdef HAVE_FREEBSD
+ static gboolean
+ get_kinfo_proc (pid_t pid, struct kinfo_proc *p)
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/components/desktop/polkit/patches/02-duktape.patch	Tue Jun 14 20:31:53 2016 -0700
@@ -0,0 +1,78465 @@
+From 951c354472ae14af34a6a034ff0f79376cd085ed Mon Sep 17 00:00:00 2001
+From: "Jasper St. Pierre" <[email protected]>
+Date: Wed, 12 Aug 2015 16:04:31 -0700
+Subject: [PATCH] Port to duktape
+
+---
+ configure.ac                                    |   15 -
+ src/polkitbackend/Makefile.am                   |    7 +-
+ src/polkitbackend/duktape.c                     |72690 +++++++++++++++++++++++
+ src/polkitbackend/duktape.h                     | 4460 ++
+ src/polkitbackend/polkitbackendjsauthority.c    |  846 +-
+ test/data/etc/polkit-1/rules.d/10-testing.rules |    2 +-
+ 6 files changed, 77329 insertions(+), 691 deletions(-)
+ create mode 100644 src/polkitbackend/duktape.c
+ create mode 100644 src/polkitbackend/duktape.h
+
+diff --git a/configure.ac b/configure.ac
+index 85f26b9..29758be 100644
+--- a/configure.ac
++++ b/configure.ac
[email protected]@ -129,21 +129,6 @@ AC_DEFINE([GLIB_VERSION_MIN_REQUIRED], [GLIB_VERSION_2_30],
+ AC_DEFINE([GLIB_VERSION_MAX_ALLOWED], [G_ENCODE_VERSION(2,34)],
+         [Notify us when we'll need to transition away from g_type_init()])
+ 
+-AC_ARG_WITH(mozjs, AS_HELP_STRING([[email protected]<:@mozjs185/mozjs-17.0|[email protected]:>@],
+-		                  [Specify version of Spidermonkey to use]),,
+-            with_mozjs=auto)
+-AS_IF([test x${with_mozjs} != xauto], [
+-  PKG_CHECK_MODULES(LIBJS, ${with_mozjs})
+-], [
+-  PKG_CHECK_MODULES(LIBJS, [mozjs185], have_mozjs185=yes, have_mozjs185=no)
+-  AS_IF([test x${have_mozjs185} = xno], [
+-  PKG_CHECK_MODULES(LIBJS, [mozjs-17.0], have_mozjs17=yes,
+-   [AC_MSG_ERROR([Could not find mozjs185 or mozjs-17.0; see http://ftp.mozilla.org/pub/mozilla.org/js/])])
+-  ])
+-])
+-AC_SUBST(LIBJS_CFLAGS)
+-AC_SUBST(LIBJS_LIBS)
+-
+ EXPAT_LIB=""
+ AC_ARG_WITH(expat, [  --with-expat=<dir>      Use expat from here],
+                       [
+diff --git a/src/polkitbackend/Makefile.am b/src/polkitbackend/Makefile.am
+index 547ca82..ef6a9dd 100644
+--- a/src/polkitbackend/Makefile.am
++++ b/src/polkitbackend/Makefile.am
[email protected]@ -36,6 +36,7 @@ libpolkit_backend_1_la_SOURCES =                                   			\
+ 	polkitbackendactionpool.h		polkitbackendactionpool.c		\
+ 	polkitbackendconfigsource.h		polkitbackendconfigsource.c		\
+ 	polkitbackendactionlookup.h		polkitbackendactionlookup.c		\
++	duktape.c duktape.h \
+         $(NULL)
+ 
+ if HAVE_LIBSYSTEMD
[email protected]@ -49,9 +50,11 @@ endif
+ libpolkit_backend_1_la_CFLAGS =                                        	\
+         -D_POLKIT_COMPILATION                                  		\
+         -D_POLKIT_BACKEND_COMPILATION                                  	\
++	-DDUK_OPT_HAVE_CUSTOM_H						\
++	-DDUK_OPT_INTERRUPT_COUNTER					\
++	-D'DUK_OPT_EXEC_TIMEOUT_CHECK(u)=polkit_js_exec_timeout_check(u)' \
+         $(GLIB_CFLAGS)							\
+ 	$(LIBSYSTEMD_CFLAGS)						\
+-	$(LIBJS_CFLAGS)							\
+         $(NULL)
+ 
+ libpolkit_backend_1_la_LIBADD =                               		\
[email protected]@ -59,7 +62,7 @@ libpolkit_backend_1_la_LIBADD =                               		\
+ 	$(LIBSYSTEMD_LIBS)						\
+ 	$(top_builddir)/src/polkit/libpolkit-gobject-1.la		\
+ 	$(EXPAT_LIBS)							\
+-	$(LIBJS_LIBS)							\
++	-lm								\
+         $(NULL)
+ 
+ rulesdir = $(sysconfdir)/polkit-1/rules.d
+diff --git a/src/polkitbackend/duktape.c b/src/polkitbackend/duktape.c
+new file mode 100644
+index 0000000..cb39caf
+--- /dev/null
++++ b/src/polkitbackend/duktape.c
[email protected]@ -0,0 +1,72690 @@
++/*
++ *  Single file autogenerated distributable for Duktape 1.2.3.
++ *  Git commit 0605a18660dbae486c62a42a33fabd034c8623ff (v1.2.3).
++ *
++ *  See Duktape AUTHORS.rst and LICENSE.txt for copyright and
++ *  licensing information.
++ */
++
++/* LICENSE.txt */
++/*
++*  ===============
++*  Duktape license
++*  ===============
++*
++*  (http://opensource.org/licenses/MIT)
++*
++*  Copyright (c) 2013-2015 by Duktape authors (see AUTHORS.rst)
++*
++*  Permission is hereby granted, free of charge, to any person obtaining a copy
++*  of this software and associated documentation files (the "Software"), to deal
++*  in the Software without restriction, including without limitation the rights
++*  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
++*  copies of the Software, and to permit persons to whom the Software is
++*  furnished to do so, subject to the following conditions:
++*
++*  The above copyright notice and this permission notice shall be included in
++*  all copies or substantial portions of the Software.
++*
++*  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
++*  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
++*  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
++*  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
++*  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
++*  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
++*  THE SOFTWARE.
++*
++*/
++/* AUTHORS.rst */
++/*
++*  ===============
++*  Duktape authors
++*  ===============
++*
++*  Copyright
++*  =========
++*
++*  Duktape copyrights are held by its authors.  Each author has a copyright
++*  to their contribution, and agrees to irrevocably license the contribution
++*  under the Duktape ``LICENSE.txt``.
++*
++*  Authors
++*  =======
++*
++*  Please include an e-mail address, a link to your GitHub profile, or something
++*  similar to allow your contribution to be identified accurately.
++*
++*  The following people have contributed code and agreed to irrevocably license
++*  their contributions under the Duktape ``LICENSE.txt`` (in order of appearance):
++*
++*  * Sami Vaarala <[email protected]>
++*  * Niki Dobrev
++*  * Andreas \u00d6man <[email protected]>
++*  * L\u00e1szl\u00f3 Lang\u00f3 <[email protected]>
++*  * Legimet <[email protected]>
++*
++*  Other contributions
++*  ===================
++*
++*  The following people have contributed something other than code (e.g. reported
++*  bugs, provided ideas, etc; roughly in order of appearance):
++*
++*  * Greg Burns
++*  * Anthony Rabine
++*  * Carlos Costa
++*  * Aur\u00e9lien Bouilland
++*  * Preet Desai (Pris Matic)
++*  * judofyr (http://www.reddit.com/user/judofyr)
++*  * Jason Woofenden
++*  * Micha\u0142 Przyby\u015b
++*  * Anthony Howe
++*  * Conrad Pankoff
++*  * Jim Schimpf
++*  * Rajaran Gaunker (https://github.com/zimbabao)
++*  * Andreas \u00d6man
++*  * Doug Sanden
++*  * Josh Engebretson (https://github.com/JoshEngebretson)
++*  * Remo Eichenberger (https://github.com/remoe)
++*  * Mamod Mehyar (https://github.com/mamod)
++*  * David Demelier (https://github.com/hftmarkand)
++*  * Tim Caswell (https://github.com/creationix)
++*  * Mitchell Blank Jr (https://github.com/mitchblank)
++*  * https://github.com/yushli
++*  * Seo Sanghyeon (https://github.com/sanxiyn)
++*  * Han ChoongWoo (https://github.com/tunz)
++*  * Joshua Peek (https://github.com/josh)
++*  * Bruce E. Pascoe (https://github.com/fatcerberus)
++*  * https://github.com/Kelledin
++*  * https://github.com/sstruchtrup
++*
++*  If you are accidentally missing from this list, send me an e-mail
++*  (``[email protected]``) and I'll fix the omission.
++*/
++#line 1 "duk_internal.h"
++/*
++ *  Top-level include file to be used for all (internal) source files.
++ *
++ *  Source files should not include individual header files, as they
++ *  have not been designed to be individually included.
++ */
++
++#ifndef DUK_INTERNAL_H_INCLUDED
++#define DUK_INTERNAL_H_INCLUDED
++
++/*
++ *  The 'duktape.h' header provides the public API, but also handles all
++ *  compiler and platform specific feature detection, Duktape feature
++ *  resolution, inclusion of system headers, etc.  These have been merged
++ *  because the public API is also dependent on e.g. detecting appropriate
++ *  C types which is quite platform/compiler specific especially for a non-C99
++ *  build.  The public API is also dependent on the resolved feature set.
++ *
++ *  Some actions taken by the merged header (such as including system headers)
++ *  are not appropriate for building a user application.  The define
++ *  DUK_COMPILING_DUKTAPE allows the merged header to skip/include some
++ *  sections depending on what is being built.
++ */
++
++#define DUK_COMPILING_DUKTAPE
++#include "duktape.h"
++
++/*
++ *  User declarations, e.g. prototypes for user functions used by Duktape
++ *  macros.  Concretely, if DUK_OPT_PANIC_HANDLER is used and the macro
++ *  value calls a user function, it needs to be declared for Duktape
++ *  compilation to avoid warnings.
++ */
++
++DUK_USE_USER_DECLARE()
++
++/*
++ *  Duktape includes (other than duk_features.h)
++ *
++ *  The header files expect to be included in an order which satisfies header
++ *  dependencies correctly (the headers themselves don't include any other
++ *  includes).  Forward declarations are used to break circular struct/typedef
++ *  dependencies.
++ */
++
++#line 1 "duk_replacements.h"
++#ifndef DUK_REPLACEMENTS_H_INCLUDED
++#define DUK_REPLACEMENTS_H_INCLUDED
++
++#ifdef DUK_USE_REPL_FPCLASSIFY
++DUK_INTERNAL_DECL int duk_repl_fpclassify(double x);
++#endif
++
++#ifdef DUK_USE_REPL_SIGNBIT
++DUK_INTERNAL_DECL int duk_repl_signbit(double x);
++#endif
++
++#ifdef DUK_USE_REPL_ISFINITE
++DUK_INTERNAL_DECL int duk_repl_isfinite(double x);
++#endif
++
++#ifdef DUK_USE_REPL_ISNAN
++DUK_INTERNAL_DECL int duk_repl_isnan(double x);
++#endif
++
++#ifdef DUK_USE_REPL_ISINF
++DUK_INTERNAL_DECL int duk_repl_isinf(double x);
++#endif
++
++#endif  /* DUK_REPLACEMENTS_H_INCLUDED */
++#line 1 "duk_jmpbuf.h"
++/*
++ *  Wrapper for jmp_buf.
++ *
++ *  This is used because jmp_buf is an array type for backward compatibility.
++ *  Wrapping jmp_buf in a struct makes pointer references, sizeof, etc,
++ *  behave more intuitively.
++ *
++ *  http://en.wikipedia.org/wiki/Setjmp.h#Member_types
++ */
++
++#ifndef DUK_JMPBUF_H_INCLUDED
++#define DUK_JMPBUF_H_INCLUDED
++
++struct duk_jmpbuf {
++#if defined(DUK_USE_SETJMP) || defined(DUK_USE_UNDERSCORE_SETJMP)
++	jmp_buf jb;
++#elif defined(DUK_USE_SIGSETJMP)
++	sigjmp_buf jb;
++#else
++#error internal error, no long control transfer provider
++#endif
++};
++
++#endif  /* DUK_JMPBUF_H_INCLUDED */
++#line 1 "duk_forwdecl.h"
++/*
++ *  Forward declarations for all Duktape structures.
++ */
++
++#ifndef DUK_FORWDECL_H_INCLUDED
++#define DUK_FORWDECL_H_INCLUDED
++
++/*
++ *  Forward declarations
++ */
++
++struct duk_jmpbuf;
++
++/* duk_tval intentionally skipped */
++struct duk_heaphdr;
++struct duk_heaphdr_string;
++struct duk_hstring;
++struct duk_hstring_external;
++struct duk_hobject;
++struct duk_hcompiledfunction;
++struct duk_hnativefunction;
++struct duk_hthread;
++struct duk_hbuffer;
++struct duk_hbuffer_fixed;
++struct duk_hbuffer_dynamic;
++
++struct duk_propaccessor;
++union duk_propvalue;
++struct duk_propdesc;
++
++struct duk_heap;
++struct duk_breakpoint;
++
++struct duk_activation;
++struct duk_catcher;
++struct duk_strcache;
++struct duk_ljstate;
++struct duk_strtab_entry;
++
++#ifdef DUK_USE_DEBUG
++struct duk_fixedbuffer;
++#endif
++
++struct duk_bitdecoder_ctx;
++struct duk_bitencoder_ctx;
++
++struct duk_token;
++struct duk_re_token;
++struct duk_lexer_point;
++struct duk_lexer_ctx;
++
++struct duk_compiler_instr;
++struct duk_compiler_func;
++struct duk_compiler_ctx;
++
++struct duk_re_matcher_ctx;
++struct duk_re_compiler_ctx;
++
++typedef struct duk_jmpbuf duk_jmpbuf;
++
++/* duk_tval intentionally skipped */
++typedef struct duk_heaphdr duk_heaphdr;
++typedef struct duk_heaphdr_string duk_heaphdr_string;
++typedef struct duk_hstring duk_hstring;
++typedef struct duk_hstring_external duk_hstring_external;
++typedef struct duk_hobject duk_hobject;
++typedef struct duk_hcompiledfunction duk_hcompiledfunction;
++typedef struct duk_hnativefunction duk_hnativefunction;
++typedef struct duk_hthread duk_hthread;
++typedef struct duk_hbuffer duk_hbuffer;
++typedef struct duk_hbuffer_fixed duk_hbuffer_fixed;
++typedef struct duk_hbuffer_dynamic duk_hbuffer_dynamic;
++
++typedef struct duk_propaccessor duk_propaccessor;
++typedef union duk_propvalue duk_propvalue;
++typedef struct duk_propdesc duk_propdesc;
++
++typedef struct duk_heap duk_heap;
++typedef struct duk_breakpoint duk_breakpoint;
++
++typedef struct duk_activation duk_activation;
++typedef struct duk_catcher duk_catcher;
++typedef struct duk_strcache duk_strcache;
++typedef struct duk_ljstate duk_ljstate;
++typedef struct duk_strtab_entry duk_strtab_entry;
++
++#ifdef DUK_USE_DEBUG
++typedef struct duk_fixedbuffer duk_fixedbuffer;
++#endif
++
++typedef struct duk_bitdecoder_ctx duk_bitdecoder_ctx;
++typedef struct duk_bitencoder_ctx duk_bitencoder_ctx;
++
++typedef struct duk_token duk_token;
++typedef struct duk_re_token duk_re_token;
++typedef struct duk_lexer_point duk_lexer_point;
++typedef struct duk_lexer_ctx duk_lexer_ctx;
++
++typedef struct duk_compiler_instr duk_compiler_instr;
++typedef struct duk_compiler_func duk_compiler_func;
++typedef struct duk_compiler_ctx duk_compiler_ctx;
++
++typedef struct duk_re_matcher_ctx duk_re_matcher_ctx;
++typedef struct duk_re_compiler_ctx duk_re_compiler_ctx;
++
++#endif  /* DUK_FORWDECL_H_INCLUDED */
++#line 1 "duk_builtins.h"
++/*
++ *  Automatically generated by genbuiltins.py, do not edit!
++ */
++
++#ifndef DUK_BUILTINS_H_INCLUDED
++#define DUK_BUILTINS_H_INCLUDED
++
++#if defined(DUK_USE_DOUBLE_LE)
++#if !defined(DUK_SINGLE_FILE)
++DUK_INTERNAL_DECL const duk_uint8_t duk_strings_data[1943];
++#endif  /* !DUK_SINGLE_FILE */
++
++#define DUK_STRDATA_DATA_LENGTH                                       1943
++#define DUK_STRDATA_MAX_STRLEN                                        24
++
++#define DUK_STRIDX_UC_LOGGER                                          0                              /* 'Logger' */
++#define DUK_STRIDX_UC_THREAD                                          1                              /* 'Thread' */
++#define DUK_STRIDX_UC_POINTER                                         2                              /* 'Pointer' */
++#define DUK_STRIDX_UC_BUFFER                                          3                              /* 'Buffer' */
++#define DUK_STRIDX_DEC_ENV                                            4                              /* 'DecEnv' */
++#define DUK_STRIDX_OBJ_ENV                                            5                              /* 'ObjEnv' */
++#define DUK_STRIDX_EMPTY_STRING                                       6                              /* '' */
++#define DUK_STRIDX_GLOBAL                                             7                              /* 'global' */
++#define DUK_STRIDX_UC_ARGUMENTS                                       8                              /* 'Arguments' */
++#define DUK_STRIDX_JSON                                               9                              /* 'JSON' */
++#define DUK_STRIDX_MATH                                               10                             /* 'Math' */
++#define DUK_STRIDX_UC_ERROR                                           11                             /* 'Error' */
++#define DUK_STRIDX_REG_EXP                                            12                             /* 'RegExp' */
++#define DUK_STRIDX_DATE                                               13                             /* 'Date' */
++#define DUK_STRIDX_UC_NUMBER                                          14                             /* 'Number' */
++#define DUK_STRIDX_UC_BOOLEAN                                         15                             /* 'Boolean' */
++#define DUK_STRIDX_UC_STRING                                          16                             /* 'String' */
++#define DUK_STRIDX_ARRAY                                              17                             /* 'Array' */
++#define DUK_STRIDX_UC_FUNCTION                                        18                             /* 'Function' */
++#define DUK_STRIDX_UC_OBJECT                                          19                             /* 'Object' */
++#define DUK_STRIDX_UC_NULL                                            20                             /* 'Null' */
++#define DUK_STRIDX_UC_UNDEFINED                                       21                             /* 'Undefined' */
++#define DUK_STRIDX_JSON_EXT_FUNCTION2                                 22                             /* '{_func:true}' */
++#define DUK_STRIDX_JSON_EXT_FUNCTION1                                 23                             /* '{"_func":true}' */
++#define DUK_STRIDX_JSON_EXT_NEGINF                                    24                             /* '{"_ninf":true}' */
++#define DUK_STRIDX_JSON_EXT_POSINF                                    25                             /* '{"_inf":true}' */
++#define DUK_STRIDX_JSON_EXT_NAN                                       26                             /* '{"_nan":true}' */
++#define DUK_STRIDX_JSON_EXT_UNDEFINED                                 27                             /* '{"_undef":true}' */
++#define DUK_STRIDX_TO_LOG_STRING                                      28                             /* 'toLogString' */
++#define DUK_STRIDX_CLOG                                               29                             /* 'clog' */
++#define DUK_STRIDX_LC_L                                               30                             /* 'l' */
++#define DUK_STRIDX_LC_N                                               31                             /* 'n' */
++#define DUK_STRIDX_LC_FATAL                                           32                             /* 'fatal' */
++#define DUK_STRIDX_LC_ERROR                                           33                             /* 'error' */
++#define DUK_STRIDX_LC_WARN                                            34                             /* 'warn' */
++#define DUK_STRIDX_LC_DEBUG                                           35                             /* 'debug' */
++#define DUK_STRIDX_LC_TRACE                                           36                             /* 'trace' */
++#define DUK_STRIDX_RAW                                                37                             /* 'raw' */
++#define DUK_STRIDX_FMT                                                38                             /* 'fmt' */
++#define DUK_STRIDX_CURRENT                                            39                             /* 'current' */
++#define DUK_STRIDX_RESUME                                             40                             /* 'resume' */
++#define DUK_STRIDX_COMPACT                                            41                             /* 'compact' */
++#define DUK_STRIDX_JC                                                 42                             /* 'jc' */
++#define DUK_STRIDX_JX                                                 43                             /* 'jx' */
++#define DUK_STRIDX_BASE64                                             44                             /* 'base64' */
++#define DUK_STRIDX_HEX                                                45                             /* 'hex' */
++#define DUK_STRIDX_DEC                                                46                             /* 'dec' */
++#define DUK_STRIDX_ENC                                                47                             /* 'enc' */
++#define DUK_STRIDX_FIN                                                48                             /* 'fin' */
++#define DUK_STRIDX_GC                                                 49                             /* 'gc' */
++#define DUK_STRIDX_ACT                                                50                             /* 'act' */
++#define DUK_STRIDX_LC_INFO                                            51                             /* 'info' */
++#define DUK_STRIDX_VERSION                                            52                             /* 'version' */
++#define DUK_STRIDX_ENV                                                53                             /* 'env' */
++#define DUK_STRIDX_MOD_LOADED                                         54                             /* 'modLoaded' */
++#define DUK_STRIDX_MOD_SEARCH                                         55                             /* 'modSearch' */
++#define DUK_STRIDX_ERR_THROW                                          56                             /* 'errThrow' */
++#define DUK_STRIDX_ERR_CREATE                                         57                             /* 'errCreate' */
++#define DUK_STRIDX_COMPILE                                            58                             /* 'compile' */
++#define DUK_STRIDX_INT_REGBASE                                        59                             /* '\x00Regbase' */
++#define DUK_STRIDX_INT_THREAD                                         60                             /* '\x00Thread' */
++#define DUK_STRIDX_INT_HANDLER                                        61                             /* '\x00Handler' */
++#define DUK_STRIDX_INT_FINALIZER                                      62                             /* '\x00Finalizer' */
++#define DUK_STRIDX_INT_CALLEE                                         63                             /* '\x00Callee' */
++#define DUK_STRIDX_INT_MAP                                            64                             /* '\x00Map' */
++#define DUK_STRIDX_INT_ARGS                                           65                             /* '\x00Args' */
++#define DUK_STRIDX_INT_THIS                                           66                             /* '\x00This' */
++#define DUK_STRIDX_INT_PC2LINE                                        67                             /* '\x00Pc2line' */
++#define DUK_STRIDX_INT_SOURCE                                         68                             /* '\x00Source' */
++#define DUK_STRIDX_INT_VARENV                                         69                             /* '\x00Varenv' */
++#define DUK_STRIDX_INT_LEXENV                                         70                             /* '\x00Lexenv' */
++#define DUK_STRIDX_INT_VARMAP                                         71                             /* '\x00Varmap' */
++#define DUK_STRIDX_INT_FORMALS                                        72                             /* '\x00Formals' */
++#define DUK_STRIDX_INT_BYTECODE                                       73                             /* '\x00Bytecode' */
++#define DUK_STRIDX_INT_NEXT                                           74                             /* '\x00Next' */
++#define DUK_STRIDX_INT_TARGET                                         75                             /* '\x00Target' */
++#define DUK_STRIDX_INT_VALUE                                          76                             /* '\x00Value' */
++#define DUK_STRIDX_LC_POINTER                                         77                             /* 'pointer' */
++#define DUK_STRIDX_LC_BUFFER                                          78                             /* 'buffer' */
++#define DUK_STRIDX_INT_TRACEDATA                                      79                             /* '\x00Tracedata' */
++#define DUK_STRIDX_LINE_NUMBER                                        80                             /* 'lineNumber' */
++#define DUK_STRIDX_FILE_NAME                                          81                             /* 'fileName' */
++#define DUK_STRIDX_PC                                                 82                             /* 'pc' */
++#define DUK_STRIDX_STACK                                              83                             /* 'stack' */
++#define DUK_STRIDX_THROW_TYPE_ERROR                                   84                             /* 'ThrowTypeError' */
++#define DUK_STRIDX_DUKTAPE                                            85                             /* 'Duktape' */
++#define DUK_STRIDX_ID                                                 86                             /* 'id' */
++#define DUK_STRIDX_REQUIRE                                            87                             /* 'require' */
++#define DUK_STRIDX___PROTO__                                          88                             /* '__proto__' */
++#define DUK_STRIDX_SET_PROTOTYPE_OF                                   89                             /* 'setPrototypeOf' */
++#define DUK_STRIDX_OWN_KEYS                                           90                             /* 'ownKeys' */
++#define DUK_STRIDX_ENUMERATE                                          91                             /* 'enumerate' */
++#define DUK_STRIDX_DELETE_PROPERTY                                    92                             /* 'deleteProperty' */
++#define DUK_STRIDX_HAS                                                93                             /* 'has' */
++#define DUK_STRIDX_PROXY                                              94                             /* 'Proxy' */
++#define DUK_STRIDX_CALLEE                                             95                             /* 'callee' */
++#define DUK_STRIDX_INVALID_DATE                                       96                             /* 'Invalid Date' */
++#define DUK_STRIDX_BRACKETED_ELLIPSIS                                 97                             /* '[...]' */
++#define DUK_STRIDX_NEWLINE_TAB                                        98                             /* '\n\t' */
++#define DUK_STRIDX_SPACE                                              99                             /* ' ' */
++#define DUK_STRIDX_COMMA                                              100                            /* ',' */
++#define DUK_STRIDX_MINUS_ZERO                                         101                            /* '-0' */
++#define DUK_STRIDX_PLUS_ZERO                                          102                            /* '+0' */
++#define DUK_STRIDX_ZERO                                               103                            /* '0' */
++#define DUK_STRIDX_MINUS_INFINITY                                     104                            /* '-Infinity' */
++#define DUK_STRIDX_PLUS_INFINITY                                      105                            /* '+Infinity' */
++#define DUK_STRIDX_INFINITY                                           106                            /* 'Infinity' */
++#define DUK_STRIDX_LC_OBJECT                                          107                            /* 'object' */
++#define DUK_STRIDX_LC_STRING                                          108                            /* 'string' */
++#define DUK_STRIDX_LC_NUMBER                                          109                            /* 'number' */
++#define DUK_STRIDX_LC_BOOLEAN                                         110                            /* 'boolean' */
++#define DUK_STRIDX_LC_UNDEFINED                                       111                            /* 'undefined' */
++#define DUK_STRIDX_STRINGIFY                                          112                            /* 'stringify' */
++#define DUK_STRIDX_TAN                                                113                            /* 'tan' */
++#define DUK_STRIDX_SQRT                                               114                            /* 'sqrt' */
++#define DUK_STRIDX_SIN                                                115                            /* 'sin' */
++#define DUK_STRIDX_ROUND                                              116                            /* 'round' */
++#define DUK_STRIDX_RANDOM                                             117                            /* 'random' */
++#define DUK_STRIDX_POW                                                118                            /* 'pow' */
++#define DUK_STRIDX_MIN                                                119                            /* 'min' */
++#define DUK_STRIDX_MAX                                                120                            /* 'max' */
++#define DUK_STRIDX_LOG                                                121                            /* 'log' */
++#define DUK_STRIDX_FLOOR                                              122                            /* 'floor' */
++#define DUK_STRIDX_EXP                                                123                            /* 'exp' */
++#define DUK_STRIDX_COS                                                124                            /* 'cos' */
++#define DUK_STRIDX_CEIL                                               125                            /* 'ceil' */
++#define DUK_STRIDX_ATAN2                                              126                            /* 'atan2' */
++#define DUK_STRIDX_ATAN                                               127                            /* 'atan' */
++#define DUK_STRIDX_ASIN                                               128                            /* 'asin' */
++#define DUK_STRIDX_ACOS                                               129                            /* 'acos' */
++#define DUK_STRIDX_ABS                                                130                            /* 'abs' */
++#define DUK_STRIDX_SQRT2                                              131                            /* 'SQRT2' */
++#define DUK_STRIDX_SQRT1_2                                            132                            /* 'SQRT1_2' */
++#define DUK_STRIDX_PI                                                 133                            /* 'PI' */
++#define DUK_STRIDX_LOG10E                                             134                            /* 'LOG10E' */
++#define DUK_STRIDX_LOG2E                                              135                            /* 'LOG2E' */
++#define DUK_STRIDX_LN2                                                136                            /* 'LN2' */
++#define DUK_STRIDX_LN10                                               137                            /* 'LN10' */
++#define DUK_STRIDX_E                                                  138                            /* 'E' */
++#define DUK_STRIDX_MESSAGE                                            139                            /* 'message' */
++#define DUK_STRIDX_NAME                                               140                            /* 'name' */
++#define DUK_STRIDX_INPUT                                              141                            /* 'input' */
++#define DUK_STRIDX_INDEX                                              142                            /* 'index' */
++#define DUK_STRIDX_ESCAPED_EMPTY_REGEXP                               143                            /* '(?:)' */
++#define DUK_STRIDX_LAST_INDEX                                         144                            /* 'lastIndex' */
++#define DUK_STRIDX_MULTILINE                                          145                            /* 'multiline' */
++#define DUK_STRIDX_IGNORE_CASE                                        146                            /* 'ignoreCase' */
++#define DUK_STRIDX_SOURCE                                             147                            /* 'source' */
++#define DUK_STRIDX_TEST                                               148                            /* 'test' */
++#define DUK_STRIDX_EXEC                                               149                            /* 'exec' */
++#define DUK_STRIDX_TO_GMT_STRING                                      150                            /* 'toGMTString' */
++#define DUK_STRIDX_SET_YEAR                                           151                            /* 'setYear' */
++#define DUK_STRIDX_GET_YEAR                                           152                            /* 'getYear' */
++#define DUK_STRIDX_TO_JSON                                            153                            /* 'toJSON' */
++#define DUK_STRIDX_TO_ISO_STRING                                      154                            /* 'toISOString' */
++#define DUK_STRIDX_TO_UTC_STRING                                      155                            /* 'toUTCString' */
++#define DUK_STRIDX_SET_UTC_FULL_YEAR                                  156                            /* 'setUTCFullYear' */
++#define DUK_STRIDX_SET_FULL_YEAR                                      157                            /* 'setFullYear' */
++#define DUK_STRIDX_SET_UTC_MONTH                                      158                            /* 'setUTCMonth' */
++#define DUK_STRIDX_SET_MONTH                                          159                            /* 'setMonth' */
++#define DUK_STRIDX_SET_UTC_DATE                                       160                            /* 'setUTCDate' */
++#define DUK_STRIDX_SET_DATE                                           161                            /* 'setDate' */
++#define DUK_STRIDX_SET_UTC_HOURS                                      162                            /* 'setUTCHours' */
++#define DUK_STRIDX_SET_HOURS                                          163                            /* 'setHours' */
++#define DUK_STRIDX_SET_UTC_MINUTES                                    164                            /* 'setUTCMinutes' */
++#define DUK_STRIDX_SET_MINUTES                                        165                            /* 'setMinutes' */
++#define DUK_STRIDX_SET_UTC_SECONDS                                    166                            /* 'setUTCSeconds' */
++#define DUK_STRIDX_SET_SECONDS                                        167                            /* 'setSeconds' */
++#define DUK_STRIDX_SET_UTC_MILLISECONDS                               168                            /* 'setUTCMilliseconds' */
++#define DUK_STRIDX_SET_MILLISECONDS                                   169                            /* 'setMilliseconds' */
++#define DUK_STRIDX_SET_TIME                                           170                            /* 'setTime' */
++#define DUK_STRIDX_GET_TIMEZONE_OFFSET                                171                            /* 'getTimezoneOffset' */
++#define DUK_STRIDX_GET_UTC_MILLISECONDS                               172                            /* 'getUTCMilliseconds' */
++#define DUK_STRIDX_GET_MILLISECONDS                                   173                            /* 'getMilliseconds' */
++#define DUK_STRIDX_GET_UTC_SECONDS                                    174                            /* 'getUTCSeconds' */
++#define DUK_STRIDX_GET_SECONDS                                        175                            /* 'getSeconds' */
++#define DUK_STRIDX_GET_UTC_MINUTES                                    176                            /* 'getUTCMinutes' */
++#define DUK_STRIDX_GET_MINUTES                                        177                            /* 'getMinutes' */
++#define DUK_STRIDX_GET_UTC_HOURS                                      178                            /* 'getUTCHours' */
++#define DUK_STRIDX_GET_HOURS                                          179                            /* 'getHours' */
++#define DUK_STRIDX_GET_UTC_DAY                                        180                            /* 'getUTCDay' */
++#define DUK_STRIDX_GET_DAY                                            181                            /* 'getDay' */
++#define DUK_STRIDX_GET_UTC_DATE                                       182                            /* 'getUTCDate' */
++#define DUK_STRIDX_GET_DATE                                           183                            /* 'getDate' */
++#define DUK_STRIDX_GET_UTC_MONTH                                      184                            /* 'getUTCMonth' */
++#define DUK_STRIDX_GET_MONTH                                          185                            /* 'getMonth' */
++#define DUK_STRIDX_GET_UTC_FULL_YEAR                                  186                            /* 'getUTCFullYear' */
++#define DUK_STRIDX_GET_FULL_YEAR                                      187                            /* 'getFullYear' */
++#define DUK_STRIDX_GET_TIME                                           188                            /* 'getTime' */
++#define DUK_STRIDX_TO_LOCALE_TIME_STRING                              189                            /* 'toLocaleTimeString' */
++#define DUK_STRIDX_TO_LOCALE_DATE_STRING                              190                            /* 'toLocaleDateString' */
++#define DUK_STRIDX_TO_TIME_STRING                                     191                            /* 'toTimeString' */
++#define DUK_STRIDX_TO_DATE_STRING                                     192                            /* 'toDateString' */
++#define DUK_STRIDX_NOW                                                193                            /* 'now' */
++#define DUK_STRIDX_UTC                                                194                            /* 'UTC' */
++#define DUK_STRIDX_PARSE                                              195                            /* 'parse' */
++#define DUK_STRIDX_TO_PRECISION                                       196                            /* 'toPrecision' */
++#define DUK_STRIDX_TO_EXPONENTIAL                                     197                            /* 'toExponential' */
++#define DUK_STRIDX_TO_FIXED                                           198                            /* 'toFixed' */
++#define DUK_STRIDX_POSITIVE_INFINITY                                  199                            /* 'POSITIVE_INFINITY' */
++#define DUK_STRIDX_NEGATIVE_INFINITY                                  200                            /* 'NEGATIVE_INFINITY' */
++#define DUK_STRIDX_NAN                                                201                            /* 'NaN' */
++#define DUK_STRIDX_MIN_VALUE                                          202                            /* 'MIN_VALUE' */
++#define DUK_STRIDX_MAX_VALUE                                          203                            /* 'MAX_VALUE' */
++#define DUK_STRIDX_SUBSTR                                             204                            /* 'substr' */
++#define DUK_STRIDX_TRIM                                               205                            /* 'trim' */
++#define DUK_STRIDX_TO_LOCALE_UPPER_CASE                               206                            /* 'toLocaleUpperCase' */
++#define DUK_STRIDX_TO_UPPER_CASE                                      207                            /* 'toUpperCase' */
++#define DUK_STRIDX_TO_LOCALE_LOWER_CASE                               208                            /* 'toLocaleLowerCase' */
++#define DUK_STRIDX_TO_LOWER_CASE                                      209                            /* 'toLowerCase' */
++#define DUK_STRIDX_SUBSTRING                                          210                            /* 'substring' */
++#define DUK_STRIDX_SPLIT                                              211                            /* 'split' */
++#define DUK_STRIDX_SEARCH                                             212                            /* 'search' */
++#define DUK_STRIDX_REPLACE                                            213                            /* 'replace' */
++#define DUK_STRIDX_MATCH                                              214                            /* 'match' */
++#define DUK_STRIDX_LOCALE_COMPARE                                     215                            /* 'localeCompare' */
++#define DUK_STRIDX_CHAR_CODE_AT                                       216                            /* 'charCodeAt' */
++#define DUK_STRIDX_CHAR_AT                                            217                            /* 'charAt' */
++#define DUK_STRIDX_FROM_CHAR_CODE                                     218                            /* 'fromCharCode' */
++#define DUK_STRIDX_REDUCE_RIGHT                                       219                            /* 'reduceRight' */
++#define DUK_STRIDX_REDUCE                                             220                            /* 'reduce' */
++#define DUK_STRIDX_FILTER                                             221                            /* 'filter' */
++#define DUK_STRIDX_MAP                                                222                            /* 'map' */
++#define DUK_STRIDX_FOR_EACH                                           223                            /* 'forEach' */
++#define DUK_STRIDX_SOME                                               224                            /* 'some' */
++#define DUK_STRIDX_EVERY                                              225                            /* 'every' */
++#define DUK_STRIDX_LAST_INDEX_OF                                      226                            /* 'lastIndexOf' */
++#define DUK_STRIDX_INDEX_OF                                           227                            /* 'indexOf' */
++#define DUK_STRIDX_UNSHIFT                                            228                            /* 'unshift' */
++#define DUK_STRIDX_SPLICE                                             229                            /* 'splice' */
++#define DUK_STRIDX_SORT                                               230                            /* 'sort' */
++#define DUK_STRIDX_SLICE                                              231                            /* 'slice' */
++#define DUK_STRIDX_SHIFT                                              232                            /* 'shift' */
++#define DUK_STRIDX_REVERSE                                            233                            /* 'reverse' */
++#define DUK_STRIDX_PUSH                                               234                            /* 'push' */
++#define DUK_STRIDX_POP                                                235                            /* 'pop' */
++#define DUK_STRIDX_JOIN                                               236                            /* 'join' */
++#define DUK_STRIDX_CONCAT                                             237                            /* 'concat' */
++#define DUK_STRIDX_IS_ARRAY                                           238                            /* 'isArray' */
++#define DUK_STRIDX_LC_ARGUMENTS                                       239                            /* 'arguments' */
++#define DUK_STRIDX_CALLER                                             240                            /* 'caller' */
++#define DUK_STRIDX_BIND                                               241                            /* 'bind' */
++#define DUK_STRIDX_CALL                                               242                            /* 'call' */
++#define DUK_STRIDX_APPLY                                              243                            /* 'apply' */
++#define DUK_STRIDX_PROPERTY_IS_ENUMERABLE                             244                            /* 'propertyIsEnumerable' */
++#define DUK_STRIDX_IS_PROTOTYPE_OF                                    245                            /* 'isPrototypeOf' */
++#define DUK_STRIDX_HAS_OWN_PROPERTY                                   246                            /* 'hasOwnProperty' */
++#define DUK_STRIDX_VALUE_OF                                           247                            /* 'valueOf' */
++#define DUK_STRIDX_TO_LOCALE_STRING                                   248                            /* 'toLocaleString' */
++#define DUK_STRIDX_TO_STRING                                          249                            /* 'toString' */
++#define DUK_STRIDX_CONSTRUCTOR                                        250                            /* 'constructor' */
++#define DUK_STRIDX_SET                                                251                            /* 'set' */
++#define DUK_STRIDX_GET                                                252                            /* 'get' */
++#define DUK_STRIDX_ENUMERABLE                                         253                            /* 'enumerable' */
++#define DUK_STRIDX_CONFIGURABLE                                       254                            /* 'configurable' */
++#define DUK_STRIDX_WRITABLE                                           255                            /* 'writable' */
++#define DUK_STRIDX_VALUE                                              256                            /* 'value' */
++#define DUK_STRIDX_KEYS                                               257                            /* 'keys' */
++#define DUK_STRIDX_IS_EXTENSIBLE                                      258                            /* 'isExtensible' */
++#define DUK_STRIDX_IS_FROZEN                                          259                            /* 'isFrozen' */
++#define DUK_STRIDX_IS_SEALED                                          260                            /* 'isSealed' */
++#define DUK_STRIDX_PREVENT_EXTENSIONS                                 261                            /* 'preventExtensions' */
++#define DUK_STRIDX_FREEZE                                             262                            /* 'freeze' */
++#define DUK_STRIDX_SEAL                                               263                            /* 'seal' */
++#define DUK_STRIDX_DEFINE_PROPERTIES                                  264                            /* 'defineProperties' */
++#define DUK_STRIDX_DEFINE_PROPERTY                                    265                            /* 'defineProperty' */
++#define DUK_STRIDX_CREATE                                             266                            /* 'create' */
++#define DUK_STRIDX_GET_OWN_PROPERTY_NAMES                             267                            /* 'getOwnPropertyNames' */
++#define DUK_STRIDX_GET_OWN_PROPERTY_DESCRIPTOR                        268                            /* 'getOwnPropertyDescriptor' */
++#define DUK_STRIDX_GET_PROTOTYPE_OF                                   269                            /* 'getPrototypeOf' */
++#define DUK_STRIDX_PROTOTYPE                                          270                            /* 'prototype' */
++#define DUK_STRIDX_LENGTH                                             271                            /* 'length' */
++#define DUK_STRIDX_ALERT                                              272                            /* 'alert' */
++#define DUK_STRIDX_PRINT                                              273                            /* 'print' */
++#define DUK_STRIDX_UNESCAPE                                           274                            /* 'unescape' */
++#define DUK_STRIDX_ESCAPE                                             275                            /* 'escape' */
++#define DUK_STRIDX_ENCODE_URI_COMPONENT                               276                            /* 'encodeURIComponent' */
++#define DUK_STRIDX_ENCODE_URI                                         277                            /* 'encodeURI' */
++#define DUK_STRIDX_DECODE_URI_COMPONENT                               278                            /* 'decodeURIComponent' */
++#define DUK_STRIDX_DECODE_URI                                         279                            /* 'decodeURI' */
++#define DUK_STRIDX_IS_FINITE                                          280                            /* 'isFinite' */
++#define DUK_STRIDX_IS_NAN                                             281                            /* 'isNaN' */
++#define DUK_STRIDX_PARSE_FLOAT                                        282                            /* 'parseFloat' */
++#define DUK_STRIDX_PARSE_INT                                          283                            /* 'parseInt' */
++#define DUK_STRIDX_EVAL                                               284                            /* 'eval' */
++#define DUK_STRIDX_URI_ERROR                                          285                            /* 'URIError' */
++#define DUK_STRIDX_TYPE_ERROR                                         286                            /* 'TypeError' */
++#define DUK_STRIDX_SYNTAX_ERROR                                       287                            /* 'SyntaxError' */
++#define DUK_STRIDX_REFERENCE_ERROR                                    288                            /* 'ReferenceError' */
++#define DUK_STRIDX_RANGE_ERROR                                        289                            /* 'RangeError' */
++#define DUK_STRIDX_EVAL_ERROR                                         290                            /* 'EvalError' */
++#define DUK_STRIDX_BREAK                                              291                            /* 'break' */
++#define DUK_STRIDX_CASE                                               292                            /* 'case' */
++#define DUK_STRIDX_CATCH                                              293                            /* 'catch' */
++#define DUK_STRIDX_CONTINUE                                           294                            /* 'continue' */
++#define DUK_STRIDX_DEBUGGER                                           295                            /* 'debugger' */
++#define DUK_STRIDX_DEFAULT                                            296                            /* 'default' */
++#define DUK_STRIDX_DELETE                                             297                            /* 'delete' */
++#define DUK_STRIDX_DO                                                 298                            /* 'do' */
++#define DUK_STRIDX_ELSE                                               299                            /* 'else' */
++#define DUK_STRIDX_FINALLY                                            300                            /* 'finally' */
++#define DUK_STRIDX_FOR                                                301                            /* 'for' */
++#define DUK_STRIDX_LC_FUNCTION                                        302                            /* 'function' */
++#define DUK_STRIDX_IF                                                 303                            /* 'if' */
++#define DUK_STRIDX_IN                                                 304                            /* 'in' */
++#define DUK_STRIDX_INSTANCEOF                                         305                            /* 'instanceof' */
++#define DUK_STRIDX_NEW                                                306                            /* 'new' */
++#define DUK_STRIDX_RETURN                                             307                            /* 'return' */
++#define DUK_STRIDX_SWITCH                                             308                            /* 'switch' */
++#define DUK_STRIDX_THIS                                               309                            /* 'this' */
++#define DUK_STRIDX_THROW                                              310                            /* 'throw' */
++#define DUK_STRIDX_TRY                                                311                            /* 'try' */
++#define DUK_STRIDX_TYPEOF                                             312                            /* 'typeof' */
++#define DUK_STRIDX_VAR                                                313                            /* 'var' */
++#define DUK_STRIDX_VOID                                               314                            /* 'void' */
++#define DUK_STRIDX_WHILE                                              315                            /* 'while' */
++#define DUK_STRIDX_WITH                                               316                            /* 'with' */
++#define DUK_STRIDX_CLASS                                              317                            /* 'class' */
++#define DUK_STRIDX_CONST                                              318                            /* 'const' */
++#define DUK_STRIDX_ENUM                                               319                            /* 'enum' */
++#define DUK_STRIDX_EXPORT                                             320                            /* 'export' */
++#define DUK_STRIDX_EXTENDS                                            321                            /* 'extends' */
++#define DUK_STRIDX_IMPORT                                             322                            /* 'import' */
++#define DUK_STRIDX_SUPER                                              323                            /* 'super' */
++#define DUK_STRIDX_LC_NULL                                            324                            /* 'null' */
++#define DUK_STRIDX_TRUE                                               325                            /* 'true' */
++#define DUK_STRIDX_FALSE                                              326                            /* 'false' */
++#define DUK_STRIDX_IMPLEMENTS                                         327                            /* 'implements' */
++#define DUK_STRIDX_INTERFACE                                          328                            /* 'interface' */
++#define DUK_STRIDX_LET                                                329                            /* 'let' */
++#define DUK_STRIDX_PACKAGE                                            330                            /* 'package' */
++#define DUK_STRIDX_PRIVATE                                            331                            /* 'private' */
++#define DUK_STRIDX_PROTECTED                                          332                            /* 'protected' */
++#define DUK_STRIDX_PUBLIC                                             333                            /* 'public' */
++#define DUK_STRIDX_STATIC                                             334                            /* 'static' */
++#define DUK_STRIDX_YIELD                                              335                            /* 'yield' */
++
++#define DUK_HEAP_STRING_UC_LOGGER(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_LOGGER)
++#define DUK_HTHREAD_STRING_UC_LOGGER(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_LOGGER)
++#define DUK_HEAP_STRING_UC_THREAD(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_THREAD)
++#define DUK_HTHREAD_STRING_UC_THREAD(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_THREAD)
++#define DUK_HEAP_STRING_UC_POINTER(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_POINTER)
++#define DUK_HTHREAD_STRING_UC_POINTER(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_POINTER)
++#define DUK_HEAP_STRING_UC_BUFFER(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_BUFFER)
++#define DUK_HTHREAD_STRING_UC_BUFFER(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_BUFFER)
++#define DUK_HEAP_STRING_DEC_ENV(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEC_ENV)
++#define DUK_HTHREAD_STRING_DEC_ENV(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEC_ENV)
++#define DUK_HEAP_STRING_OBJ_ENV(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_OBJ_ENV)
++#define DUK_HTHREAD_STRING_OBJ_ENV(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_OBJ_ENV)
++#define DUK_HEAP_STRING_EMPTY_STRING(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EMPTY_STRING)
++#define DUK_HTHREAD_STRING_EMPTY_STRING(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EMPTY_STRING)
++#define DUK_HEAP_STRING_GLOBAL(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GLOBAL)
++#define DUK_HTHREAD_STRING_GLOBAL(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GLOBAL)
++#define DUK_HEAP_STRING_UC_ARGUMENTS(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_ARGUMENTS)
++#define DUK_HTHREAD_STRING_UC_ARGUMENTS(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_ARGUMENTS)
++#define DUK_HEAP_STRING_JSON(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON)
++#define DUK_HTHREAD_STRING_JSON(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON)
++#define DUK_HEAP_STRING_MATH(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MATH)
++#define DUK_HTHREAD_STRING_MATH(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MATH)
++#define DUK_HEAP_STRING_UC_ERROR(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_ERROR)
++#define DUK_HTHREAD_STRING_UC_ERROR(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_ERROR)
++#define DUK_HEAP_STRING_REG_EXP(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REG_EXP)
++#define DUK_HTHREAD_STRING_REG_EXP(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REG_EXP)
++#define DUK_HEAP_STRING_DATE(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DATE)
++#define DUK_HTHREAD_STRING_DATE(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DATE)
++#define DUK_HEAP_STRING_UC_NUMBER(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_NUMBER)
++#define DUK_HTHREAD_STRING_UC_NUMBER(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_NUMBER)
++#define DUK_HEAP_STRING_UC_BOOLEAN(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_BOOLEAN)
++#define DUK_HTHREAD_STRING_UC_BOOLEAN(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_BOOLEAN)
++#define DUK_HEAP_STRING_UC_STRING(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_STRING)
++#define DUK_HTHREAD_STRING_UC_STRING(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_STRING)
++#define DUK_HEAP_STRING_ARRAY(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ARRAY)
++#define DUK_HTHREAD_STRING_ARRAY(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ARRAY)
++#define DUK_HEAP_STRING_UC_FUNCTION(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_FUNCTION)
++#define DUK_HTHREAD_STRING_UC_FUNCTION(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_FUNCTION)
++#define DUK_HEAP_STRING_UC_OBJECT(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_OBJECT)
++#define DUK_HTHREAD_STRING_UC_OBJECT(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_OBJECT)
++#define DUK_HEAP_STRING_UC_NULL(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_NULL)
++#define DUK_HTHREAD_STRING_UC_NULL(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_NULL)
++#define DUK_HEAP_STRING_UC_UNDEFINED(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_UNDEFINED)
++#define DUK_HTHREAD_STRING_UC_UNDEFINED(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_UNDEFINED)
++#define DUK_HEAP_STRING_JSON_EXT_FUNCTION2(heap)                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_FUNCTION2)
++#define DUK_HTHREAD_STRING_JSON_EXT_FUNCTION2(thr)                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_FUNCTION2)
++#define DUK_HEAP_STRING_JSON_EXT_FUNCTION1(heap)                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_FUNCTION1)
++#define DUK_HTHREAD_STRING_JSON_EXT_FUNCTION1(thr)                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_FUNCTION1)
++#define DUK_HEAP_STRING_JSON_EXT_NEGINF(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_NEGINF)
++#define DUK_HTHREAD_STRING_JSON_EXT_NEGINF(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_NEGINF)
++#define DUK_HEAP_STRING_JSON_EXT_POSINF(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_POSINF)
++#define DUK_HTHREAD_STRING_JSON_EXT_POSINF(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_POSINF)
++#define DUK_HEAP_STRING_JSON_EXT_NAN(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_NAN)
++#define DUK_HTHREAD_STRING_JSON_EXT_NAN(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_NAN)
++#define DUK_HEAP_STRING_JSON_EXT_UNDEFINED(heap)                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_UNDEFINED)
++#define DUK_HTHREAD_STRING_JSON_EXT_UNDEFINED(thr)                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_UNDEFINED)
++#define DUK_HEAP_STRING_TO_LOG_STRING(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOG_STRING)
++#define DUK_HTHREAD_STRING_TO_LOG_STRING(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOG_STRING)
++#define DUK_HEAP_STRING_CLOG(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CLOG)
++#define DUK_HTHREAD_STRING_CLOG(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CLOG)
++#define DUK_HEAP_STRING_LC_L(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_L)
++#define DUK_HTHREAD_STRING_LC_L(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_L)
++#define DUK_HEAP_STRING_LC_N(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_N)
++#define DUK_HTHREAD_STRING_LC_N(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_N)
++#define DUK_HEAP_STRING_LC_FATAL(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_FATAL)
++#define DUK_HTHREAD_STRING_LC_FATAL(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_FATAL)
++#define DUK_HEAP_STRING_LC_ERROR(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_ERROR)
++#define DUK_HTHREAD_STRING_LC_ERROR(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_ERROR)
++#define DUK_HEAP_STRING_LC_WARN(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_WARN)
++#define DUK_HTHREAD_STRING_LC_WARN(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_WARN)
++#define DUK_HEAP_STRING_LC_DEBUG(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_DEBUG)
++#define DUK_HTHREAD_STRING_LC_DEBUG(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_DEBUG)
++#define DUK_HEAP_STRING_LC_TRACE(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_TRACE)
++#define DUK_HTHREAD_STRING_LC_TRACE(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_TRACE)
++#define DUK_HEAP_STRING_RAW(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RAW)
++#define DUK_HTHREAD_STRING_RAW(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RAW)
++#define DUK_HEAP_STRING_FMT(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FMT)
++#define DUK_HTHREAD_STRING_FMT(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FMT)
++#define DUK_HEAP_STRING_CURRENT(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CURRENT)
++#define DUK_HTHREAD_STRING_CURRENT(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CURRENT)
++#define DUK_HEAP_STRING_RESUME(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RESUME)
++#define DUK_HTHREAD_STRING_RESUME(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RESUME)
++#define DUK_HEAP_STRING_COMPACT(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COMPACT)
++#define DUK_HTHREAD_STRING_COMPACT(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COMPACT)
++#define DUK_HEAP_STRING_JC(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JC)
++#define DUK_HTHREAD_STRING_JC(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JC)
++#define DUK_HEAP_STRING_JX(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JX)
++#define DUK_HTHREAD_STRING_JX(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JX)
++#define DUK_HEAP_STRING_BASE64(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BASE64)
++#define DUK_HTHREAD_STRING_BASE64(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BASE64)
++#define DUK_HEAP_STRING_HEX(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_HEX)
++#define DUK_HTHREAD_STRING_HEX(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_HEX)
++#define DUK_HEAP_STRING_DEC(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEC)
++#define DUK_HTHREAD_STRING_DEC(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEC)
++#define DUK_HEAP_STRING_ENC(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENC)
++#define DUK_HTHREAD_STRING_ENC(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENC)
++#define DUK_HEAP_STRING_FIN(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FIN)
++#define DUK_HTHREAD_STRING_FIN(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FIN)
++#define DUK_HEAP_STRING_GC(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GC)
++#define DUK_HTHREAD_STRING_GC(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GC)
++#define DUK_HEAP_STRING_ACT(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ACT)
++#define DUK_HTHREAD_STRING_ACT(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ACT)
++#define DUK_HEAP_STRING_LC_INFO(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_INFO)
++#define DUK_HTHREAD_STRING_LC_INFO(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_INFO)
++#define DUK_HEAP_STRING_VERSION(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VERSION)
++#define DUK_HTHREAD_STRING_VERSION(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VERSION)
++#define DUK_HEAP_STRING_ENV(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENV)
++#define DUK_HTHREAD_STRING_ENV(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENV)
++#define DUK_HEAP_STRING_MOD_LOADED(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MOD_LOADED)
++#define DUK_HTHREAD_STRING_MOD_LOADED(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MOD_LOADED)
++#define DUK_HEAP_STRING_MOD_SEARCH(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MOD_SEARCH)
++#define DUK_HTHREAD_STRING_MOD_SEARCH(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MOD_SEARCH)
++#define DUK_HEAP_STRING_ERR_THROW(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ERR_THROW)
++#define DUK_HTHREAD_STRING_ERR_THROW(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ERR_THROW)
++#define DUK_HEAP_STRING_ERR_CREATE(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ERR_CREATE)
++#define DUK_HTHREAD_STRING_ERR_CREATE(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ERR_CREATE)
++#define DUK_HEAP_STRING_COMPILE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COMPILE)
++#define DUK_HTHREAD_STRING_COMPILE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COMPILE)
++#define DUK_HEAP_STRING_INT_REGBASE(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_REGBASE)
++#define DUK_HTHREAD_STRING_INT_REGBASE(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_REGBASE)
++#define DUK_HEAP_STRING_INT_THREAD(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_THREAD)
++#define DUK_HTHREAD_STRING_INT_THREAD(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_THREAD)
++#define DUK_HEAP_STRING_INT_HANDLER(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_HANDLER)
++#define DUK_HTHREAD_STRING_INT_HANDLER(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_HANDLER)
++#define DUK_HEAP_STRING_INT_FINALIZER(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_FINALIZER)
++#define DUK_HTHREAD_STRING_INT_FINALIZER(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_FINALIZER)
++#define DUK_HEAP_STRING_INT_CALLEE(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_CALLEE)
++#define DUK_HTHREAD_STRING_INT_CALLEE(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_CALLEE)
++#define DUK_HEAP_STRING_INT_MAP(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_MAP)
++#define DUK_HTHREAD_STRING_INT_MAP(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_MAP)
++#define DUK_HEAP_STRING_INT_ARGS(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_ARGS)
++#define DUK_HTHREAD_STRING_INT_ARGS(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_ARGS)
++#define DUK_HEAP_STRING_INT_THIS(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_THIS)
++#define DUK_HTHREAD_STRING_INT_THIS(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_THIS)
++#define DUK_HEAP_STRING_INT_PC2LINE(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_PC2LINE)
++#define DUK_HTHREAD_STRING_INT_PC2LINE(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_PC2LINE)
++#define DUK_HEAP_STRING_INT_SOURCE(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_SOURCE)
++#define DUK_HTHREAD_STRING_INT_SOURCE(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_SOURCE)
++#define DUK_HEAP_STRING_INT_VARENV(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_VARENV)
++#define DUK_HTHREAD_STRING_INT_VARENV(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_VARENV)
++#define DUK_HEAP_STRING_INT_LEXENV(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_LEXENV)
++#define DUK_HTHREAD_STRING_INT_LEXENV(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_LEXENV)
++#define DUK_HEAP_STRING_INT_VARMAP(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_VARMAP)
++#define DUK_HTHREAD_STRING_INT_VARMAP(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_VARMAP)
++#define DUK_HEAP_STRING_INT_FORMALS(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_FORMALS)
++#define DUK_HTHREAD_STRING_INT_FORMALS(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_FORMALS)
++#define DUK_HEAP_STRING_INT_BYTECODE(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_BYTECODE)
++#define DUK_HTHREAD_STRING_INT_BYTECODE(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_BYTECODE)
++#define DUK_HEAP_STRING_INT_NEXT(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_NEXT)
++#define DUK_HTHREAD_STRING_INT_NEXT(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_NEXT)
++#define DUK_HEAP_STRING_INT_TARGET(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_TARGET)
++#define DUK_HTHREAD_STRING_INT_TARGET(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_TARGET)
++#define DUK_HEAP_STRING_INT_VALUE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_VALUE)
++#define DUK_HTHREAD_STRING_INT_VALUE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_VALUE)
++#define DUK_HEAP_STRING_LC_POINTER(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_POINTER)
++#define DUK_HTHREAD_STRING_LC_POINTER(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_POINTER)
++#define DUK_HEAP_STRING_LC_BUFFER(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_BUFFER)
++#define DUK_HTHREAD_STRING_LC_BUFFER(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_BUFFER)
++#define DUK_HEAP_STRING_INT_TRACEDATA(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_TRACEDATA)
++#define DUK_HTHREAD_STRING_INT_TRACEDATA(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_TRACEDATA)
++#define DUK_HEAP_STRING_LINE_NUMBER(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LINE_NUMBER)
++#define DUK_HTHREAD_STRING_LINE_NUMBER(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LINE_NUMBER)
++#define DUK_HEAP_STRING_FILE_NAME(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FILE_NAME)
++#define DUK_HTHREAD_STRING_FILE_NAME(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FILE_NAME)
++#define DUK_HEAP_STRING_PC(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PC)
++#define DUK_HTHREAD_STRING_PC(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PC)
++#define DUK_HEAP_STRING_STACK(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_STACK)
++#define DUK_HTHREAD_STRING_STACK(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_STACK)
++#define DUK_HEAP_STRING_THROW_TYPE_ERROR(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_THROW_TYPE_ERROR)
++#define DUK_HTHREAD_STRING_THROW_TYPE_ERROR(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_THROW_TYPE_ERROR)
++#define DUK_HEAP_STRING_DUKTAPE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DUKTAPE)
++#define DUK_HTHREAD_STRING_DUKTAPE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DUKTAPE)
++#define DUK_HEAP_STRING_ID(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ID)
++#define DUK_HTHREAD_STRING_ID(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ID)
++#define DUK_HEAP_STRING_REQUIRE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REQUIRE)
++#define DUK_HTHREAD_STRING_REQUIRE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REQUIRE)
++#define DUK_HEAP_STRING___PROTO__(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX___PROTO__)
++#define DUK_HTHREAD_STRING___PROTO__(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX___PROTO__)
++#define DUK_HEAP_STRING_SET_PROTOTYPE_OF(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_PROTOTYPE_OF)
++#define DUK_HTHREAD_STRING_SET_PROTOTYPE_OF(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_PROTOTYPE_OF)
++#define DUK_HEAP_STRING_OWN_KEYS(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_OWN_KEYS)
++#define DUK_HTHREAD_STRING_OWN_KEYS(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_OWN_KEYS)
++#define DUK_HEAP_STRING_ENUMERATE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENUMERATE)
++#define DUK_HTHREAD_STRING_ENUMERATE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENUMERATE)
++#define DUK_HEAP_STRING_DELETE_PROPERTY(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DELETE_PROPERTY)
++#define DUK_HTHREAD_STRING_DELETE_PROPERTY(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DELETE_PROPERTY)
++#define DUK_HEAP_STRING_HAS(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_HAS)
++#define DUK_HTHREAD_STRING_HAS(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_HAS)
++#define DUK_HEAP_STRING_PROXY(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROXY)
++#define DUK_HTHREAD_STRING_PROXY(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROXY)
++#define DUK_HEAP_STRING_CALLEE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CALLEE)
++#define DUK_HTHREAD_STRING_CALLEE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CALLEE)
++#define DUK_HEAP_STRING_INVALID_DATE(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INVALID_DATE)
++#define DUK_HTHREAD_STRING_INVALID_DATE(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INVALID_DATE)
++#define DUK_HEAP_STRING_BRACKETED_ELLIPSIS(heap)                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BRACKETED_ELLIPSIS)
++#define DUK_HTHREAD_STRING_BRACKETED_ELLIPSIS(thr)                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BRACKETED_ELLIPSIS)
++#define DUK_HEAP_STRING_NEWLINE_TAB(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NEWLINE_TAB)
++#define DUK_HTHREAD_STRING_NEWLINE_TAB(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NEWLINE_TAB)
++#define DUK_HEAP_STRING_SPACE(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SPACE)
++#define DUK_HTHREAD_STRING_SPACE(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SPACE)
++#define DUK_HEAP_STRING_COMMA(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COMMA)
++#define DUK_HTHREAD_STRING_COMMA(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COMMA)
++#define DUK_HEAP_STRING_MINUS_ZERO(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MINUS_ZERO)
++#define DUK_HTHREAD_STRING_MINUS_ZERO(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MINUS_ZERO)
++#define DUK_HEAP_STRING_PLUS_ZERO(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PLUS_ZERO)
++#define DUK_HTHREAD_STRING_PLUS_ZERO(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PLUS_ZERO)
++#define DUK_HEAP_STRING_ZERO(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ZERO)
++#define DUK_HTHREAD_STRING_ZERO(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ZERO)
++#define DUK_HEAP_STRING_MINUS_INFINITY(heap)                          DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MINUS_INFINITY)
++#define DUK_HTHREAD_STRING_MINUS_INFINITY(thr)                        DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MINUS_INFINITY)
++#define DUK_HEAP_STRING_PLUS_INFINITY(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PLUS_INFINITY)
++#define DUK_HTHREAD_STRING_PLUS_INFINITY(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PLUS_INFINITY)
++#define DUK_HEAP_STRING_INFINITY(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INFINITY)
++#define DUK_HTHREAD_STRING_INFINITY(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INFINITY)
++#define DUK_HEAP_STRING_LC_OBJECT(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_OBJECT)
++#define DUK_HTHREAD_STRING_LC_OBJECT(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_OBJECT)
++#define DUK_HEAP_STRING_LC_STRING(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_STRING)
++#define DUK_HTHREAD_STRING_LC_STRING(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_STRING)
++#define DUK_HEAP_STRING_LC_NUMBER(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_NUMBER)
++#define DUK_HTHREAD_STRING_LC_NUMBER(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_NUMBER)
++#define DUK_HEAP_STRING_LC_BOOLEAN(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_BOOLEAN)
++#define DUK_HTHREAD_STRING_LC_BOOLEAN(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_BOOLEAN)
++#define DUK_HEAP_STRING_LC_UNDEFINED(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_UNDEFINED)
++#define DUK_HTHREAD_STRING_LC_UNDEFINED(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_UNDEFINED)
++#define DUK_HEAP_STRING_STRINGIFY(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_STRINGIFY)
++#define DUK_HTHREAD_STRING_STRINGIFY(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_STRINGIFY)
++#define DUK_HEAP_STRING_TAN(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TAN)
++#define DUK_HTHREAD_STRING_TAN(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TAN)
++#define DUK_HEAP_STRING_SQRT(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SQRT)
++#define DUK_HTHREAD_STRING_SQRT(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SQRT)
++#define DUK_HEAP_STRING_SIN(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SIN)
++#define DUK_HTHREAD_STRING_SIN(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SIN)
++#define DUK_HEAP_STRING_ROUND(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ROUND)
++#define DUK_HTHREAD_STRING_ROUND(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ROUND)
++#define DUK_HEAP_STRING_RANDOM(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RANDOM)
++#define DUK_HTHREAD_STRING_RANDOM(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RANDOM)
++#define DUK_HEAP_STRING_POW(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_POW)
++#define DUK_HTHREAD_STRING_POW(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_POW)
++#define DUK_HEAP_STRING_MIN(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MIN)
++#define DUK_HTHREAD_STRING_MIN(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MIN)
++#define DUK_HEAP_STRING_MAX(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MAX)
++#define DUK_HTHREAD_STRING_MAX(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MAX)
++#define DUK_HEAP_STRING_LOG(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LOG)
++#define DUK_HTHREAD_STRING_LOG(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LOG)
++#define DUK_HEAP_STRING_FLOOR(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FLOOR)
++#define DUK_HTHREAD_STRING_FLOOR(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FLOOR)
++#define DUK_HEAP_STRING_EXP(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXP)
++#define DUK_HTHREAD_STRING_EXP(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXP)
++#define DUK_HEAP_STRING_COS(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COS)
++#define DUK_HTHREAD_STRING_COS(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COS)
++#define DUK_HEAP_STRING_CEIL(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CEIL)
++#define DUK_HTHREAD_STRING_CEIL(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CEIL)
++#define DUK_HEAP_STRING_ATAN2(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ATAN2)
++#define DUK_HTHREAD_STRING_ATAN2(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ATAN2)
++#define DUK_HEAP_STRING_ATAN(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ATAN)
++#define DUK_HTHREAD_STRING_ATAN(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ATAN)
++#define DUK_HEAP_STRING_ASIN(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ASIN)
++#define DUK_HTHREAD_STRING_ASIN(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ASIN)
++#define DUK_HEAP_STRING_ACOS(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ACOS)
++#define DUK_HTHREAD_STRING_ACOS(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ACOS)
++#define DUK_HEAP_STRING_ABS(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ABS)
++#define DUK_HTHREAD_STRING_ABS(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ABS)
++#define DUK_HEAP_STRING_SQRT2(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SQRT2)
++#define DUK_HTHREAD_STRING_SQRT2(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SQRT2)
++#define DUK_HEAP_STRING_SQRT1_2(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SQRT1_2)
++#define DUK_HTHREAD_STRING_SQRT1_2(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SQRT1_2)
++#define DUK_HEAP_STRING_PI(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PI)
++#define DUK_HTHREAD_STRING_PI(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PI)
++#define DUK_HEAP_STRING_LOG10E(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LOG10E)
++#define DUK_HTHREAD_STRING_LOG10E(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LOG10E)
++#define DUK_HEAP_STRING_LOG2E(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LOG2E)
++#define DUK_HTHREAD_STRING_LOG2E(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LOG2E)
++#define DUK_HEAP_STRING_LN2(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LN2)
++#define DUK_HTHREAD_STRING_LN2(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LN2)
++#define DUK_HEAP_STRING_LN10(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LN10)
++#define DUK_HTHREAD_STRING_LN10(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LN10)
++#define DUK_HEAP_STRING_E(heap)                                       DUK_HEAP_GET_STRING((heap),DUK_STRIDX_E)
++#define DUK_HTHREAD_STRING_E(thr)                                     DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_E)
++#define DUK_HEAP_STRING_MESSAGE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MESSAGE)
++#define DUK_HTHREAD_STRING_MESSAGE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MESSAGE)
++#define DUK_HEAP_STRING_NAME(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NAME)
++#define DUK_HTHREAD_STRING_NAME(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NAME)
++#define DUK_HEAP_STRING_INPUT(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INPUT)
++#define DUK_HTHREAD_STRING_INPUT(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INPUT)
++#define DUK_HEAP_STRING_INDEX(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INDEX)
++#define DUK_HTHREAD_STRING_INDEX(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INDEX)
++#define DUK_HEAP_STRING_ESCAPED_EMPTY_REGEXP(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ESCAPED_EMPTY_REGEXP)
++#define DUK_HTHREAD_STRING_ESCAPED_EMPTY_REGEXP(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ESCAPED_EMPTY_REGEXP)
++#define DUK_HEAP_STRING_LAST_INDEX(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LAST_INDEX)
++#define DUK_HTHREAD_STRING_LAST_INDEX(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LAST_INDEX)
++#define DUK_HEAP_STRING_MULTILINE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MULTILINE)
++#define DUK_HTHREAD_STRING_MULTILINE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MULTILINE)
++#define DUK_HEAP_STRING_IGNORE_CASE(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IGNORE_CASE)
++#define DUK_HTHREAD_STRING_IGNORE_CASE(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IGNORE_CASE)
++#define DUK_HEAP_STRING_SOURCE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SOURCE)
++#define DUK_HTHREAD_STRING_SOURCE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SOURCE)
++#define DUK_HEAP_STRING_TEST(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TEST)
++#define DUK_HTHREAD_STRING_TEST(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TEST)
++#define DUK_HEAP_STRING_EXEC(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXEC)
++#define DUK_HTHREAD_STRING_EXEC(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXEC)
++#define DUK_HEAP_STRING_TO_GMT_STRING(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_GMT_STRING)
++#define DUK_HTHREAD_STRING_TO_GMT_STRING(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_GMT_STRING)
++#define DUK_HEAP_STRING_SET_YEAR(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_YEAR)
++#define DUK_HTHREAD_STRING_SET_YEAR(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_YEAR)
++#define DUK_HEAP_STRING_GET_YEAR(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_YEAR)
++#define DUK_HTHREAD_STRING_GET_YEAR(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_YEAR)
++#define DUK_HEAP_STRING_TO_JSON(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_JSON)
++#define DUK_HTHREAD_STRING_TO_JSON(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_JSON)
++#define DUK_HEAP_STRING_TO_ISO_STRING(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_ISO_STRING)
++#define DUK_HTHREAD_STRING_TO_ISO_STRING(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_ISO_STRING)
++#define DUK_HEAP_STRING_TO_UTC_STRING(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_UTC_STRING)
++#define DUK_HTHREAD_STRING_TO_UTC_STRING(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_UTC_STRING)
++#define DUK_HEAP_STRING_SET_UTC_FULL_YEAR(heap)                       DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_FULL_YEAR)
++#define DUK_HTHREAD_STRING_SET_UTC_FULL_YEAR(thr)                     DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_FULL_YEAR)
++#define DUK_HEAP_STRING_SET_FULL_YEAR(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_FULL_YEAR)
++#define DUK_HTHREAD_STRING_SET_FULL_YEAR(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_FULL_YEAR)
++#define DUK_HEAP_STRING_SET_UTC_MONTH(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_MONTH)
++#define DUK_HTHREAD_STRING_SET_UTC_MONTH(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_MONTH)
++#define DUK_HEAP_STRING_SET_MONTH(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_MONTH)
++#define DUK_HTHREAD_STRING_SET_MONTH(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_MONTH)
++#define DUK_HEAP_STRING_SET_UTC_DATE(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_DATE)
++#define DUK_HTHREAD_STRING_SET_UTC_DATE(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_DATE)
++#define DUK_HEAP_STRING_SET_DATE(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_DATE)
++#define DUK_HTHREAD_STRING_SET_DATE(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_DATE)
++#define DUK_HEAP_STRING_SET_UTC_HOURS(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_HOURS)
++#define DUK_HTHREAD_STRING_SET_UTC_HOURS(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_HOURS)
++#define DUK_HEAP_STRING_SET_HOURS(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_HOURS)
++#define DUK_HTHREAD_STRING_SET_HOURS(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_HOURS)
++#define DUK_HEAP_STRING_SET_UTC_MINUTES(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_MINUTES)
++#define DUK_HTHREAD_STRING_SET_UTC_MINUTES(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_MINUTES)
++#define DUK_HEAP_STRING_SET_MINUTES(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_MINUTES)
++#define DUK_HTHREAD_STRING_SET_MINUTES(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_MINUTES)
++#define DUK_HEAP_STRING_SET_UTC_SECONDS(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_SECONDS)
++#define DUK_HTHREAD_STRING_SET_UTC_SECONDS(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_SECONDS)
++#define DUK_HEAP_STRING_SET_SECONDS(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_SECONDS)
++#define DUK_HTHREAD_STRING_SET_SECONDS(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_SECONDS)
++#define DUK_HEAP_STRING_SET_UTC_MILLISECONDS(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_MILLISECONDS)
++#define DUK_HTHREAD_STRING_SET_UTC_MILLISECONDS(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_MILLISECONDS)
++#define DUK_HEAP_STRING_SET_MILLISECONDS(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_MILLISECONDS)
++#define DUK_HTHREAD_STRING_SET_MILLISECONDS(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_MILLISECONDS)
++#define DUK_HEAP_STRING_SET_TIME(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_TIME)
++#define DUK_HTHREAD_STRING_SET_TIME(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_TIME)
++#define DUK_HEAP_STRING_GET_TIMEZONE_OFFSET(heap)                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_TIMEZONE_OFFSET)
++#define DUK_HTHREAD_STRING_GET_TIMEZONE_OFFSET(thr)                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_TIMEZONE_OFFSET)
++#define DUK_HEAP_STRING_GET_UTC_MILLISECONDS(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_MILLISECONDS)
++#define DUK_HTHREAD_STRING_GET_UTC_MILLISECONDS(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_MILLISECONDS)
++#define DUK_HEAP_STRING_GET_MILLISECONDS(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_MILLISECONDS)
++#define DUK_HTHREAD_STRING_GET_MILLISECONDS(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_MILLISECONDS)
++#define DUK_HEAP_STRING_GET_UTC_SECONDS(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_SECONDS)
++#define DUK_HTHREAD_STRING_GET_UTC_SECONDS(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_SECONDS)
++#define DUK_HEAP_STRING_GET_SECONDS(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_SECONDS)
++#define DUK_HTHREAD_STRING_GET_SECONDS(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_SECONDS)
++#define DUK_HEAP_STRING_GET_UTC_MINUTES(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_MINUTES)
++#define DUK_HTHREAD_STRING_GET_UTC_MINUTES(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_MINUTES)
++#define DUK_HEAP_STRING_GET_MINUTES(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_MINUTES)
++#define DUK_HTHREAD_STRING_GET_MINUTES(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_MINUTES)
++#define DUK_HEAP_STRING_GET_UTC_HOURS(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_HOURS)
++#define DUK_HTHREAD_STRING_GET_UTC_HOURS(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_HOURS)
++#define DUK_HEAP_STRING_GET_HOURS(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_HOURS)
++#define DUK_HTHREAD_STRING_GET_HOURS(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_HOURS)
++#define DUK_HEAP_STRING_GET_UTC_DAY(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_DAY)
++#define DUK_HTHREAD_STRING_GET_UTC_DAY(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_DAY)
++#define DUK_HEAP_STRING_GET_DAY(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_DAY)
++#define DUK_HTHREAD_STRING_GET_DAY(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_DAY)
++#define DUK_HEAP_STRING_GET_UTC_DATE(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_DATE)
++#define DUK_HTHREAD_STRING_GET_UTC_DATE(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_DATE)
++#define DUK_HEAP_STRING_GET_DATE(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_DATE)
++#define DUK_HTHREAD_STRING_GET_DATE(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_DATE)
++#define DUK_HEAP_STRING_GET_UTC_MONTH(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_MONTH)
++#define DUK_HTHREAD_STRING_GET_UTC_MONTH(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_MONTH)
++#define DUK_HEAP_STRING_GET_MONTH(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_MONTH)
++#define DUK_HTHREAD_STRING_GET_MONTH(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_MONTH)
++#define DUK_HEAP_STRING_GET_UTC_FULL_YEAR(heap)                       DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_FULL_YEAR)
++#define DUK_HTHREAD_STRING_GET_UTC_FULL_YEAR(thr)                     DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_FULL_YEAR)
++#define DUK_HEAP_STRING_GET_FULL_YEAR(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_FULL_YEAR)
++#define DUK_HTHREAD_STRING_GET_FULL_YEAR(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_FULL_YEAR)
++#define DUK_HEAP_STRING_GET_TIME(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_TIME)
++#define DUK_HTHREAD_STRING_GET_TIME(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_TIME)
++#define DUK_HEAP_STRING_TO_LOCALE_TIME_STRING(heap)                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_TIME_STRING)
++#define DUK_HTHREAD_STRING_TO_LOCALE_TIME_STRING(thr)                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_TIME_STRING)
++#define DUK_HEAP_STRING_TO_LOCALE_DATE_STRING(heap)                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_DATE_STRING)
++#define DUK_HTHREAD_STRING_TO_LOCALE_DATE_STRING(thr)                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_DATE_STRING)
++#define DUK_HEAP_STRING_TO_TIME_STRING(heap)                          DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_TIME_STRING)
++#define DUK_HTHREAD_STRING_TO_TIME_STRING(thr)                        DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_TIME_STRING)
++#define DUK_HEAP_STRING_TO_DATE_STRING(heap)                          DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_DATE_STRING)
++#define DUK_HTHREAD_STRING_TO_DATE_STRING(thr)                        DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_DATE_STRING)
++#define DUK_HEAP_STRING_NOW(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NOW)
++#define DUK_HTHREAD_STRING_NOW(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NOW)
++#define DUK_HEAP_STRING_UTC(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UTC)
++#define DUK_HTHREAD_STRING_UTC(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UTC)
++#define DUK_HEAP_STRING_PARSE(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PARSE)
++#define DUK_HTHREAD_STRING_PARSE(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PARSE)
++#define DUK_HEAP_STRING_TO_PRECISION(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_PRECISION)
++#define DUK_HTHREAD_STRING_TO_PRECISION(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_PRECISION)
++#define DUK_HEAP_STRING_TO_EXPONENTIAL(heap)                          DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_EXPONENTIAL)
++#define DUK_HTHREAD_STRING_TO_EXPONENTIAL(thr)                        DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_EXPONENTIAL)
++#define DUK_HEAP_STRING_TO_FIXED(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_FIXED)
++#define DUK_HTHREAD_STRING_TO_FIXED(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_FIXED)
++#define DUK_HEAP_STRING_POSITIVE_INFINITY(heap)                       DUK_HEAP_GET_STRING((heap),DUK_STRIDX_POSITIVE_INFINITY)
++#define DUK_HTHREAD_STRING_POSITIVE_INFINITY(thr)                     DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_POSITIVE_INFINITY)
++#define DUK_HEAP_STRING_NEGATIVE_INFINITY(heap)                       DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NEGATIVE_INFINITY)
++#define DUK_HTHREAD_STRING_NEGATIVE_INFINITY(thr)                     DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NEGATIVE_INFINITY)
++#define DUK_HEAP_STRING_NAN(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NAN)
++#define DUK_HTHREAD_STRING_NAN(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NAN)
++#define DUK_HEAP_STRING_MIN_VALUE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MIN_VALUE)
++#define DUK_HTHREAD_STRING_MIN_VALUE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MIN_VALUE)
++#define DUK_HEAP_STRING_MAX_VALUE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MAX_VALUE)
++#define DUK_HTHREAD_STRING_MAX_VALUE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MAX_VALUE)
++#define DUK_HEAP_STRING_SUBSTR(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SUBSTR)
++#define DUK_HTHREAD_STRING_SUBSTR(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SUBSTR)
++#define DUK_HEAP_STRING_TRIM(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TRIM)
++#define DUK_HTHREAD_STRING_TRIM(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TRIM)
++#define DUK_HEAP_STRING_TO_LOCALE_UPPER_CASE(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_UPPER_CASE)
++#define DUK_HTHREAD_STRING_TO_LOCALE_UPPER_CASE(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_UPPER_CASE)
++#define DUK_HEAP_STRING_TO_UPPER_CASE(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_UPPER_CASE)
++#define DUK_HTHREAD_STRING_TO_UPPER_CASE(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_UPPER_CASE)
++#define DUK_HEAP_STRING_TO_LOCALE_LOWER_CASE(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_LOWER_CASE)
++#define DUK_HTHREAD_STRING_TO_LOCALE_LOWER_CASE(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_LOWER_CASE)
++#define DUK_HEAP_STRING_TO_LOWER_CASE(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOWER_CASE)
++#define DUK_HTHREAD_STRING_TO_LOWER_CASE(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOWER_CASE)
++#define DUK_HEAP_STRING_SUBSTRING(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SUBSTRING)
++#define DUK_HTHREAD_STRING_SUBSTRING(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SUBSTRING)
++#define DUK_HEAP_STRING_SPLIT(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SPLIT)
++#define DUK_HTHREAD_STRING_SPLIT(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SPLIT)
++#define DUK_HEAP_STRING_SEARCH(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SEARCH)
++#define DUK_HTHREAD_STRING_SEARCH(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SEARCH)
++#define DUK_HEAP_STRING_REPLACE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REPLACE)
++#define DUK_HTHREAD_STRING_REPLACE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REPLACE)
++#define DUK_HEAP_STRING_MATCH(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MATCH)
++#define DUK_HTHREAD_STRING_MATCH(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MATCH)
++#define DUK_HEAP_STRING_LOCALE_COMPARE(heap)                          DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LOCALE_COMPARE)
++#define DUK_HTHREAD_STRING_LOCALE_COMPARE(thr)                        DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LOCALE_COMPARE)
++#define DUK_HEAP_STRING_CHAR_CODE_AT(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CHAR_CODE_AT)
++#define DUK_HTHREAD_STRING_CHAR_CODE_AT(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CHAR_CODE_AT)
++#define DUK_HEAP_STRING_CHAR_AT(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CHAR_AT)
++#define DUK_HTHREAD_STRING_CHAR_AT(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CHAR_AT)
++#define DUK_HEAP_STRING_FROM_CHAR_CODE(heap)                          DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FROM_CHAR_CODE)
++#define DUK_HTHREAD_STRING_FROM_CHAR_CODE(thr)                        DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FROM_CHAR_CODE)
++#define DUK_HEAP_STRING_REDUCE_RIGHT(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REDUCE_RIGHT)
++#define DUK_HTHREAD_STRING_REDUCE_RIGHT(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REDUCE_RIGHT)
++#define DUK_HEAP_STRING_REDUCE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REDUCE)
++#define DUK_HTHREAD_STRING_REDUCE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REDUCE)
++#define DUK_HEAP_STRING_FILTER(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FILTER)
++#define DUK_HTHREAD_STRING_FILTER(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FILTER)
++#define DUK_HEAP_STRING_MAP(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MAP)
++#define DUK_HTHREAD_STRING_MAP(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MAP)
++#define DUK_HEAP_STRING_FOR_EACH(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FOR_EACH)
++#define DUK_HTHREAD_STRING_FOR_EACH(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FOR_EACH)
++#define DUK_HEAP_STRING_SOME(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SOME)
++#define DUK_HTHREAD_STRING_SOME(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SOME)
++#define DUK_HEAP_STRING_EVERY(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EVERY)
++#define DUK_HTHREAD_STRING_EVERY(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EVERY)
++#define DUK_HEAP_STRING_LAST_INDEX_OF(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LAST_INDEX_OF)
++#define DUK_HTHREAD_STRING_LAST_INDEX_OF(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LAST_INDEX_OF)
++#define DUK_HEAP_STRING_INDEX_OF(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INDEX_OF)
++#define DUK_HTHREAD_STRING_INDEX_OF(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INDEX_OF)
++#define DUK_HEAP_STRING_UNSHIFT(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UNSHIFT)
++#define DUK_HTHREAD_STRING_UNSHIFT(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UNSHIFT)
++#define DUK_HEAP_STRING_SPLICE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SPLICE)
++#define DUK_HTHREAD_STRING_SPLICE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SPLICE)
++#define DUK_HEAP_STRING_SORT(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SORT)
++#define DUK_HTHREAD_STRING_SORT(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SORT)
++#define DUK_HEAP_STRING_SLICE(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SLICE)
++#define DUK_HTHREAD_STRING_SLICE(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SLICE)
++#define DUK_HEAP_STRING_SHIFT(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SHIFT)
++#define DUK_HTHREAD_STRING_SHIFT(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SHIFT)
++#define DUK_HEAP_STRING_REVERSE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REVERSE)
++#define DUK_HTHREAD_STRING_REVERSE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REVERSE)
++#define DUK_HEAP_STRING_PUSH(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PUSH)
++#define DUK_HTHREAD_STRING_PUSH(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PUSH)
++#define DUK_HEAP_STRING_POP(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_POP)
++#define DUK_HTHREAD_STRING_POP(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_POP)
++#define DUK_HEAP_STRING_JOIN(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JOIN)
++#define DUK_HTHREAD_STRING_JOIN(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JOIN)
++#define DUK_HEAP_STRING_CONCAT(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONCAT)
++#define DUK_HTHREAD_STRING_CONCAT(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONCAT)
++#define DUK_HEAP_STRING_IS_ARRAY(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_ARRAY)
++#define DUK_HTHREAD_STRING_IS_ARRAY(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_ARRAY)
++#define DUK_HEAP_STRING_LC_ARGUMENTS(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_ARGUMENTS)
++#define DUK_HTHREAD_STRING_LC_ARGUMENTS(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_ARGUMENTS)
++#define DUK_HEAP_STRING_CALLER(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CALLER)
++#define DUK_HTHREAD_STRING_CALLER(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CALLER)
++#define DUK_HEAP_STRING_BIND(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BIND)
++#define DUK_HTHREAD_STRING_BIND(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BIND)
++#define DUK_HEAP_STRING_CALL(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CALL)
++#define DUK_HTHREAD_STRING_CALL(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CALL)
++#define DUK_HEAP_STRING_APPLY(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_APPLY)
++#define DUK_HTHREAD_STRING_APPLY(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_APPLY)
++#define DUK_HEAP_STRING_PROPERTY_IS_ENUMERABLE(heap)                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROPERTY_IS_ENUMERABLE)
++#define DUK_HTHREAD_STRING_PROPERTY_IS_ENUMERABLE(thr)                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROPERTY_IS_ENUMERABLE)
++#define DUK_HEAP_STRING_IS_PROTOTYPE_OF(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_PROTOTYPE_OF)
++#define DUK_HTHREAD_STRING_IS_PROTOTYPE_OF(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_PROTOTYPE_OF)
++#define DUK_HEAP_STRING_HAS_OWN_PROPERTY(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_HAS_OWN_PROPERTY)
++#define DUK_HTHREAD_STRING_HAS_OWN_PROPERTY(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_HAS_OWN_PROPERTY)
++#define DUK_HEAP_STRING_VALUE_OF(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VALUE_OF)
++#define DUK_HTHREAD_STRING_VALUE_OF(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VALUE_OF)
++#define DUK_HEAP_STRING_TO_LOCALE_STRING(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_STRING)
++#define DUK_HTHREAD_STRING_TO_LOCALE_STRING(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_STRING)
++#define DUK_HEAP_STRING_TO_STRING(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_STRING)
++#define DUK_HTHREAD_STRING_TO_STRING(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_STRING)
++#define DUK_HEAP_STRING_CONSTRUCTOR(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONSTRUCTOR)
++#define DUK_HTHREAD_STRING_CONSTRUCTOR(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONSTRUCTOR)
++#define DUK_HEAP_STRING_SET(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET)
++#define DUK_HTHREAD_STRING_SET(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET)
++#define DUK_HEAP_STRING_GET(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET)
++#define DUK_HTHREAD_STRING_GET(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET)
++#define DUK_HEAP_STRING_ENUMERABLE(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENUMERABLE)
++#define DUK_HTHREAD_STRING_ENUMERABLE(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENUMERABLE)
++#define DUK_HEAP_STRING_CONFIGURABLE(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONFIGURABLE)
++#define DUK_HTHREAD_STRING_CONFIGURABLE(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONFIGURABLE)
++#define DUK_HEAP_STRING_WRITABLE(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITABLE)
++#define DUK_HTHREAD_STRING_WRITABLE(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITABLE)
++#define DUK_HEAP_STRING_VALUE(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VALUE)
++#define DUK_HTHREAD_STRING_VALUE(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VALUE)
++#define DUK_HEAP_STRING_KEYS(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_KEYS)
++#define DUK_HTHREAD_STRING_KEYS(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_KEYS)
++#define DUK_HEAP_STRING_IS_EXTENSIBLE(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_EXTENSIBLE)
++#define DUK_HTHREAD_STRING_IS_EXTENSIBLE(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_EXTENSIBLE)
++#define DUK_HEAP_STRING_IS_FROZEN(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_FROZEN)
++#define DUK_HTHREAD_STRING_IS_FROZEN(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_FROZEN)
++#define DUK_HEAP_STRING_IS_SEALED(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_SEALED)
++#define DUK_HTHREAD_STRING_IS_SEALED(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_SEALED)
++#define DUK_HEAP_STRING_PREVENT_EXTENSIONS(heap)                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PREVENT_EXTENSIONS)
++#define DUK_HTHREAD_STRING_PREVENT_EXTENSIONS(thr)                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PREVENT_EXTENSIONS)
++#define DUK_HEAP_STRING_FREEZE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FREEZE)
++#define DUK_HTHREAD_STRING_FREEZE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FREEZE)
++#define DUK_HEAP_STRING_SEAL(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SEAL)
++#define DUK_HTHREAD_STRING_SEAL(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SEAL)
++#define DUK_HEAP_STRING_DEFINE_PROPERTIES(heap)                       DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEFINE_PROPERTIES)
++#define DUK_HTHREAD_STRING_DEFINE_PROPERTIES(thr)                     DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEFINE_PROPERTIES)
++#define DUK_HEAP_STRING_DEFINE_PROPERTY(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEFINE_PROPERTY)
++#define DUK_HTHREAD_STRING_DEFINE_PROPERTY(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEFINE_PROPERTY)
++#define DUK_HEAP_STRING_CREATE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CREATE)
++#define DUK_HTHREAD_STRING_CREATE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CREATE)
++#define DUK_HEAP_STRING_GET_OWN_PROPERTY_NAMES(heap)                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_OWN_PROPERTY_NAMES)
++#define DUK_HTHREAD_STRING_GET_OWN_PROPERTY_NAMES(thr)                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_OWN_PROPERTY_NAMES)
++#define DUK_HEAP_STRING_GET_OWN_PROPERTY_DESCRIPTOR(heap)             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_OWN_PROPERTY_DESCRIPTOR)
++#define DUK_HTHREAD_STRING_GET_OWN_PROPERTY_DESCRIPTOR(thr)           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_OWN_PROPERTY_DESCRIPTOR)
++#define DUK_HEAP_STRING_GET_PROTOTYPE_OF(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_PROTOTYPE_OF)
++#define DUK_HTHREAD_STRING_GET_PROTOTYPE_OF(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_PROTOTYPE_OF)
++#define DUK_HEAP_STRING_PROTOTYPE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROTOTYPE)
++#define DUK_HTHREAD_STRING_PROTOTYPE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROTOTYPE)
++#define DUK_HEAP_STRING_LENGTH(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LENGTH)
++#define DUK_HTHREAD_STRING_LENGTH(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LENGTH)
++#define DUK_HEAP_STRING_ALERT(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ALERT)
++#define DUK_HTHREAD_STRING_ALERT(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ALERT)
++#define DUK_HEAP_STRING_PRINT(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PRINT)
++#define DUK_HTHREAD_STRING_PRINT(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PRINT)
++#define DUK_HEAP_STRING_UNESCAPE(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UNESCAPE)
++#define DUK_HTHREAD_STRING_UNESCAPE(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UNESCAPE)
++#define DUK_HEAP_STRING_ESCAPE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ESCAPE)
++#define DUK_HTHREAD_STRING_ESCAPE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ESCAPE)
++#define DUK_HEAP_STRING_ENCODE_URI_COMPONENT(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENCODE_URI_COMPONENT)
++#define DUK_HTHREAD_STRING_ENCODE_URI_COMPONENT(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENCODE_URI_COMPONENT)
++#define DUK_HEAP_STRING_ENCODE_URI(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENCODE_URI)
++#define DUK_HTHREAD_STRING_ENCODE_URI(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENCODE_URI)
++#define DUK_HEAP_STRING_DECODE_URI_COMPONENT(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DECODE_URI_COMPONENT)
++#define DUK_HTHREAD_STRING_DECODE_URI_COMPONENT(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DECODE_URI_COMPONENT)
++#define DUK_HEAP_STRING_DECODE_URI(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DECODE_URI)
++#define DUK_HTHREAD_STRING_DECODE_URI(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DECODE_URI)
++#define DUK_HEAP_STRING_IS_FINITE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_FINITE)
++#define DUK_HTHREAD_STRING_IS_FINITE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_FINITE)
++#define DUK_HEAP_STRING_IS_NAN(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_NAN)
++#define DUK_HTHREAD_STRING_IS_NAN(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_NAN)
++#define DUK_HEAP_STRING_PARSE_FLOAT(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PARSE_FLOAT)
++#define DUK_HTHREAD_STRING_PARSE_FLOAT(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PARSE_FLOAT)
++#define DUK_HEAP_STRING_PARSE_INT(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PARSE_INT)
++#define DUK_HTHREAD_STRING_PARSE_INT(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PARSE_INT)
++#define DUK_HEAP_STRING_EVAL(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EVAL)
++#define DUK_HTHREAD_STRING_EVAL(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EVAL)
++#define DUK_HEAP_STRING_URI_ERROR(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_URI_ERROR)
++#define DUK_HTHREAD_STRING_URI_ERROR(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_URI_ERROR)
++#define DUK_HEAP_STRING_TYPE_ERROR(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TYPE_ERROR)
++#define DUK_HTHREAD_STRING_TYPE_ERROR(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TYPE_ERROR)
++#define DUK_HEAP_STRING_SYNTAX_ERROR(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SYNTAX_ERROR)
++#define DUK_HTHREAD_STRING_SYNTAX_ERROR(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SYNTAX_ERROR)
++#define DUK_HEAP_STRING_REFERENCE_ERROR(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REFERENCE_ERROR)
++#define DUK_HTHREAD_STRING_REFERENCE_ERROR(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REFERENCE_ERROR)
++#define DUK_HEAP_STRING_RANGE_ERROR(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RANGE_ERROR)
++#define DUK_HTHREAD_STRING_RANGE_ERROR(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RANGE_ERROR)
++#define DUK_HEAP_STRING_EVAL_ERROR(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EVAL_ERROR)
++#define DUK_HTHREAD_STRING_EVAL_ERROR(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EVAL_ERROR)
++#define DUK_HEAP_STRING_BREAK(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BREAK)
++#define DUK_HTHREAD_STRING_BREAK(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BREAK)
++#define DUK_HEAP_STRING_CASE(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CASE)
++#define DUK_HTHREAD_STRING_CASE(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CASE)
++#define DUK_HEAP_STRING_CATCH(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CATCH)
++#define DUK_HTHREAD_STRING_CATCH(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CATCH)
++#define DUK_HEAP_STRING_CONTINUE(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONTINUE)
++#define DUK_HTHREAD_STRING_CONTINUE(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONTINUE)
++#define DUK_HEAP_STRING_DEBUGGER(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEBUGGER)
++#define DUK_HTHREAD_STRING_DEBUGGER(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEBUGGER)
++#define DUK_HEAP_STRING_DEFAULT(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEFAULT)
++#define DUK_HTHREAD_STRING_DEFAULT(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEFAULT)
++#define DUK_HEAP_STRING_DELETE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DELETE)
++#define DUK_HTHREAD_STRING_DELETE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DELETE)
++#define DUK_HEAP_STRING_DO(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DO)
++#define DUK_HTHREAD_STRING_DO(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DO)
++#define DUK_HEAP_STRING_ELSE(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ELSE)
++#define DUK_HTHREAD_STRING_ELSE(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ELSE)
++#define DUK_HEAP_STRING_FINALLY(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FINALLY)
++#define DUK_HTHREAD_STRING_FINALLY(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FINALLY)
++#define DUK_HEAP_STRING_FOR(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FOR)
++#define DUK_HTHREAD_STRING_FOR(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FOR)
++#define DUK_HEAP_STRING_LC_FUNCTION(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_FUNCTION)
++#define DUK_HTHREAD_STRING_LC_FUNCTION(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_FUNCTION)
++#define DUK_HEAP_STRING_IF(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IF)
++#define DUK_HTHREAD_STRING_IF(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IF)
++#define DUK_HEAP_STRING_IN(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IN)
++#define DUK_HTHREAD_STRING_IN(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IN)
++#define DUK_HEAP_STRING_INSTANCEOF(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INSTANCEOF)
++#define DUK_HTHREAD_STRING_INSTANCEOF(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INSTANCEOF)
++#define DUK_HEAP_STRING_NEW(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NEW)
++#define DUK_HTHREAD_STRING_NEW(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NEW)
++#define DUK_HEAP_STRING_RETURN(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RETURN)
++#define DUK_HTHREAD_STRING_RETURN(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RETURN)
++#define DUK_HEAP_STRING_SWITCH(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SWITCH)
++#define DUK_HTHREAD_STRING_SWITCH(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SWITCH)
++#define DUK_HEAP_STRING_THIS(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_THIS)
++#define DUK_HTHREAD_STRING_THIS(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_THIS)
++#define DUK_HEAP_STRING_THROW(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_THROW)
++#define DUK_HTHREAD_STRING_THROW(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_THROW)
++#define DUK_HEAP_STRING_TRY(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TRY)
++#define DUK_HTHREAD_STRING_TRY(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TRY)
++#define DUK_HEAP_STRING_TYPEOF(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TYPEOF)
++#define DUK_HTHREAD_STRING_TYPEOF(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TYPEOF)
++#define DUK_HEAP_STRING_VAR(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VAR)
++#define DUK_HTHREAD_STRING_VAR(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VAR)
++#define DUK_HEAP_STRING_VOID(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VOID)
++#define DUK_HTHREAD_STRING_VOID(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VOID)
++#define DUK_HEAP_STRING_WHILE(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WHILE)
++#define DUK_HTHREAD_STRING_WHILE(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WHILE)
++#define DUK_HEAP_STRING_WITH(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WITH)
++#define DUK_HTHREAD_STRING_WITH(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WITH)
++#define DUK_HEAP_STRING_CLASS(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CLASS)
++#define DUK_HTHREAD_STRING_CLASS(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CLASS)
++#define DUK_HEAP_STRING_CONST(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONST)
++#define DUK_HTHREAD_STRING_CONST(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONST)
++#define DUK_HEAP_STRING_ENUM(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENUM)
++#define DUK_HTHREAD_STRING_ENUM(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENUM)
++#define DUK_HEAP_STRING_EXPORT(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXPORT)
++#define DUK_HTHREAD_STRING_EXPORT(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXPORT)
++#define DUK_HEAP_STRING_EXTENDS(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXTENDS)
++#define DUK_HTHREAD_STRING_EXTENDS(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXTENDS)
++#define DUK_HEAP_STRING_IMPORT(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IMPORT)
++#define DUK_HTHREAD_STRING_IMPORT(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IMPORT)
++#define DUK_HEAP_STRING_SUPER(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SUPER)
++#define DUK_HTHREAD_STRING_SUPER(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SUPER)
++#define DUK_HEAP_STRING_LC_NULL(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_NULL)
++#define DUK_HTHREAD_STRING_LC_NULL(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_NULL)
++#define DUK_HEAP_STRING_TRUE(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TRUE)
++#define DUK_HTHREAD_STRING_TRUE(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TRUE)
++#define DUK_HEAP_STRING_FALSE(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FALSE)
++#define DUK_HTHREAD_STRING_FALSE(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FALSE)
++#define DUK_HEAP_STRING_IMPLEMENTS(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IMPLEMENTS)
++#define DUK_HTHREAD_STRING_IMPLEMENTS(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IMPLEMENTS)
++#define DUK_HEAP_STRING_INTERFACE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INTERFACE)
++#define DUK_HTHREAD_STRING_INTERFACE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INTERFACE)
++#define DUK_HEAP_STRING_LET(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LET)
++#define DUK_HTHREAD_STRING_LET(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LET)
++#define DUK_HEAP_STRING_PACKAGE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PACKAGE)
++#define DUK_HTHREAD_STRING_PACKAGE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PACKAGE)
++#define DUK_HEAP_STRING_PRIVATE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PRIVATE)
++#define DUK_HTHREAD_STRING_PRIVATE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PRIVATE)
++#define DUK_HEAP_STRING_PROTECTED(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROTECTED)
++#define DUK_HTHREAD_STRING_PROTECTED(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROTECTED)
++#define DUK_HEAP_STRING_PUBLIC(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PUBLIC)
++#define DUK_HTHREAD_STRING_PUBLIC(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PUBLIC)
++#define DUK_HEAP_STRING_STATIC(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_STATIC)
++#define DUK_HTHREAD_STRING_STATIC(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_STATIC)
++#define DUK_HEAP_STRING_YIELD(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_YIELD)
++#define DUK_HTHREAD_STRING_YIELD(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_YIELD)
++
++#define DUK_HEAP_NUM_STRINGS                                          336
++
++#define DUK_STRIDX_START_RESERVED                                     291
++#define DUK_STRIDX_START_STRICT_RESERVED                              327
++#define DUK_STRIDX_END_RESERVED                                       336                            /* exclusive endpoint */
++
++#if !defined(DUK_SINGLE_FILE)
++DUK_INTERNAL_DECL const duk_c_function duk_bi_native_functions[128];
++DUK_INTERNAL_DECL const duk_uint8_t duk_builtins_data[1341];
++#ifdef DUK_USE_BUILTIN_INITJS
++DUK_INTERNAL_DECL const duk_uint8_t duk_initjs_data[187];
++#endif  /* DUK_USE_BUILTIN_INITJS */
++#endif  /* !DUK_SINGLE_FILE */
++
++#define DUK_BUILTINS_DATA_LENGTH                                      1341
++#ifdef DUK_USE_BUILTIN_INITJS
++#define DUK_BUILTIN_INITJS_DATA_LENGTH                                187
++#endif  /* DUK_USE_BUILTIN_INITJS */
++
++#define DUK_BIDX_GLOBAL                                               0
++#define DUK_BIDX_GLOBAL_ENV                                           1
++#define DUK_BIDX_OBJECT_CONSTRUCTOR                                   2
++#define DUK_BIDX_OBJECT_PROTOTYPE                                     3
++#define DUK_BIDX_FUNCTION_CONSTRUCTOR                                 4
++#define DUK_BIDX_FUNCTION_PROTOTYPE                                   5
++#define DUK_BIDX_ARRAY_CONSTRUCTOR                                    6
++#define DUK_BIDX_ARRAY_PROTOTYPE                                      7
++#define DUK_BIDX_STRING_CONSTRUCTOR                                   8
++#define DUK_BIDX_STRING_PROTOTYPE                                     9
++#define DUK_BIDX_BOOLEAN_CONSTRUCTOR                                  10
++#define DUK_BIDX_BOOLEAN_PROTOTYPE                                    11
++#define DUK_BIDX_NUMBER_CONSTRUCTOR                                   12
++#define DUK_BIDX_NUMBER_PROTOTYPE                                     13
++#define DUK_BIDX_DATE_CONSTRUCTOR                                     14
++#define DUK_BIDX_DATE_PROTOTYPE                                       15
++#define DUK_BIDX_REGEXP_CONSTRUCTOR                                   16
++#define DUK_BIDX_REGEXP_PROTOTYPE                                     17
++#define DUK_BIDX_ERROR_CONSTRUCTOR                                    18
++#define DUK_BIDX_ERROR_PROTOTYPE                                      19
++#define DUK_BIDX_EVAL_ERROR_CONSTRUCTOR                               20
++#define DUK_BIDX_EVAL_ERROR_PROTOTYPE                                 21
++#define DUK_BIDX_RANGE_ERROR_CONSTRUCTOR                              22
++#define DUK_BIDX_RANGE_ERROR_PROTOTYPE                                23
++#define DUK_BIDX_REFERENCE_ERROR_CONSTRUCTOR                          24
++#define DUK_BIDX_REFERENCE_ERROR_PROTOTYPE                            25
++#define DUK_BIDX_SYNTAX_ERROR_CONSTRUCTOR                             26
++#define DUK_BIDX_SYNTAX_ERROR_PROTOTYPE                               27
++#define DUK_BIDX_TYPE_ERROR_CONSTRUCTOR                               28
++#define DUK_BIDX_TYPE_ERROR_PROTOTYPE                                 29
++#define DUK_BIDX_URI_ERROR_CONSTRUCTOR                                30
++#define DUK_BIDX_URI_ERROR_PROTOTYPE                                  31
++#define DUK_BIDX_MATH                                                 32
++#define DUK_BIDX_JSON                                                 33
++#define DUK_BIDX_TYPE_ERROR_THROWER                                   34
++#define DUK_BIDX_PROXY_CONSTRUCTOR                                    35
++#define DUK_BIDX_DUKTAPE                                              36
++#define DUK_BIDX_THREAD_CONSTRUCTOR                                   37
++#define DUK_BIDX_THREAD_PROTOTYPE                                     38
++#define DUK_BIDX_BUFFER_CONSTRUCTOR                                   39
++#define DUK_BIDX_BUFFER_PROTOTYPE                                     40
++#define DUK_BIDX_POINTER_CONSTRUCTOR                                  41
++#define DUK_BIDX_POINTER_PROTOTYPE                                    42
++#define DUK_BIDX_LOGGER_CONSTRUCTOR                                   43
++#define DUK_BIDX_LOGGER_PROTOTYPE                                     44
++#define DUK_BIDX_DOUBLE_ERROR                                         45
++
++#define DUK_NUM_BUILTINS                                              46
++
++#elif defined(DUK_USE_DOUBLE_BE)
++#if !defined(DUK_SINGLE_FILE)
++DUK_INTERNAL_DECL const duk_uint8_t duk_strings_data[1943];
++#endif  /* !DUK_SINGLE_FILE */
++
++#define DUK_STRDATA_DATA_LENGTH                                       1943
++#define DUK_STRDATA_MAX_STRLEN                                        24
++
++#define DUK_STRIDX_UC_LOGGER                                          0                              /* 'Logger' */
++#define DUK_STRIDX_UC_THREAD                                          1                              /* 'Thread' */
++#define DUK_STRIDX_UC_POINTER                                         2                              /* 'Pointer' */
++#define DUK_STRIDX_UC_BUFFER                                          3                              /* 'Buffer' */
++#define DUK_STRIDX_DEC_ENV                                            4                              /* 'DecEnv' */
++#define DUK_STRIDX_OBJ_ENV                                            5                              /* 'ObjEnv' */
++#define DUK_STRIDX_EMPTY_STRING                                       6                              /* '' */
++#define DUK_STRIDX_GLOBAL                                             7                              /* 'global' */
++#define DUK_STRIDX_UC_ARGUMENTS                                       8                              /* 'Arguments' */
++#define DUK_STRIDX_JSON                                               9                              /* 'JSON' */
++#define DUK_STRIDX_MATH                                               10                             /* 'Math' */
++#define DUK_STRIDX_UC_ERROR                                           11                             /* 'Error' */
++#define DUK_STRIDX_REG_EXP                                            12                             /* 'RegExp' */
++#define DUK_STRIDX_DATE                                               13                             /* 'Date' */
++#define DUK_STRIDX_UC_NUMBER                                          14                             /* 'Number' */
++#define DUK_STRIDX_UC_BOOLEAN                                         15                             /* 'Boolean' */
++#define DUK_STRIDX_UC_STRING                                          16                             /* 'String' */
++#define DUK_STRIDX_ARRAY                                              17                             /* 'Array' */
++#define DUK_STRIDX_UC_FUNCTION                                        18                             /* 'Function' */
++#define DUK_STRIDX_UC_OBJECT                                          19                             /* 'Object' */
++#define DUK_STRIDX_UC_NULL                                            20                             /* 'Null' */
++#define DUK_STRIDX_UC_UNDEFINED                                       21                             /* 'Undefined' */
++#define DUK_STRIDX_JSON_EXT_FUNCTION2                                 22                             /* '{_func:true}' */
++#define DUK_STRIDX_JSON_EXT_FUNCTION1                                 23                             /* '{"_func":true}' */
++#define DUK_STRIDX_JSON_EXT_NEGINF                                    24                             /* '{"_ninf":true}' */
++#define DUK_STRIDX_JSON_EXT_POSINF                                    25                             /* '{"_inf":true}' */
++#define DUK_STRIDX_JSON_EXT_NAN                                       26                             /* '{"_nan":true}' */
++#define DUK_STRIDX_JSON_EXT_UNDEFINED                                 27                             /* '{"_undef":true}' */
++#define DUK_STRIDX_TO_LOG_STRING                                      28                             /* 'toLogString' */
++#define DUK_STRIDX_CLOG                                               29                             /* 'clog' */
++#define DUK_STRIDX_LC_L                                               30                             /* 'l' */
++#define DUK_STRIDX_LC_N                                               31                             /* 'n' */
++#define DUK_STRIDX_LC_FATAL                                           32                             /* 'fatal' */
++#define DUK_STRIDX_LC_ERROR                                           33                             /* 'error' */
++#define DUK_STRIDX_LC_WARN                                            34                             /* 'warn' */
++#define DUK_STRIDX_LC_DEBUG                                           35                             /* 'debug' */
++#define DUK_STRIDX_LC_TRACE                                           36                             /* 'trace' */
++#define DUK_STRIDX_RAW                                                37                             /* 'raw' */
++#define DUK_STRIDX_FMT                                                38                             /* 'fmt' */
++#define DUK_STRIDX_CURRENT                                            39                             /* 'current' */
++#define DUK_STRIDX_RESUME                                             40                             /* 'resume' */
++#define DUK_STRIDX_COMPACT                                            41                             /* 'compact' */
++#define DUK_STRIDX_JC                                                 42                             /* 'jc' */
++#define DUK_STRIDX_JX                                                 43                             /* 'jx' */
++#define DUK_STRIDX_BASE64                                             44                             /* 'base64' */
++#define DUK_STRIDX_HEX                                                45                             /* 'hex' */
++#define DUK_STRIDX_DEC                                                46                             /* 'dec' */
++#define DUK_STRIDX_ENC                                                47                             /* 'enc' */
++#define DUK_STRIDX_FIN                                                48                             /* 'fin' */
++#define DUK_STRIDX_GC                                                 49                             /* 'gc' */
++#define DUK_STRIDX_ACT                                                50                             /* 'act' */
++#define DUK_STRIDX_LC_INFO                                            51                             /* 'info' */
++#define DUK_STRIDX_VERSION                                            52                             /* 'version' */
++#define DUK_STRIDX_ENV                                                53                             /* 'env' */
++#define DUK_STRIDX_MOD_LOADED                                         54                             /* 'modLoaded' */
++#define DUK_STRIDX_MOD_SEARCH                                         55                             /* 'modSearch' */
++#define DUK_STRIDX_ERR_THROW                                          56                             /* 'errThrow' */
++#define DUK_STRIDX_ERR_CREATE                                         57                             /* 'errCreate' */
++#define DUK_STRIDX_COMPILE                                            58                             /* 'compile' */
++#define DUK_STRIDX_INT_REGBASE                                        59                             /* '\x00Regbase' */
++#define DUK_STRIDX_INT_THREAD                                         60                             /* '\x00Thread' */
++#define DUK_STRIDX_INT_HANDLER                                        61                             /* '\x00Handler' */
++#define DUK_STRIDX_INT_FINALIZER                                      62                             /* '\x00Finalizer' */
++#define DUK_STRIDX_INT_CALLEE                                         63                             /* '\x00Callee' */
++#define DUK_STRIDX_INT_MAP                                            64                             /* '\x00Map' */
++#define DUK_STRIDX_INT_ARGS                                           65                             /* '\x00Args' */
++#define DUK_STRIDX_INT_THIS                                           66                             /* '\x00This' */
++#define DUK_STRIDX_INT_PC2LINE                                        67                             /* '\x00Pc2line' */
++#define DUK_STRIDX_INT_SOURCE                                         68                             /* '\x00Source' */
++#define DUK_STRIDX_INT_VARENV                                         69                             /* '\x00Varenv' */
++#define DUK_STRIDX_INT_LEXENV                                         70                             /* '\x00Lexenv' */
++#define DUK_STRIDX_INT_VARMAP                                         71                             /* '\x00Varmap' */
++#define DUK_STRIDX_INT_FORMALS                                        72                             /* '\x00Formals' */
++#define DUK_STRIDX_INT_BYTECODE                                       73                             /* '\x00Bytecode' */
++#define DUK_STRIDX_INT_NEXT                                           74                             /* '\x00Next' */
++#define DUK_STRIDX_INT_TARGET                                         75                             /* '\x00Target' */
++#define DUK_STRIDX_INT_VALUE                                          76                             /* '\x00Value' */
++#define DUK_STRIDX_LC_POINTER                                         77                             /* 'pointer' */
++#define DUK_STRIDX_LC_BUFFER                                          78                             /* 'buffer' */
++#define DUK_STRIDX_INT_TRACEDATA                                      79                             /* '\x00Tracedata' */
++#define DUK_STRIDX_LINE_NUMBER                                        80                             /* 'lineNumber' */
++#define DUK_STRIDX_FILE_NAME                                          81                             /* 'fileName' */
++#define DUK_STRIDX_PC                                                 82                             /* 'pc' */
++#define DUK_STRIDX_STACK                                              83                             /* 'stack' */
++#define DUK_STRIDX_THROW_TYPE_ERROR                                   84                             /* 'ThrowTypeError' */
++#define DUK_STRIDX_DUKTAPE                                            85                             /* 'Duktape' */
++#define DUK_STRIDX_ID                                                 86                             /* 'id' */
++#define DUK_STRIDX_REQUIRE                                            87                             /* 'require' */
++#define DUK_STRIDX___PROTO__                                          88                             /* '__proto__' */
++#define DUK_STRIDX_SET_PROTOTYPE_OF                                   89                             /* 'setPrototypeOf' */
++#define DUK_STRIDX_OWN_KEYS                                           90                             /* 'ownKeys' */
++#define DUK_STRIDX_ENUMERATE                                          91                             /* 'enumerate' */
++#define DUK_STRIDX_DELETE_PROPERTY                                    92                             /* 'deleteProperty' */
++#define DUK_STRIDX_HAS                                                93                             /* 'has' */
++#define DUK_STRIDX_PROXY                                              94                             /* 'Proxy' */
++#define DUK_STRIDX_CALLEE                                             95                             /* 'callee' */
++#define DUK_STRIDX_INVALID_DATE                                       96                             /* 'Invalid Date' */
++#define DUK_STRIDX_BRACKETED_ELLIPSIS                                 97                             /* '[...]' */
++#define DUK_STRIDX_NEWLINE_TAB                                        98                             /* '\n\t' */
++#define DUK_STRIDX_SPACE                                              99                             /* ' ' */
++#define DUK_STRIDX_COMMA                                              100                            /* ',' */
++#define DUK_STRIDX_MINUS_ZERO                                         101                            /* '-0' */
++#define DUK_STRIDX_PLUS_ZERO                                          102                            /* '+0' */
++#define DUK_STRIDX_ZERO                                               103                            /* '0' */
++#define DUK_STRIDX_MINUS_INFINITY                                     104                            /* '-Infinity' */
++#define DUK_STRIDX_PLUS_INFINITY                                      105                            /* '+Infinity' */
++#define DUK_STRIDX_INFINITY                                           106                            /* 'Infinity' */
++#define DUK_STRIDX_LC_OBJECT                                          107                            /* 'object' */
++#define DUK_STRIDX_LC_STRING                                          108                            /* 'string' */
++#define DUK_STRIDX_LC_NUMBER                                          109                            /* 'number' */
++#define DUK_STRIDX_LC_BOOLEAN                                         110                            /* 'boolean' */
++#define DUK_STRIDX_LC_UNDEFINED                                       111                            /* 'undefined' */
++#define DUK_STRIDX_STRINGIFY                                          112                            /* 'stringify' */
++#define DUK_STRIDX_TAN                                                113                            /* 'tan' */
++#define DUK_STRIDX_SQRT                                               114                            /* 'sqrt' */
++#define DUK_STRIDX_SIN                                                115                            /* 'sin' */
++#define DUK_STRIDX_ROUND                                              116                            /* 'round' */
++#define DUK_STRIDX_RANDOM                                             117                            /* 'random' */
++#define DUK_STRIDX_POW                                                118                            /* 'pow' */
++#define DUK_STRIDX_MIN                                                119                            /* 'min' */
++#define DUK_STRIDX_MAX                                                120                            /* 'max' */
++#define DUK_STRIDX_LOG                                                121                            /* 'log' */
++#define DUK_STRIDX_FLOOR                                              122                            /* 'floor' */
++#define DUK_STRIDX_EXP                                                123                            /* 'exp' */
++#define DUK_STRIDX_COS                                                124                            /* 'cos' */
++#define DUK_STRIDX_CEIL                                               125                            /* 'ceil' */
++#define DUK_STRIDX_ATAN2                                              126                            /* 'atan2' */
++#define DUK_STRIDX_ATAN                                               127                            /* 'atan' */
++#define DUK_STRIDX_ASIN                                               128                            /* 'asin' */
++#define DUK_STRIDX_ACOS                                               129                            /* 'acos' */
++#define DUK_STRIDX_ABS                                                130                            /* 'abs' */
++#define DUK_STRIDX_SQRT2                                              131                            /* 'SQRT2' */
++#define DUK_STRIDX_SQRT1_2                                            132                            /* 'SQRT1_2' */
++#define DUK_STRIDX_PI                                                 133                            /* 'PI' */
++#define DUK_STRIDX_LOG10E                                             134                            /* 'LOG10E' */
++#define DUK_STRIDX_LOG2E                                              135                            /* 'LOG2E' */
++#define DUK_STRIDX_LN2                                                136                            /* 'LN2' */
++#define DUK_STRIDX_LN10                                               137                            /* 'LN10' */
++#define DUK_STRIDX_E                                                  138                            /* 'E' */
++#define DUK_STRIDX_MESSAGE                                            139                            /* 'message' */
++#define DUK_STRIDX_NAME                                               140                            /* 'name' */
++#define DUK_STRIDX_INPUT                                              141                            /* 'input' */
++#define DUK_STRIDX_INDEX                                              142                            /* 'index' */
++#define DUK_STRIDX_ESCAPED_EMPTY_REGEXP                               143                            /* '(?:)' */
++#define DUK_STRIDX_LAST_INDEX                                         144                            /* 'lastIndex' */
++#define DUK_STRIDX_MULTILINE                                          145                            /* 'multiline' */
++#define DUK_STRIDX_IGNORE_CASE                                        146                            /* 'ignoreCase' */
++#define DUK_STRIDX_SOURCE                                             147                            /* 'source' */
++#define DUK_STRIDX_TEST                                               148                            /* 'test' */
++#define DUK_STRIDX_EXEC                                               149                            /* 'exec' */
++#define DUK_STRIDX_TO_GMT_STRING                                      150                            /* 'toGMTString' */
++#define DUK_STRIDX_SET_YEAR                                           151                            /* 'setYear' */
++#define DUK_STRIDX_GET_YEAR                                           152                            /* 'getYear' */
++#define DUK_STRIDX_TO_JSON                                            153                            /* 'toJSON' */
++#define DUK_STRIDX_TO_ISO_STRING                                      154                            /* 'toISOString' */
++#define DUK_STRIDX_TO_UTC_STRING                                      155                            /* 'toUTCString' */
++#define DUK_STRIDX_SET_UTC_FULL_YEAR                                  156                            /* 'setUTCFullYear' */
++#define DUK_STRIDX_SET_FULL_YEAR                                      157                            /* 'setFullYear' */
++#define DUK_STRIDX_SET_UTC_MONTH                                      158                            /* 'setUTCMonth' */
++#define DUK_STRIDX_SET_MONTH                                          159                            /* 'setMonth' */
++#define DUK_STRIDX_SET_UTC_DATE                                       160                            /* 'setUTCDate' */
++#define DUK_STRIDX_SET_DATE                                           161                            /* 'setDate' */
++#define DUK_STRIDX_SET_UTC_HOURS                                      162                            /* 'setUTCHours' */
++#define DUK_STRIDX_SET_HOURS                                          163                            /* 'setHours' */
++#define DUK_STRIDX_SET_UTC_MINUTES                                    164                            /* 'setUTCMinutes' */
++#define DUK_STRIDX_SET_MINUTES                                        165                            /* 'setMinutes' */
++#define DUK_STRIDX_SET_UTC_SECONDS                                    166                            /* 'setUTCSeconds' */
++#define DUK_STRIDX_SET_SECONDS                                        167                            /* 'setSeconds' */
++#define DUK_STRIDX_SET_UTC_MILLISECONDS                               168                            /* 'setUTCMilliseconds' */
++#define DUK_STRIDX_SET_MILLISECONDS                                   169                            /* 'setMilliseconds' */
++#define DUK_STRIDX_SET_TIME                                           170                            /* 'setTime' */
++#define DUK_STRIDX_GET_TIMEZONE_OFFSET                                171                            /* 'getTimezoneOffset' */
++#define DUK_STRIDX_GET_UTC_MILLISECONDS                               172                            /* 'getUTCMilliseconds' */
++#define DUK_STRIDX_GET_MILLISECONDS                                   173                            /* 'getMilliseconds' */
++#define DUK_STRIDX_GET_UTC_SECONDS                                    174                            /* 'getUTCSeconds' */
++#define DUK_STRIDX_GET_SECONDS                                        175                            /* 'getSeconds' */
++#define DUK_STRIDX_GET_UTC_MINUTES                                    176                            /* 'getUTCMinutes' */
++#define DUK_STRIDX_GET_MINUTES                                        177                            /* 'getMinutes' */
++#define DUK_STRIDX_GET_UTC_HOURS                                      178                            /* 'getUTCHours' */
++#define DUK_STRIDX_GET_HOURS                                          179                            /* 'getHours' */
++#define DUK_STRIDX_GET_UTC_DAY                                        180                            /* 'getUTCDay' */
++#define DUK_STRIDX_GET_DAY                                            181                            /* 'getDay' */
++#define DUK_STRIDX_GET_UTC_DATE                                       182                            /* 'getUTCDate' */
++#define DUK_STRIDX_GET_DATE                                           183                            /* 'getDate' */
++#define DUK_STRIDX_GET_UTC_MONTH                                      184                            /* 'getUTCMonth' */
++#define DUK_STRIDX_GET_MONTH                                          185                            /* 'getMonth' */
++#define DUK_STRIDX_GET_UTC_FULL_YEAR                                  186                            /* 'getUTCFullYear' */
++#define DUK_STRIDX_GET_FULL_YEAR                                      187                            /* 'getFullYear' */
++#define DUK_STRIDX_GET_TIME                                           188                            /* 'getTime' */
++#define DUK_STRIDX_TO_LOCALE_TIME_STRING                              189                            /* 'toLocaleTimeString' */
++#define DUK_STRIDX_TO_LOCALE_DATE_STRING                              190                            /* 'toLocaleDateString' */
++#define DUK_STRIDX_TO_TIME_STRING                                     191                            /* 'toTimeString' */
++#define DUK_STRIDX_TO_DATE_STRING                                     192                            /* 'toDateString' */
++#define DUK_STRIDX_NOW                                                193                            /* 'now' */
++#define DUK_STRIDX_UTC                                                194                            /* 'UTC' */
++#define DUK_STRIDX_PARSE                                              195                            /* 'parse' */
++#define DUK_STRIDX_TO_PRECISION                                       196                            /* 'toPrecision' */
++#define DUK_STRIDX_TO_EXPONENTIAL                                     197                            /* 'toExponential' */
++#define DUK_STRIDX_TO_FIXED                                           198                            /* 'toFixed' */
++#define DUK_STRIDX_POSITIVE_INFINITY                                  199                            /* 'POSITIVE_INFINITY' */
++#define DUK_STRIDX_NEGATIVE_INFINITY                                  200                            /* 'NEGATIVE_INFINITY' */
++#define DUK_STRIDX_NAN                                                201                            /* 'NaN' */
++#define DUK_STRIDX_MIN_VALUE                                          202                            /* 'MIN_VALUE' */
++#define DUK_STRIDX_MAX_VALUE                                          203                            /* 'MAX_VALUE' */
++#define DUK_STRIDX_SUBSTR                                             204                            /* 'substr' */
++#define DUK_STRIDX_TRIM                                               205                            /* 'trim' */
++#define DUK_STRIDX_TO_LOCALE_UPPER_CASE                               206                            /* 'toLocaleUpperCase' */
++#define DUK_STRIDX_TO_UPPER_CASE                                      207                            /* 'toUpperCase' */
++#define DUK_STRIDX_TO_LOCALE_LOWER_CASE                               208                            /* 'toLocaleLowerCase' */
++#define DUK_STRIDX_TO_LOWER_CASE                                      209                            /* 'toLowerCase' */
++#define DUK_STRIDX_SUBSTRING                                          210                            /* 'substring' */
++#define DUK_STRIDX_SPLIT                                              211                            /* 'split' */
++#define DUK_STRIDX_SEARCH                                             212                            /* 'search' */
++#define DUK_STRIDX_REPLACE                                            213                            /* 'replace' */
++#define DUK_STRIDX_MATCH                                              214                            /* 'match' */
++#define DUK_STRIDX_LOCALE_COMPARE                                     215                            /* 'localeCompare' */
++#define DUK_STRIDX_CHAR_CODE_AT                                       216                            /* 'charCodeAt' */
++#define DUK_STRIDX_CHAR_AT                                            217                            /* 'charAt' */
++#define DUK_STRIDX_FROM_CHAR_CODE                                     218                            /* 'fromCharCode' */
++#define DUK_STRIDX_REDUCE_RIGHT                                       219                            /* 'reduceRight' */
++#define DUK_STRIDX_REDUCE                                             220                            /* 'reduce' */
++#define DUK_STRIDX_FILTER                                             221                            /* 'filter' */
++#define DUK_STRIDX_MAP                                                222                            /* 'map' */
++#define DUK_STRIDX_FOR_EACH                                           223                            /* 'forEach' */
++#define DUK_STRIDX_SOME                                               224                            /* 'some' */
++#define DUK_STRIDX_EVERY                                              225                            /* 'every' */
++#define DUK_STRIDX_LAST_INDEX_OF                                      226                            /* 'lastIndexOf' */
++#define DUK_STRIDX_INDEX_OF                                           227                            /* 'indexOf' */
++#define DUK_STRIDX_UNSHIFT                                            228                            /* 'unshift' */
++#define DUK_STRIDX_SPLICE                                             229                            /* 'splice' */
++#define DUK_STRIDX_SORT                                               230                            /* 'sort' */
++#define DUK_STRIDX_SLICE                                              231                            /* 'slice' */
++#define DUK_STRIDX_SHIFT                                              232                            /* 'shift' */
++#define DUK_STRIDX_REVERSE                                            233                            /* 'reverse' */
++#define DUK_STRIDX_PUSH                                               234                            /* 'push' */
++#define DUK_STRIDX_POP                                                235                            /* 'pop' */
++#define DUK_STRIDX_JOIN                                               236                            /* 'join' */
++#define DUK_STRIDX_CONCAT                                             237                            /* 'concat' */
++#define DUK_STRIDX_IS_ARRAY                                           238                            /* 'isArray' */
++#define DUK_STRIDX_LC_ARGUMENTS                                       239                            /* 'arguments' */
++#define DUK_STRIDX_CALLER                                             240                            /* 'caller' */
++#define DUK_STRIDX_BIND                                               241                            /* 'bind' */
++#define DUK_STRIDX_CALL                                               242                            /* 'call' */
++#define DUK_STRIDX_APPLY                                              243                            /* 'apply' */
++#define DUK_STRIDX_PROPERTY_IS_ENUMERABLE                             244                            /* 'propertyIsEnumerable' */
++#define DUK_STRIDX_IS_PROTOTYPE_OF                                    245                            /* 'isPrototypeOf' */
++#define DUK_STRIDX_HAS_OWN_PROPERTY                                   246                            /* 'hasOwnProperty' */
++#define DUK_STRIDX_VALUE_OF                                           247                            /* 'valueOf' */
++#define DUK_STRIDX_TO_LOCALE_STRING                                   248                            /* 'toLocaleString' */
++#define DUK_STRIDX_TO_STRING                                          249                            /* 'toString' */
++#define DUK_STRIDX_CONSTRUCTOR                                        250                            /* 'constructor' */
++#define DUK_STRIDX_SET                                                251                            /* 'set' */
++#define DUK_STRIDX_GET                                                252                            /* 'get' */
++#define DUK_STRIDX_ENUMERABLE                                         253                            /* 'enumerable' */
++#define DUK_STRIDX_CONFIGURABLE                                       254                            /* 'configurable' */
++#define DUK_STRIDX_WRITABLE                                           255                            /* 'writable' */
++#define DUK_STRIDX_VALUE                                              256                            /* 'value' */
++#define DUK_STRIDX_KEYS                                               257                            /* 'keys' */
++#define DUK_STRIDX_IS_EXTENSIBLE                                      258                            /* 'isExtensible' */
++#define DUK_STRIDX_IS_FROZEN                                          259                            /* 'isFrozen' */
++#define DUK_STRIDX_IS_SEALED                                          260                            /* 'isSealed' */
++#define DUK_STRIDX_PREVENT_EXTENSIONS                                 261                            /* 'preventExtensions' */
++#define DUK_STRIDX_FREEZE                                             262                            /* 'freeze' */
++#define DUK_STRIDX_SEAL                                               263                            /* 'seal' */
++#define DUK_STRIDX_DEFINE_PROPERTIES                                  264                            /* 'defineProperties' */
++#define DUK_STRIDX_DEFINE_PROPERTY                                    265                            /* 'defineProperty' */
++#define DUK_STRIDX_CREATE                                             266                            /* 'create' */
++#define DUK_STRIDX_GET_OWN_PROPERTY_NAMES                             267                            /* 'getOwnPropertyNames' */
++#define DUK_STRIDX_GET_OWN_PROPERTY_DESCRIPTOR                        268                            /* 'getOwnPropertyDescriptor' */
++#define DUK_STRIDX_GET_PROTOTYPE_OF                                   269                            /* 'getPrototypeOf' */
++#define DUK_STRIDX_PROTOTYPE                                          270                            /* 'prototype' */
++#define DUK_STRIDX_LENGTH                                             271                            /* 'length' */
++#define DUK_STRIDX_ALERT                                              272                            /* 'alert' */
++#define DUK_STRIDX_PRINT                                              273                            /* 'print' */
++#define DUK_STRIDX_UNESCAPE                                           274                            /* 'unescape' */
++#define DUK_STRIDX_ESCAPE                                             275                            /* 'escape' */
++#define DUK_STRIDX_ENCODE_URI_COMPONENT                               276                            /* 'encodeURIComponent' */
++#define DUK_STRIDX_ENCODE_URI                                         277                            /* 'encodeURI' */
++#define DUK_STRIDX_DECODE_URI_COMPONENT                               278                            /* 'decodeURIComponent' */
++#define DUK_STRIDX_DECODE_URI                                         279                            /* 'decodeURI' */
++#define DUK_STRIDX_IS_FINITE                                          280                            /* 'isFinite' */
++#define DUK_STRIDX_IS_NAN                                             281                            /* 'isNaN' */
++#define DUK_STRIDX_PARSE_FLOAT                                        282                            /* 'parseFloat' */
++#define DUK_STRIDX_PARSE_INT                                          283                            /* 'parseInt' */
++#define DUK_STRIDX_EVAL                                               284                            /* 'eval' */
++#define DUK_STRIDX_URI_ERROR                                          285                            /* 'URIError' */
++#define DUK_STRIDX_TYPE_ERROR                                         286                            /* 'TypeError' */
++#define DUK_STRIDX_SYNTAX_ERROR                                       287                            /* 'SyntaxError' */
++#define DUK_STRIDX_REFERENCE_ERROR                                    288                            /* 'ReferenceError' */
++#define DUK_STRIDX_RANGE_ERROR                                        289                            /* 'RangeError' */
++#define DUK_STRIDX_EVAL_ERROR                                         290                            /* 'EvalError' */
++#define DUK_STRIDX_BREAK                                              291                            /* 'break' */
++#define DUK_STRIDX_CASE                                               292                            /* 'case' */
++#define DUK_STRIDX_CATCH                                              293                            /* 'catch' */
++#define DUK_STRIDX_CONTINUE                                           294                            /* 'continue' */
++#define DUK_STRIDX_DEBUGGER                                           295                            /* 'debugger' */
++#define DUK_STRIDX_DEFAULT                                            296                            /* 'default' */
++#define DUK_STRIDX_DELETE                                             297                            /* 'delete' */
++#define DUK_STRIDX_DO                                                 298                            /* 'do' */
++#define DUK_STRIDX_ELSE                                               299                            /* 'else' */
++#define DUK_STRIDX_FINALLY                                            300                            /* 'finally' */
++#define DUK_STRIDX_FOR                                                301                            /* 'for' */
++#define DUK_STRIDX_LC_FUNCTION                                        302                            /* 'function' */
++#define DUK_STRIDX_IF                                                 303                            /* 'if' */
++#define DUK_STRIDX_IN                                                 304                            /* 'in' */
++#define DUK_STRIDX_INSTANCEOF                                         305                            /* 'instanceof' */
++#define DUK_STRIDX_NEW                                                306                            /* 'new' */
++#define DUK_STRIDX_RETURN                                             307                            /* 'return' */
++#define DUK_STRIDX_SWITCH                                             308                            /* 'switch' */
++#define DUK_STRIDX_THIS                                               309                            /* 'this' */
++#define DUK_STRIDX_THROW                                              310                            /* 'throw' */
++#define DUK_STRIDX_TRY                                                311                            /* 'try' */
++#define DUK_STRIDX_TYPEOF                                             312                            /* 'typeof' */
++#define DUK_STRIDX_VAR                                                313                            /* 'var' */
++#define DUK_STRIDX_VOID                                               314                            /* 'void' */
++#define DUK_STRIDX_WHILE                                              315                            /* 'while' */
++#define DUK_STRIDX_WITH                                               316                            /* 'with' */
++#define DUK_STRIDX_CLASS                                              317                            /* 'class' */
++#define DUK_STRIDX_CONST                                              318                            /* 'const' */
++#define DUK_STRIDX_ENUM                                               319                            /* 'enum' */
++#define DUK_STRIDX_EXPORT                                             320                            /* 'export' */
++#define DUK_STRIDX_EXTENDS                                            321                            /* 'extends' */
++#define DUK_STRIDX_IMPORT                                             322                            /* 'import' */
++#define DUK_STRIDX_SUPER                                              323                            /* 'super' */
++#define DUK_STRIDX_LC_NULL                                            324                            /* 'null' */
++#define DUK_STRIDX_TRUE                                               325                            /* 'true' */
++#define DUK_STRIDX_FALSE                                              326                            /* 'false' */
++#define DUK_STRIDX_IMPLEMENTS                                         327                            /* 'implements' */
++#define DUK_STRIDX_INTERFACE                                          328                            /* 'interface' */
++#define DUK_STRIDX_LET                                                329                            /* 'let' */
++#define DUK_STRIDX_PACKAGE                                            330                            /* 'package' */
++#define DUK_STRIDX_PRIVATE                                            331                            /* 'private' */
++#define DUK_STRIDX_PROTECTED                                          332                            /* 'protected' */
++#define DUK_STRIDX_PUBLIC                                             333                            /* 'public' */
++#define DUK_STRIDX_STATIC                                             334                            /* 'static' */
++#define DUK_STRIDX_YIELD                                              335                            /* 'yield' */
++
++#define DUK_HEAP_STRING_UC_LOGGER(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_LOGGER)
++#define DUK_HTHREAD_STRING_UC_LOGGER(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_LOGGER)
++#define DUK_HEAP_STRING_UC_THREAD(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_THREAD)
++#define DUK_HTHREAD_STRING_UC_THREAD(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_THREAD)
++#define DUK_HEAP_STRING_UC_POINTER(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_POINTER)
++#define DUK_HTHREAD_STRING_UC_POINTER(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_POINTER)
++#define DUK_HEAP_STRING_UC_BUFFER(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_BUFFER)
++#define DUK_HTHREAD_STRING_UC_BUFFER(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_BUFFER)
++#define DUK_HEAP_STRING_DEC_ENV(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEC_ENV)
++#define DUK_HTHREAD_STRING_DEC_ENV(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEC_ENV)
++#define DUK_HEAP_STRING_OBJ_ENV(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_OBJ_ENV)
++#define DUK_HTHREAD_STRING_OBJ_ENV(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_OBJ_ENV)
++#define DUK_HEAP_STRING_EMPTY_STRING(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EMPTY_STRING)
++#define DUK_HTHREAD_STRING_EMPTY_STRING(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EMPTY_STRING)
++#define DUK_HEAP_STRING_GLOBAL(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GLOBAL)
++#define DUK_HTHREAD_STRING_GLOBAL(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GLOBAL)
++#define DUK_HEAP_STRING_UC_ARGUMENTS(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_ARGUMENTS)
++#define DUK_HTHREAD_STRING_UC_ARGUMENTS(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_ARGUMENTS)
++#define DUK_HEAP_STRING_JSON(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON)
++#define DUK_HTHREAD_STRING_JSON(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON)
++#define DUK_HEAP_STRING_MATH(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MATH)
++#define DUK_HTHREAD_STRING_MATH(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MATH)
++#define DUK_HEAP_STRING_UC_ERROR(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_ERROR)
++#define DUK_HTHREAD_STRING_UC_ERROR(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_ERROR)
++#define DUK_HEAP_STRING_REG_EXP(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REG_EXP)
++#define DUK_HTHREAD_STRING_REG_EXP(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REG_EXP)
++#define DUK_HEAP_STRING_DATE(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DATE)
++#define DUK_HTHREAD_STRING_DATE(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DATE)
++#define DUK_HEAP_STRING_UC_NUMBER(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_NUMBER)
++#define DUK_HTHREAD_STRING_UC_NUMBER(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_NUMBER)
++#define DUK_HEAP_STRING_UC_BOOLEAN(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_BOOLEAN)
++#define DUK_HTHREAD_STRING_UC_BOOLEAN(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_BOOLEAN)
++#define DUK_HEAP_STRING_UC_STRING(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_STRING)
++#define DUK_HTHREAD_STRING_UC_STRING(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_STRING)
++#define DUK_HEAP_STRING_ARRAY(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ARRAY)
++#define DUK_HTHREAD_STRING_ARRAY(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ARRAY)
++#define DUK_HEAP_STRING_UC_FUNCTION(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_FUNCTION)
++#define DUK_HTHREAD_STRING_UC_FUNCTION(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_FUNCTION)
++#define DUK_HEAP_STRING_UC_OBJECT(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_OBJECT)
++#define DUK_HTHREAD_STRING_UC_OBJECT(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_OBJECT)
++#define DUK_HEAP_STRING_UC_NULL(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_NULL)
++#define DUK_HTHREAD_STRING_UC_NULL(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_NULL)
++#define DUK_HEAP_STRING_UC_UNDEFINED(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_UNDEFINED)
++#define DUK_HTHREAD_STRING_UC_UNDEFINED(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_UNDEFINED)
++#define DUK_HEAP_STRING_JSON_EXT_FUNCTION2(heap)                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_FUNCTION2)
++#define DUK_HTHREAD_STRING_JSON_EXT_FUNCTION2(thr)                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_FUNCTION2)
++#define DUK_HEAP_STRING_JSON_EXT_FUNCTION1(heap)                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_FUNCTION1)
++#define DUK_HTHREAD_STRING_JSON_EXT_FUNCTION1(thr)                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_FUNCTION1)
++#define DUK_HEAP_STRING_JSON_EXT_NEGINF(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_NEGINF)
++#define DUK_HTHREAD_STRING_JSON_EXT_NEGINF(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_NEGINF)
++#define DUK_HEAP_STRING_JSON_EXT_POSINF(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_POSINF)
++#define DUK_HTHREAD_STRING_JSON_EXT_POSINF(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_POSINF)
++#define DUK_HEAP_STRING_JSON_EXT_NAN(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_NAN)
++#define DUK_HTHREAD_STRING_JSON_EXT_NAN(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_NAN)
++#define DUK_HEAP_STRING_JSON_EXT_UNDEFINED(heap)                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_UNDEFINED)
++#define DUK_HTHREAD_STRING_JSON_EXT_UNDEFINED(thr)                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_UNDEFINED)
++#define DUK_HEAP_STRING_TO_LOG_STRING(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOG_STRING)
++#define DUK_HTHREAD_STRING_TO_LOG_STRING(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOG_STRING)
++#define DUK_HEAP_STRING_CLOG(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CLOG)
++#define DUK_HTHREAD_STRING_CLOG(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CLOG)
++#define DUK_HEAP_STRING_LC_L(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_L)
++#define DUK_HTHREAD_STRING_LC_L(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_L)
++#define DUK_HEAP_STRING_LC_N(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_N)
++#define DUK_HTHREAD_STRING_LC_N(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_N)
++#define DUK_HEAP_STRING_LC_FATAL(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_FATAL)
++#define DUK_HTHREAD_STRING_LC_FATAL(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_FATAL)
++#define DUK_HEAP_STRING_LC_ERROR(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_ERROR)
++#define DUK_HTHREAD_STRING_LC_ERROR(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_ERROR)
++#define DUK_HEAP_STRING_LC_WARN(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_WARN)
++#define DUK_HTHREAD_STRING_LC_WARN(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_WARN)
++#define DUK_HEAP_STRING_LC_DEBUG(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_DEBUG)
++#define DUK_HTHREAD_STRING_LC_DEBUG(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_DEBUG)
++#define DUK_HEAP_STRING_LC_TRACE(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_TRACE)
++#define DUK_HTHREAD_STRING_LC_TRACE(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_TRACE)
++#define DUK_HEAP_STRING_RAW(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RAW)
++#define DUK_HTHREAD_STRING_RAW(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RAW)
++#define DUK_HEAP_STRING_FMT(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FMT)
++#define DUK_HTHREAD_STRING_FMT(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FMT)
++#define DUK_HEAP_STRING_CURRENT(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CURRENT)
++#define DUK_HTHREAD_STRING_CURRENT(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CURRENT)
++#define DUK_HEAP_STRING_RESUME(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RESUME)
++#define DUK_HTHREAD_STRING_RESUME(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RESUME)
++#define DUK_HEAP_STRING_COMPACT(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COMPACT)
++#define DUK_HTHREAD_STRING_COMPACT(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COMPACT)
++#define DUK_HEAP_STRING_JC(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JC)
++#define DUK_HTHREAD_STRING_JC(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JC)
++#define DUK_HEAP_STRING_JX(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JX)
++#define DUK_HTHREAD_STRING_JX(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JX)
++#define DUK_HEAP_STRING_BASE64(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BASE64)
++#define DUK_HTHREAD_STRING_BASE64(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BASE64)
++#define DUK_HEAP_STRING_HEX(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_HEX)
++#define DUK_HTHREAD_STRING_HEX(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_HEX)
++#define DUK_HEAP_STRING_DEC(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEC)
++#define DUK_HTHREAD_STRING_DEC(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEC)
++#define DUK_HEAP_STRING_ENC(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENC)
++#define DUK_HTHREAD_STRING_ENC(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENC)
++#define DUK_HEAP_STRING_FIN(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FIN)
++#define DUK_HTHREAD_STRING_FIN(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FIN)
++#define DUK_HEAP_STRING_GC(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GC)
++#define DUK_HTHREAD_STRING_GC(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GC)
++#define DUK_HEAP_STRING_ACT(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ACT)
++#define DUK_HTHREAD_STRING_ACT(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ACT)
++#define DUK_HEAP_STRING_LC_INFO(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_INFO)
++#define DUK_HTHREAD_STRING_LC_INFO(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_INFO)
++#define DUK_HEAP_STRING_VERSION(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VERSION)
++#define DUK_HTHREAD_STRING_VERSION(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VERSION)
++#define DUK_HEAP_STRING_ENV(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENV)
++#define DUK_HTHREAD_STRING_ENV(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENV)
++#define DUK_HEAP_STRING_MOD_LOADED(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MOD_LOADED)
++#define DUK_HTHREAD_STRING_MOD_LOADED(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MOD_LOADED)
++#define DUK_HEAP_STRING_MOD_SEARCH(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MOD_SEARCH)
++#define DUK_HTHREAD_STRING_MOD_SEARCH(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MOD_SEARCH)
++#define DUK_HEAP_STRING_ERR_THROW(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ERR_THROW)
++#define DUK_HTHREAD_STRING_ERR_THROW(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ERR_THROW)
++#define DUK_HEAP_STRING_ERR_CREATE(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ERR_CREATE)
++#define DUK_HTHREAD_STRING_ERR_CREATE(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ERR_CREATE)
++#define DUK_HEAP_STRING_COMPILE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COMPILE)
++#define DUK_HTHREAD_STRING_COMPILE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COMPILE)
++#define DUK_HEAP_STRING_INT_REGBASE(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_REGBASE)
++#define DUK_HTHREAD_STRING_INT_REGBASE(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_REGBASE)
++#define DUK_HEAP_STRING_INT_THREAD(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_THREAD)
++#define DUK_HTHREAD_STRING_INT_THREAD(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_THREAD)
++#define DUK_HEAP_STRING_INT_HANDLER(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_HANDLER)
++#define DUK_HTHREAD_STRING_INT_HANDLER(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_HANDLER)
++#define DUK_HEAP_STRING_INT_FINALIZER(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_FINALIZER)
++#define DUK_HTHREAD_STRING_INT_FINALIZER(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_FINALIZER)
++#define DUK_HEAP_STRING_INT_CALLEE(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_CALLEE)
++#define DUK_HTHREAD_STRING_INT_CALLEE(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_CALLEE)
++#define DUK_HEAP_STRING_INT_MAP(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_MAP)
++#define DUK_HTHREAD_STRING_INT_MAP(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_MAP)
++#define DUK_HEAP_STRING_INT_ARGS(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_ARGS)
++#define DUK_HTHREAD_STRING_INT_ARGS(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_ARGS)
++#define DUK_HEAP_STRING_INT_THIS(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_THIS)
++#define DUK_HTHREAD_STRING_INT_THIS(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_THIS)
++#define DUK_HEAP_STRING_INT_PC2LINE(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_PC2LINE)
++#define DUK_HTHREAD_STRING_INT_PC2LINE(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_PC2LINE)
++#define DUK_HEAP_STRING_INT_SOURCE(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_SOURCE)
++#define DUK_HTHREAD_STRING_INT_SOURCE(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_SOURCE)
++#define DUK_HEAP_STRING_INT_VARENV(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_VARENV)
++#define DUK_HTHREAD_STRING_INT_VARENV(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_VARENV)
++#define DUK_HEAP_STRING_INT_LEXENV(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_LEXENV)
++#define DUK_HTHREAD_STRING_INT_LEXENV(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_LEXENV)
++#define DUK_HEAP_STRING_INT_VARMAP(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_VARMAP)
++#define DUK_HTHREAD_STRING_INT_VARMAP(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_VARMAP)
++#define DUK_HEAP_STRING_INT_FORMALS(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_FORMALS)
++#define DUK_HTHREAD_STRING_INT_FORMALS(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_FORMALS)
++#define DUK_HEAP_STRING_INT_BYTECODE(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_BYTECODE)
++#define DUK_HTHREAD_STRING_INT_BYTECODE(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_BYTECODE)
++#define DUK_HEAP_STRING_INT_NEXT(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_NEXT)
++#define DUK_HTHREAD_STRING_INT_NEXT(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_NEXT)
++#define DUK_HEAP_STRING_INT_TARGET(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_TARGET)
++#define DUK_HTHREAD_STRING_INT_TARGET(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_TARGET)
++#define DUK_HEAP_STRING_INT_VALUE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_VALUE)
++#define DUK_HTHREAD_STRING_INT_VALUE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_VALUE)
++#define DUK_HEAP_STRING_LC_POINTER(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_POINTER)
++#define DUK_HTHREAD_STRING_LC_POINTER(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_POINTER)
++#define DUK_HEAP_STRING_LC_BUFFER(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_BUFFER)
++#define DUK_HTHREAD_STRING_LC_BUFFER(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_BUFFER)
++#define DUK_HEAP_STRING_INT_TRACEDATA(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_TRACEDATA)
++#define DUK_HTHREAD_STRING_INT_TRACEDATA(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_TRACEDATA)
++#define DUK_HEAP_STRING_LINE_NUMBER(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LINE_NUMBER)
++#define DUK_HTHREAD_STRING_LINE_NUMBER(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LINE_NUMBER)
++#define DUK_HEAP_STRING_FILE_NAME(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FILE_NAME)
++#define DUK_HTHREAD_STRING_FILE_NAME(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FILE_NAME)
++#define DUK_HEAP_STRING_PC(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PC)
++#define DUK_HTHREAD_STRING_PC(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PC)
++#define DUK_HEAP_STRING_STACK(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_STACK)
++#define DUK_HTHREAD_STRING_STACK(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_STACK)
++#define DUK_HEAP_STRING_THROW_TYPE_ERROR(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_THROW_TYPE_ERROR)
++#define DUK_HTHREAD_STRING_THROW_TYPE_ERROR(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_THROW_TYPE_ERROR)
++#define DUK_HEAP_STRING_DUKTAPE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DUKTAPE)
++#define DUK_HTHREAD_STRING_DUKTAPE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DUKTAPE)
++#define DUK_HEAP_STRING_ID(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ID)
++#define DUK_HTHREAD_STRING_ID(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ID)
++#define DUK_HEAP_STRING_REQUIRE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REQUIRE)
++#define DUK_HTHREAD_STRING_REQUIRE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REQUIRE)
++#define DUK_HEAP_STRING___PROTO__(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX___PROTO__)
++#define DUK_HTHREAD_STRING___PROTO__(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX___PROTO__)
++#define DUK_HEAP_STRING_SET_PROTOTYPE_OF(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_PROTOTYPE_OF)
++#define DUK_HTHREAD_STRING_SET_PROTOTYPE_OF(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_PROTOTYPE_OF)
++#define DUK_HEAP_STRING_OWN_KEYS(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_OWN_KEYS)
++#define DUK_HTHREAD_STRING_OWN_KEYS(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_OWN_KEYS)
++#define DUK_HEAP_STRING_ENUMERATE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENUMERATE)
++#define DUK_HTHREAD_STRING_ENUMERATE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENUMERATE)
++#define DUK_HEAP_STRING_DELETE_PROPERTY(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DELETE_PROPERTY)
++#define DUK_HTHREAD_STRING_DELETE_PROPERTY(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DELETE_PROPERTY)
++#define DUK_HEAP_STRING_HAS(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_HAS)
++#define DUK_HTHREAD_STRING_HAS(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_HAS)
++#define DUK_HEAP_STRING_PROXY(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROXY)
++#define DUK_HTHREAD_STRING_PROXY(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROXY)
++#define DUK_HEAP_STRING_CALLEE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CALLEE)
++#define DUK_HTHREAD_STRING_CALLEE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CALLEE)
++#define DUK_HEAP_STRING_INVALID_DATE(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INVALID_DATE)
++#define DUK_HTHREAD_STRING_INVALID_DATE(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INVALID_DATE)
++#define DUK_HEAP_STRING_BRACKETED_ELLIPSIS(heap)                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BRACKETED_ELLIPSIS)
++#define DUK_HTHREAD_STRING_BRACKETED_ELLIPSIS(thr)                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BRACKETED_ELLIPSIS)
++#define DUK_HEAP_STRING_NEWLINE_TAB(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NEWLINE_TAB)
++#define DUK_HTHREAD_STRING_NEWLINE_TAB(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NEWLINE_TAB)
++#define DUK_HEAP_STRING_SPACE(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SPACE)
++#define DUK_HTHREAD_STRING_SPACE(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SPACE)
++#define DUK_HEAP_STRING_COMMA(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COMMA)
++#define DUK_HTHREAD_STRING_COMMA(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COMMA)
++#define DUK_HEAP_STRING_MINUS_ZERO(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MINUS_ZERO)
++#define DUK_HTHREAD_STRING_MINUS_ZERO(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MINUS_ZERO)
++#define DUK_HEAP_STRING_PLUS_ZERO(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PLUS_ZERO)
++#define DUK_HTHREAD_STRING_PLUS_ZERO(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PLUS_ZERO)
++#define DUK_HEAP_STRING_ZERO(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ZERO)
++#define DUK_HTHREAD_STRING_ZERO(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ZERO)
++#define DUK_HEAP_STRING_MINUS_INFINITY(heap)                          DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MINUS_INFINITY)
++#define DUK_HTHREAD_STRING_MINUS_INFINITY(thr)                        DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MINUS_INFINITY)
++#define DUK_HEAP_STRING_PLUS_INFINITY(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PLUS_INFINITY)
++#define DUK_HTHREAD_STRING_PLUS_INFINITY(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PLUS_INFINITY)
++#define DUK_HEAP_STRING_INFINITY(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INFINITY)
++#define DUK_HTHREAD_STRING_INFINITY(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INFINITY)
++#define DUK_HEAP_STRING_LC_OBJECT(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_OBJECT)
++#define DUK_HTHREAD_STRING_LC_OBJECT(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_OBJECT)
++#define DUK_HEAP_STRING_LC_STRING(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_STRING)
++#define DUK_HTHREAD_STRING_LC_STRING(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_STRING)
++#define DUK_HEAP_STRING_LC_NUMBER(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_NUMBER)
++#define DUK_HTHREAD_STRING_LC_NUMBER(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_NUMBER)
++#define DUK_HEAP_STRING_LC_BOOLEAN(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_BOOLEAN)
++#define DUK_HTHREAD_STRING_LC_BOOLEAN(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_BOOLEAN)
++#define DUK_HEAP_STRING_LC_UNDEFINED(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_UNDEFINED)
++#define DUK_HTHREAD_STRING_LC_UNDEFINED(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_UNDEFINED)
++#define DUK_HEAP_STRING_STRINGIFY(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_STRINGIFY)
++#define DUK_HTHREAD_STRING_STRINGIFY(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_STRINGIFY)
++#define DUK_HEAP_STRING_TAN(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TAN)
++#define DUK_HTHREAD_STRING_TAN(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TAN)
++#define DUK_HEAP_STRING_SQRT(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SQRT)
++#define DUK_HTHREAD_STRING_SQRT(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SQRT)
++#define DUK_HEAP_STRING_SIN(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SIN)
++#define DUK_HTHREAD_STRING_SIN(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SIN)
++#define DUK_HEAP_STRING_ROUND(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ROUND)
++#define DUK_HTHREAD_STRING_ROUND(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ROUND)
++#define DUK_HEAP_STRING_RANDOM(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RANDOM)
++#define DUK_HTHREAD_STRING_RANDOM(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RANDOM)
++#define DUK_HEAP_STRING_POW(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_POW)
++#define DUK_HTHREAD_STRING_POW(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_POW)
++#define DUK_HEAP_STRING_MIN(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MIN)
++#define DUK_HTHREAD_STRING_MIN(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MIN)
++#define DUK_HEAP_STRING_MAX(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MAX)
++#define DUK_HTHREAD_STRING_MAX(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MAX)
++#define DUK_HEAP_STRING_LOG(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LOG)
++#define DUK_HTHREAD_STRING_LOG(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LOG)
++#define DUK_HEAP_STRING_FLOOR(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FLOOR)
++#define DUK_HTHREAD_STRING_FLOOR(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FLOOR)
++#define DUK_HEAP_STRING_EXP(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXP)
++#define DUK_HTHREAD_STRING_EXP(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXP)
++#define DUK_HEAP_STRING_COS(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COS)
++#define DUK_HTHREAD_STRING_COS(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COS)
++#define DUK_HEAP_STRING_CEIL(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CEIL)
++#define DUK_HTHREAD_STRING_CEIL(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CEIL)
++#define DUK_HEAP_STRING_ATAN2(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ATAN2)
++#define DUK_HTHREAD_STRING_ATAN2(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ATAN2)
++#define DUK_HEAP_STRING_ATAN(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ATAN)
++#define DUK_HTHREAD_STRING_ATAN(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ATAN)
++#define DUK_HEAP_STRING_ASIN(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ASIN)
++#define DUK_HTHREAD_STRING_ASIN(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ASIN)
++#define DUK_HEAP_STRING_ACOS(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ACOS)
++#define DUK_HTHREAD_STRING_ACOS(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ACOS)
++#define DUK_HEAP_STRING_ABS(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ABS)
++#define DUK_HTHREAD_STRING_ABS(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ABS)
++#define DUK_HEAP_STRING_SQRT2(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SQRT2)
++#define DUK_HTHREAD_STRING_SQRT2(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SQRT2)
++#define DUK_HEAP_STRING_SQRT1_2(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SQRT1_2)
++#define DUK_HTHREAD_STRING_SQRT1_2(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SQRT1_2)
++#define DUK_HEAP_STRING_PI(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PI)
++#define DUK_HTHREAD_STRING_PI(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PI)
++#define DUK_HEAP_STRING_LOG10E(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LOG10E)
++#define DUK_HTHREAD_STRING_LOG10E(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LOG10E)
++#define DUK_HEAP_STRING_LOG2E(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LOG2E)
++#define DUK_HTHREAD_STRING_LOG2E(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LOG2E)
++#define DUK_HEAP_STRING_LN2(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LN2)
++#define DUK_HTHREAD_STRING_LN2(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LN2)
++#define DUK_HEAP_STRING_LN10(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LN10)
++#define DUK_HTHREAD_STRING_LN10(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LN10)
++#define DUK_HEAP_STRING_E(heap)                                       DUK_HEAP_GET_STRING((heap),DUK_STRIDX_E)
++#define DUK_HTHREAD_STRING_E(thr)                                     DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_E)
++#define DUK_HEAP_STRING_MESSAGE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MESSAGE)
++#define DUK_HTHREAD_STRING_MESSAGE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MESSAGE)
++#define DUK_HEAP_STRING_NAME(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NAME)
++#define DUK_HTHREAD_STRING_NAME(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NAME)
++#define DUK_HEAP_STRING_INPUT(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INPUT)
++#define DUK_HTHREAD_STRING_INPUT(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INPUT)
++#define DUK_HEAP_STRING_INDEX(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INDEX)
++#define DUK_HTHREAD_STRING_INDEX(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INDEX)
++#define DUK_HEAP_STRING_ESCAPED_EMPTY_REGEXP(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ESCAPED_EMPTY_REGEXP)
++#define DUK_HTHREAD_STRING_ESCAPED_EMPTY_REGEXP(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ESCAPED_EMPTY_REGEXP)
++#define DUK_HEAP_STRING_LAST_INDEX(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LAST_INDEX)
++#define DUK_HTHREAD_STRING_LAST_INDEX(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LAST_INDEX)
++#define DUK_HEAP_STRING_MULTILINE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MULTILINE)
++#define DUK_HTHREAD_STRING_MULTILINE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MULTILINE)
++#define DUK_HEAP_STRING_IGNORE_CASE(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IGNORE_CASE)
++#define DUK_HTHREAD_STRING_IGNORE_CASE(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IGNORE_CASE)
++#define DUK_HEAP_STRING_SOURCE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SOURCE)
++#define DUK_HTHREAD_STRING_SOURCE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SOURCE)
++#define DUK_HEAP_STRING_TEST(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TEST)
++#define DUK_HTHREAD_STRING_TEST(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TEST)
++#define DUK_HEAP_STRING_EXEC(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXEC)
++#define DUK_HTHREAD_STRING_EXEC(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXEC)
++#define DUK_HEAP_STRING_TO_GMT_STRING(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_GMT_STRING)
++#define DUK_HTHREAD_STRING_TO_GMT_STRING(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_GMT_STRING)
++#define DUK_HEAP_STRING_SET_YEAR(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_YEAR)
++#define DUK_HTHREAD_STRING_SET_YEAR(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_YEAR)
++#define DUK_HEAP_STRING_GET_YEAR(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_YEAR)
++#define DUK_HTHREAD_STRING_GET_YEAR(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_YEAR)
++#define DUK_HEAP_STRING_TO_JSON(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_JSON)
++#define DUK_HTHREAD_STRING_TO_JSON(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_JSON)
++#define DUK_HEAP_STRING_TO_ISO_STRING(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_ISO_STRING)
++#define DUK_HTHREAD_STRING_TO_ISO_STRING(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_ISO_STRING)
++#define DUK_HEAP_STRING_TO_UTC_STRING(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_UTC_STRING)
++#define DUK_HTHREAD_STRING_TO_UTC_STRING(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_UTC_STRING)
++#define DUK_HEAP_STRING_SET_UTC_FULL_YEAR(heap)                       DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_FULL_YEAR)
++#define DUK_HTHREAD_STRING_SET_UTC_FULL_YEAR(thr)                     DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_FULL_YEAR)
++#define DUK_HEAP_STRING_SET_FULL_YEAR(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_FULL_YEAR)
++#define DUK_HTHREAD_STRING_SET_FULL_YEAR(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_FULL_YEAR)
++#define DUK_HEAP_STRING_SET_UTC_MONTH(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_MONTH)
++#define DUK_HTHREAD_STRING_SET_UTC_MONTH(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_MONTH)
++#define DUK_HEAP_STRING_SET_MONTH(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_MONTH)
++#define DUK_HTHREAD_STRING_SET_MONTH(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_MONTH)
++#define DUK_HEAP_STRING_SET_UTC_DATE(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_DATE)
++#define DUK_HTHREAD_STRING_SET_UTC_DATE(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_DATE)
++#define DUK_HEAP_STRING_SET_DATE(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_DATE)
++#define DUK_HTHREAD_STRING_SET_DATE(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_DATE)
++#define DUK_HEAP_STRING_SET_UTC_HOURS(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_HOURS)
++#define DUK_HTHREAD_STRING_SET_UTC_HOURS(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_HOURS)
++#define DUK_HEAP_STRING_SET_HOURS(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_HOURS)
++#define DUK_HTHREAD_STRING_SET_HOURS(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_HOURS)
++#define DUK_HEAP_STRING_SET_UTC_MINUTES(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_MINUTES)
++#define DUK_HTHREAD_STRING_SET_UTC_MINUTES(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_MINUTES)
++#define DUK_HEAP_STRING_SET_MINUTES(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_MINUTES)
++#define DUK_HTHREAD_STRING_SET_MINUTES(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_MINUTES)
++#define DUK_HEAP_STRING_SET_UTC_SECONDS(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_SECONDS)
++#define DUK_HTHREAD_STRING_SET_UTC_SECONDS(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_SECONDS)
++#define DUK_HEAP_STRING_SET_SECONDS(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_SECONDS)
++#define DUK_HTHREAD_STRING_SET_SECONDS(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_SECONDS)
++#define DUK_HEAP_STRING_SET_UTC_MILLISECONDS(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_MILLISECONDS)
++#define DUK_HTHREAD_STRING_SET_UTC_MILLISECONDS(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_MILLISECONDS)
++#define DUK_HEAP_STRING_SET_MILLISECONDS(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_MILLISECONDS)
++#define DUK_HTHREAD_STRING_SET_MILLISECONDS(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_MILLISECONDS)
++#define DUK_HEAP_STRING_SET_TIME(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_TIME)
++#define DUK_HTHREAD_STRING_SET_TIME(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_TIME)
++#define DUK_HEAP_STRING_GET_TIMEZONE_OFFSET(heap)                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_TIMEZONE_OFFSET)
++#define DUK_HTHREAD_STRING_GET_TIMEZONE_OFFSET(thr)                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_TIMEZONE_OFFSET)
++#define DUK_HEAP_STRING_GET_UTC_MILLISECONDS(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_MILLISECONDS)
++#define DUK_HTHREAD_STRING_GET_UTC_MILLISECONDS(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_MILLISECONDS)
++#define DUK_HEAP_STRING_GET_MILLISECONDS(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_MILLISECONDS)
++#define DUK_HTHREAD_STRING_GET_MILLISECONDS(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_MILLISECONDS)
++#define DUK_HEAP_STRING_GET_UTC_SECONDS(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_SECONDS)
++#define DUK_HTHREAD_STRING_GET_UTC_SECONDS(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_SECONDS)
++#define DUK_HEAP_STRING_GET_SECONDS(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_SECONDS)
++#define DUK_HTHREAD_STRING_GET_SECONDS(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_SECONDS)
++#define DUK_HEAP_STRING_GET_UTC_MINUTES(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_MINUTES)
++#define DUK_HTHREAD_STRING_GET_UTC_MINUTES(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_MINUTES)
++#define DUK_HEAP_STRING_GET_MINUTES(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_MINUTES)
++#define DUK_HTHREAD_STRING_GET_MINUTES(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_MINUTES)
++#define DUK_HEAP_STRING_GET_UTC_HOURS(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_HOURS)
++#define DUK_HTHREAD_STRING_GET_UTC_HOURS(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_HOURS)
++#define DUK_HEAP_STRING_GET_HOURS(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_HOURS)
++#define DUK_HTHREAD_STRING_GET_HOURS(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_HOURS)
++#define DUK_HEAP_STRING_GET_UTC_DAY(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_DAY)
++#define DUK_HTHREAD_STRING_GET_UTC_DAY(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_DAY)
++#define DUK_HEAP_STRING_GET_DAY(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_DAY)
++#define DUK_HTHREAD_STRING_GET_DAY(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_DAY)
++#define DUK_HEAP_STRING_GET_UTC_DATE(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_DATE)
++#define DUK_HTHREAD_STRING_GET_UTC_DATE(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_DATE)
++#define DUK_HEAP_STRING_GET_DATE(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_DATE)
++#define DUK_HTHREAD_STRING_GET_DATE(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_DATE)
++#define DUK_HEAP_STRING_GET_UTC_MONTH(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_MONTH)
++#define DUK_HTHREAD_STRING_GET_UTC_MONTH(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_MONTH)
++#define DUK_HEAP_STRING_GET_MONTH(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_MONTH)
++#define DUK_HTHREAD_STRING_GET_MONTH(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_MONTH)
++#define DUK_HEAP_STRING_GET_UTC_FULL_YEAR(heap)                       DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_FULL_YEAR)
++#define DUK_HTHREAD_STRING_GET_UTC_FULL_YEAR(thr)                     DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_FULL_YEAR)
++#define DUK_HEAP_STRING_GET_FULL_YEAR(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_FULL_YEAR)
++#define DUK_HTHREAD_STRING_GET_FULL_YEAR(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_FULL_YEAR)
++#define DUK_HEAP_STRING_GET_TIME(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_TIME)
++#define DUK_HTHREAD_STRING_GET_TIME(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_TIME)
++#define DUK_HEAP_STRING_TO_LOCALE_TIME_STRING(heap)                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_TIME_STRING)
++#define DUK_HTHREAD_STRING_TO_LOCALE_TIME_STRING(thr)                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_TIME_STRING)
++#define DUK_HEAP_STRING_TO_LOCALE_DATE_STRING(heap)                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_DATE_STRING)
++#define DUK_HTHREAD_STRING_TO_LOCALE_DATE_STRING(thr)                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_DATE_STRING)
++#define DUK_HEAP_STRING_TO_TIME_STRING(heap)                          DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_TIME_STRING)
++#define DUK_HTHREAD_STRING_TO_TIME_STRING(thr)                        DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_TIME_STRING)
++#define DUK_HEAP_STRING_TO_DATE_STRING(heap)                          DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_DATE_STRING)
++#define DUK_HTHREAD_STRING_TO_DATE_STRING(thr)                        DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_DATE_STRING)
++#define DUK_HEAP_STRING_NOW(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NOW)
++#define DUK_HTHREAD_STRING_NOW(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NOW)
++#define DUK_HEAP_STRING_UTC(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UTC)
++#define DUK_HTHREAD_STRING_UTC(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UTC)
++#define DUK_HEAP_STRING_PARSE(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PARSE)
++#define DUK_HTHREAD_STRING_PARSE(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PARSE)
++#define DUK_HEAP_STRING_TO_PRECISION(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_PRECISION)
++#define DUK_HTHREAD_STRING_TO_PRECISION(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_PRECISION)
++#define DUK_HEAP_STRING_TO_EXPONENTIAL(heap)                          DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_EXPONENTIAL)
++#define DUK_HTHREAD_STRING_TO_EXPONENTIAL(thr)                        DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_EXPONENTIAL)
++#define DUK_HEAP_STRING_TO_FIXED(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_FIXED)
++#define DUK_HTHREAD_STRING_TO_FIXED(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_FIXED)
++#define DUK_HEAP_STRING_POSITIVE_INFINITY(heap)                       DUK_HEAP_GET_STRING((heap),DUK_STRIDX_POSITIVE_INFINITY)
++#define DUK_HTHREAD_STRING_POSITIVE_INFINITY(thr)                     DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_POSITIVE_INFINITY)
++#define DUK_HEAP_STRING_NEGATIVE_INFINITY(heap)                       DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NEGATIVE_INFINITY)
++#define DUK_HTHREAD_STRING_NEGATIVE_INFINITY(thr)                     DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NEGATIVE_INFINITY)
++#define DUK_HEAP_STRING_NAN(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NAN)
++#define DUK_HTHREAD_STRING_NAN(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NAN)
++#define DUK_HEAP_STRING_MIN_VALUE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MIN_VALUE)
++#define DUK_HTHREAD_STRING_MIN_VALUE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MIN_VALUE)
++#define DUK_HEAP_STRING_MAX_VALUE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MAX_VALUE)
++#define DUK_HTHREAD_STRING_MAX_VALUE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MAX_VALUE)
++#define DUK_HEAP_STRING_SUBSTR(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SUBSTR)
++#define DUK_HTHREAD_STRING_SUBSTR(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SUBSTR)
++#define DUK_HEAP_STRING_TRIM(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TRIM)
++#define DUK_HTHREAD_STRING_TRIM(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TRIM)
++#define DUK_HEAP_STRING_TO_LOCALE_UPPER_CASE(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_UPPER_CASE)
++#define DUK_HTHREAD_STRING_TO_LOCALE_UPPER_CASE(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_UPPER_CASE)
++#define DUK_HEAP_STRING_TO_UPPER_CASE(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_UPPER_CASE)
++#define DUK_HTHREAD_STRING_TO_UPPER_CASE(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_UPPER_CASE)
++#define DUK_HEAP_STRING_TO_LOCALE_LOWER_CASE(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_LOWER_CASE)
++#define DUK_HTHREAD_STRING_TO_LOCALE_LOWER_CASE(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_LOWER_CASE)
++#define DUK_HEAP_STRING_TO_LOWER_CASE(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOWER_CASE)
++#define DUK_HTHREAD_STRING_TO_LOWER_CASE(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOWER_CASE)
++#define DUK_HEAP_STRING_SUBSTRING(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SUBSTRING)
++#define DUK_HTHREAD_STRING_SUBSTRING(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SUBSTRING)
++#define DUK_HEAP_STRING_SPLIT(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SPLIT)
++#define DUK_HTHREAD_STRING_SPLIT(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SPLIT)
++#define DUK_HEAP_STRING_SEARCH(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SEARCH)
++#define DUK_HTHREAD_STRING_SEARCH(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SEARCH)
++#define DUK_HEAP_STRING_REPLACE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REPLACE)
++#define DUK_HTHREAD_STRING_REPLACE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REPLACE)
++#define DUK_HEAP_STRING_MATCH(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MATCH)
++#define DUK_HTHREAD_STRING_MATCH(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MATCH)
++#define DUK_HEAP_STRING_LOCALE_COMPARE(heap)                          DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LOCALE_COMPARE)
++#define DUK_HTHREAD_STRING_LOCALE_COMPARE(thr)                        DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LOCALE_COMPARE)
++#define DUK_HEAP_STRING_CHAR_CODE_AT(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CHAR_CODE_AT)
++#define DUK_HTHREAD_STRING_CHAR_CODE_AT(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CHAR_CODE_AT)
++#define DUK_HEAP_STRING_CHAR_AT(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CHAR_AT)
++#define DUK_HTHREAD_STRING_CHAR_AT(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CHAR_AT)
++#define DUK_HEAP_STRING_FROM_CHAR_CODE(heap)                          DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FROM_CHAR_CODE)
++#define DUK_HTHREAD_STRING_FROM_CHAR_CODE(thr)                        DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FROM_CHAR_CODE)
++#define DUK_HEAP_STRING_REDUCE_RIGHT(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REDUCE_RIGHT)
++#define DUK_HTHREAD_STRING_REDUCE_RIGHT(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REDUCE_RIGHT)
++#define DUK_HEAP_STRING_REDUCE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REDUCE)
++#define DUK_HTHREAD_STRING_REDUCE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REDUCE)
++#define DUK_HEAP_STRING_FILTER(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FILTER)
++#define DUK_HTHREAD_STRING_FILTER(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FILTER)
++#define DUK_HEAP_STRING_MAP(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MAP)
++#define DUK_HTHREAD_STRING_MAP(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MAP)
++#define DUK_HEAP_STRING_FOR_EACH(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FOR_EACH)
++#define DUK_HTHREAD_STRING_FOR_EACH(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FOR_EACH)
++#define DUK_HEAP_STRING_SOME(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SOME)
++#define DUK_HTHREAD_STRING_SOME(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SOME)
++#define DUK_HEAP_STRING_EVERY(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EVERY)
++#define DUK_HTHREAD_STRING_EVERY(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EVERY)
++#define DUK_HEAP_STRING_LAST_INDEX_OF(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LAST_INDEX_OF)
++#define DUK_HTHREAD_STRING_LAST_INDEX_OF(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LAST_INDEX_OF)
++#define DUK_HEAP_STRING_INDEX_OF(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INDEX_OF)
++#define DUK_HTHREAD_STRING_INDEX_OF(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INDEX_OF)
++#define DUK_HEAP_STRING_UNSHIFT(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UNSHIFT)
++#define DUK_HTHREAD_STRING_UNSHIFT(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UNSHIFT)
++#define DUK_HEAP_STRING_SPLICE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SPLICE)
++#define DUK_HTHREAD_STRING_SPLICE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SPLICE)
++#define DUK_HEAP_STRING_SORT(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SORT)
++#define DUK_HTHREAD_STRING_SORT(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SORT)
++#define DUK_HEAP_STRING_SLICE(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SLICE)
++#define DUK_HTHREAD_STRING_SLICE(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SLICE)
++#define DUK_HEAP_STRING_SHIFT(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SHIFT)
++#define DUK_HTHREAD_STRING_SHIFT(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SHIFT)
++#define DUK_HEAP_STRING_REVERSE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REVERSE)
++#define DUK_HTHREAD_STRING_REVERSE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REVERSE)
++#define DUK_HEAP_STRING_PUSH(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PUSH)
++#define DUK_HTHREAD_STRING_PUSH(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PUSH)
++#define DUK_HEAP_STRING_POP(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_POP)
++#define DUK_HTHREAD_STRING_POP(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_POP)
++#define DUK_HEAP_STRING_JOIN(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JOIN)
++#define DUK_HTHREAD_STRING_JOIN(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JOIN)
++#define DUK_HEAP_STRING_CONCAT(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONCAT)
++#define DUK_HTHREAD_STRING_CONCAT(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONCAT)
++#define DUK_HEAP_STRING_IS_ARRAY(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_ARRAY)
++#define DUK_HTHREAD_STRING_IS_ARRAY(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_ARRAY)
++#define DUK_HEAP_STRING_LC_ARGUMENTS(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_ARGUMENTS)
++#define DUK_HTHREAD_STRING_LC_ARGUMENTS(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_ARGUMENTS)
++#define DUK_HEAP_STRING_CALLER(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CALLER)
++#define DUK_HTHREAD_STRING_CALLER(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CALLER)
++#define DUK_HEAP_STRING_BIND(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BIND)
++#define DUK_HTHREAD_STRING_BIND(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BIND)
++#define DUK_HEAP_STRING_CALL(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CALL)
++#define DUK_HTHREAD_STRING_CALL(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CALL)
++#define DUK_HEAP_STRING_APPLY(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_APPLY)
++#define DUK_HTHREAD_STRING_APPLY(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_APPLY)
++#define DUK_HEAP_STRING_PROPERTY_IS_ENUMERABLE(heap)                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROPERTY_IS_ENUMERABLE)
++#define DUK_HTHREAD_STRING_PROPERTY_IS_ENUMERABLE(thr)                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROPERTY_IS_ENUMERABLE)
++#define DUK_HEAP_STRING_IS_PROTOTYPE_OF(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_PROTOTYPE_OF)
++#define DUK_HTHREAD_STRING_IS_PROTOTYPE_OF(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_PROTOTYPE_OF)
++#define DUK_HEAP_STRING_HAS_OWN_PROPERTY(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_HAS_OWN_PROPERTY)
++#define DUK_HTHREAD_STRING_HAS_OWN_PROPERTY(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_HAS_OWN_PROPERTY)
++#define DUK_HEAP_STRING_VALUE_OF(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VALUE_OF)
++#define DUK_HTHREAD_STRING_VALUE_OF(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VALUE_OF)
++#define DUK_HEAP_STRING_TO_LOCALE_STRING(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_STRING)
++#define DUK_HTHREAD_STRING_TO_LOCALE_STRING(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_STRING)
++#define DUK_HEAP_STRING_TO_STRING(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_STRING)
++#define DUK_HTHREAD_STRING_TO_STRING(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_STRING)
++#define DUK_HEAP_STRING_CONSTRUCTOR(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONSTRUCTOR)
++#define DUK_HTHREAD_STRING_CONSTRUCTOR(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONSTRUCTOR)
++#define DUK_HEAP_STRING_SET(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET)
++#define DUK_HTHREAD_STRING_SET(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET)
++#define DUK_HEAP_STRING_GET(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET)
++#define DUK_HTHREAD_STRING_GET(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET)
++#define DUK_HEAP_STRING_ENUMERABLE(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENUMERABLE)
++#define DUK_HTHREAD_STRING_ENUMERABLE(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENUMERABLE)
++#define DUK_HEAP_STRING_CONFIGURABLE(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONFIGURABLE)
++#define DUK_HTHREAD_STRING_CONFIGURABLE(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONFIGURABLE)
++#define DUK_HEAP_STRING_WRITABLE(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITABLE)
++#define DUK_HTHREAD_STRING_WRITABLE(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITABLE)
++#define DUK_HEAP_STRING_VALUE(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VALUE)
++#define DUK_HTHREAD_STRING_VALUE(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VALUE)
++#define DUK_HEAP_STRING_KEYS(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_KEYS)
++#define DUK_HTHREAD_STRING_KEYS(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_KEYS)
++#define DUK_HEAP_STRING_IS_EXTENSIBLE(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_EXTENSIBLE)
++#define DUK_HTHREAD_STRING_IS_EXTENSIBLE(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_EXTENSIBLE)
++#define DUK_HEAP_STRING_IS_FROZEN(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_FROZEN)
++#define DUK_HTHREAD_STRING_IS_FROZEN(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_FROZEN)
++#define DUK_HEAP_STRING_IS_SEALED(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_SEALED)
++#define DUK_HTHREAD_STRING_IS_SEALED(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_SEALED)
++#define DUK_HEAP_STRING_PREVENT_EXTENSIONS(heap)                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PREVENT_EXTENSIONS)
++#define DUK_HTHREAD_STRING_PREVENT_EXTENSIONS(thr)                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PREVENT_EXTENSIONS)
++#define DUK_HEAP_STRING_FREEZE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FREEZE)
++#define DUK_HTHREAD_STRING_FREEZE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FREEZE)
++#define DUK_HEAP_STRING_SEAL(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SEAL)
++#define DUK_HTHREAD_STRING_SEAL(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SEAL)
++#define DUK_HEAP_STRING_DEFINE_PROPERTIES(heap)                       DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEFINE_PROPERTIES)
++#define DUK_HTHREAD_STRING_DEFINE_PROPERTIES(thr)                     DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEFINE_PROPERTIES)
++#define DUK_HEAP_STRING_DEFINE_PROPERTY(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEFINE_PROPERTY)
++#define DUK_HTHREAD_STRING_DEFINE_PROPERTY(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEFINE_PROPERTY)
++#define DUK_HEAP_STRING_CREATE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CREATE)
++#define DUK_HTHREAD_STRING_CREATE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CREATE)
++#define DUK_HEAP_STRING_GET_OWN_PROPERTY_NAMES(heap)                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_OWN_PROPERTY_NAMES)
++#define DUK_HTHREAD_STRING_GET_OWN_PROPERTY_NAMES(thr)                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_OWN_PROPERTY_NAMES)
++#define DUK_HEAP_STRING_GET_OWN_PROPERTY_DESCRIPTOR(heap)             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_OWN_PROPERTY_DESCRIPTOR)
++#define DUK_HTHREAD_STRING_GET_OWN_PROPERTY_DESCRIPTOR(thr)           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_OWN_PROPERTY_DESCRIPTOR)
++#define DUK_HEAP_STRING_GET_PROTOTYPE_OF(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_PROTOTYPE_OF)
++#define DUK_HTHREAD_STRING_GET_PROTOTYPE_OF(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_PROTOTYPE_OF)
++#define DUK_HEAP_STRING_PROTOTYPE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROTOTYPE)
++#define DUK_HTHREAD_STRING_PROTOTYPE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROTOTYPE)
++#define DUK_HEAP_STRING_LENGTH(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LENGTH)
++#define DUK_HTHREAD_STRING_LENGTH(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LENGTH)
++#define DUK_HEAP_STRING_ALERT(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ALERT)
++#define DUK_HTHREAD_STRING_ALERT(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ALERT)
++#define DUK_HEAP_STRING_PRINT(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PRINT)
++#define DUK_HTHREAD_STRING_PRINT(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PRINT)
++#define DUK_HEAP_STRING_UNESCAPE(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UNESCAPE)
++#define DUK_HTHREAD_STRING_UNESCAPE(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UNESCAPE)
++#define DUK_HEAP_STRING_ESCAPE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ESCAPE)
++#define DUK_HTHREAD_STRING_ESCAPE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ESCAPE)
++#define DUK_HEAP_STRING_ENCODE_URI_COMPONENT(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENCODE_URI_COMPONENT)
++#define DUK_HTHREAD_STRING_ENCODE_URI_COMPONENT(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENCODE_URI_COMPONENT)
++#define DUK_HEAP_STRING_ENCODE_URI(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENCODE_URI)
++#define DUK_HTHREAD_STRING_ENCODE_URI(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENCODE_URI)
++#define DUK_HEAP_STRING_DECODE_URI_COMPONENT(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DECODE_URI_COMPONENT)
++#define DUK_HTHREAD_STRING_DECODE_URI_COMPONENT(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DECODE_URI_COMPONENT)
++#define DUK_HEAP_STRING_DECODE_URI(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DECODE_URI)
++#define DUK_HTHREAD_STRING_DECODE_URI(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DECODE_URI)
++#define DUK_HEAP_STRING_IS_FINITE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_FINITE)
++#define DUK_HTHREAD_STRING_IS_FINITE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_FINITE)
++#define DUK_HEAP_STRING_IS_NAN(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_NAN)
++#define DUK_HTHREAD_STRING_IS_NAN(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_NAN)
++#define DUK_HEAP_STRING_PARSE_FLOAT(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PARSE_FLOAT)
++#define DUK_HTHREAD_STRING_PARSE_FLOAT(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PARSE_FLOAT)
++#define DUK_HEAP_STRING_PARSE_INT(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PARSE_INT)
++#define DUK_HTHREAD_STRING_PARSE_INT(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PARSE_INT)
++#define DUK_HEAP_STRING_EVAL(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EVAL)
++#define DUK_HTHREAD_STRING_EVAL(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EVAL)
++#define DUK_HEAP_STRING_URI_ERROR(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_URI_ERROR)
++#define DUK_HTHREAD_STRING_URI_ERROR(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_URI_ERROR)
++#define DUK_HEAP_STRING_TYPE_ERROR(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TYPE_ERROR)
++#define DUK_HTHREAD_STRING_TYPE_ERROR(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TYPE_ERROR)
++#define DUK_HEAP_STRING_SYNTAX_ERROR(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SYNTAX_ERROR)
++#define DUK_HTHREAD_STRING_SYNTAX_ERROR(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SYNTAX_ERROR)
++#define DUK_HEAP_STRING_REFERENCE_ERROR(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REFERENCE_ERROR)
++#define DUK_HTHREAD_STRING_REFERENCE_ERROR(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REFERENCE_ERROR)
++#define DUK_HEAP_STRING_RANGE_ERROR(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RANGE_ERROR)
++#define DUK_HTHREAD_STRING_RANGE_ERROR(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RANGE_ERROR)
++#define DUK_HEAP_STRING_EVAL_ERROR(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EVAL_ERROR)
++#define DUK_HTHREAD_STRING_EVAL_ERROR(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EVAL_ERROR)
++#define DUK_HEAP_STRING_BREAK(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BREAK)
++#define DUK_HTHREAD_STRING_BREAK(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BREAK)
++#define DUK_HEAP_STRING_CASE(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CASE)
++#define DUK_HTHREAD_STRING_CASE(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CASE)
++#define DUK_HEAP_STRING_CATCH(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CATCH)
++#define DUK_HTHREAD_STRING_CATCH(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CATCH)
++#define DUK_HEAP_STRING_CONTINUE(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONTINUE)
++#define DUK_HTHREAD_STRING_CONTINUE(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONTINUE)
++#define DUK_HEAP_STRING_DEBUGGER(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEBUGGER)
++#define DUK_HTHREAD_STRING_DEBUGGER(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEBUGGER)
++#define DUK_HEAP_STRING_DEFAULT(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEFAULT)
++#define DUK_HTHREAD_STRING_DEFAULT(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEFAULT)
++#define DUK_HEAP_STRING_DELETE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DELETE)
++#define DUK_HTHREAD_STRING_DELETE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DELETE)
++#define DUK_HEAP_STRING_DO(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DO)
++#define DUK_HTHREAD_STRING_DO(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DO)
++#define DUK_HEAP_STRING_ELSE(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ELSE)
++#define DUK_HTHREAD_STRING_ELSE(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ELSE)
++#define DUK_HEAP_STRING_FINALLY(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FINALLY)
++#define DUK_HTHREAD_STRING_FINALLY(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FINALLY)
++#define DUK_HEAP_STRING_FOR(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FOR)
++#define DUK_HTHREAD_STRING_FOR(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FOR)
++#define DUK_HEAP_STRING_LC_FUNCTION(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_FUNCTION)
++#define DUK_HTHREAD_STRING_LC_FUNCTION(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_FUNCTION)
++#define DUK_HEAP_STRING_IF(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IF)
++#define DUK_HTHREAD_STRING_IF(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IF)
++#define DUK_HEAP_STRING_IN(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IN)
++#define DUK_HTHREAD_STRING_IN(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IN)
++#define DUK_HEAP_STRING_INSTANCEOF(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INSTANCEOF)
++#define DUK_HTHREAD_STRING_INSTANCEOF(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INSTANCEOF)
++#define DUK_HEAP_STRING_NEW(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NEW)
++#define DUK_HTHREAD_STRING_NEW(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NEW)
++#define DUK_HEAP_STRING_RETURN(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RETURN)
++#define DUK_HTHREAD_STRING_RETURN(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RETURN)
++#define DUK_HEAP_STRING_SWITCH(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SWITCH)
++#define DUK_HTHREAD_STRING_SWITCH(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SWITCH)
++#define DUK_HEAP_STRING_THIS(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_THIS)
++#define DUK_HTHREAD_STRING_THIS(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_THIS)
++#define DUK_HEAP_STRING_THROW(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_THROW)
++#define DUK_HTHREAD_STRING_THROW(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_THROW)
++#define DUK_HEAP_STRING_TRY(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TRY)
++#define DUK_HTHREAD_STRING_TRY(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TRY)
++#define DUK_HEAP_STRING_TYPEOF(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TYPEOF)
++#define DUK_HTHREAD_STRING_TYPEOF(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TYPEOF)
++#define DUK_HEAP_STRING_VAR(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VAR)
++#define DUK_HTHREAD_STRING_VAR(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VAR)
++#define DUK_HEAP_STRING_VOID(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VOID)
++#define DUK_HTHREAD_STRING_VOID(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VOID)
++#define DUK_HEAP_STRING_WHILE(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WHILE)
++#define DUK_HTHREAD_STRING_WHILE(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WHILE)
++#define DUK_HEAP_STRING_WITH(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WITH)
++#define DUK_HTHREAD_STRING_WITH(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WITH)
++#define DUK_HEAP_STRING_CLASS(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CLASS)
++#define DUK_HTHREAD_STRING_CLASS(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CLASS)
++#define DUK_HEAP_STRING_CONST(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONST)
++#define DUK_HTHREAD_STRING_CONST(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONST)
++#define DUK_HEAP_STRING_ENUM(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENUM)
++#define DUK_HTHREAD_STRING_ENUM(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENUM)
++#define DUK_HEAP_STRING_EXPORT(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXPORT)
++#define DUK_HTHREAD_STRING_EXPORT(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXPORT)
++#define DUK_HEAP_STRING_EXTENDS(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXTENDS)
++#define DUK_HTHREAD_STRING_EXTENDS(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXTENDS)
++#define DUK_HEAP_STRING_IMPORT(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IMPORT)
++#define DUK_HTHREAD_STRING_IMPORT(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IMPORT)
++#define DUK_HEAP_STRING_SUPER(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SUPER)
++#define DUK_HTHREAD_STRING_SUPER(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SUPER)
++#define DUK_HEAP_STRING_LC_NULL(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_NULL)
++#define DUK_HTHREAD_STRING_LC_NULL(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_NULL)
++#define DUK_HEAP_STRING_TRUE(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TRUE)
++#define DUK_HTHREAD_STRING_TRUE(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TRUE)
++#define DUK_HEAP_STRING_FALSE(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FALSE)
++#define DUK_HTHREAD_STRING_FALSE(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FALSE)
++#define DUK_HEAP_STRING_IMPLEMENTS(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IMPLEMENTS)
++#define DUK_HTHREAD_STRING_IMPLEMENTS(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IMPLEMENTS)
++#define DUK_HEAP_STRING_INTERFACE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INTERFACE)
++#define DUK_HTHREAD_STRING_INTERFACE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INTERFACE)
++#define DUK_HEAP_STRING_LET(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LET)
++#define DUK_HTHREAD_STRING_LET(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LET)
++#define DUK_HEAP_STRING_PACKAGE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PACKAGE)
++#define DUK_HTHREAD_STRING_PACKAGE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PACKAGE)
++#define DUK_HEAP_STRING_PRIVATE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PRIVATE)
++#define DUK_HTHREAD_STRING_PRIVATE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PRIVATE)
++#define DUK_HEAP_STRING_PROTECTED(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROTECTED)
++#define DUK_HTHREAD_STRING_PROTECTED(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROTECTED)
++#define DUK_HEAP_STRING_PUBLIC(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PUBLIC)
++#define DUK_HTHREAD_STRING_PUBLIC(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PUBLIC)
++#define DUK_HEAP_STRING_STATIC(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_STATIC)
++#define DUK_HTHREAD_STRING_STATIC(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_STATIC)
++#define DUK_HEAP_STRING_YIELD(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_YIELD)
++#define DUK_HTHREAD_STRING_YIELD(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_YIELD)
++
++#define DUK_HEAP_NUM_STRINGS                                          336
++
++#define DUK_STRIDX_START_RESERVED                                     291
++#define DUK_STRIDX_START_STRICT_RESERVED                              327
++#define DUK_STRIDX_END_RESERVED                                       336                            /* exclusive endpoint */
++
++#if !defined(DUK_SINGLE_FILE)
++DUK_INTERNAL_DECL const duk_c_function duk_bi_native_functions[128];
++DUK_INTERNAL_DECL const duk_uint8_t duk_builtins_data[1341];
++#ifdef DUK_USE_BUILTIN_INITJS
++DUK_INTERNAL_DECL const duk_uint8_t duk_initjs_data[187];
++#endif  /* DUK_USE_BUILTIN_INITJS */
++#endif  /* !DUK_SINGLE_FILE */
++
++#define DUK_BUILTINS_DATA_LENGTH                                      1341
++#ifdef DUK_USE_BUILTIN_INITJS
++#define DUK_BUILTIN_INITJS_DATA_LENGTH                                187
++#endif  /* DUK_USE_BUILTIN_INITJS */
++
++#define DUK_BIDX_GLOBAL                                               0
++#define DUK_BIDX_GLOBAL_ENV                                           1
++#define DUK_BIDX_OBJECT_CONSTRUCTOR                                   2
++#define DUK_BIDX_OBJECT_PROTOTYPE                                     3
++#define DUK_BIDX_FUNCTION_CONSTRUCTOR                                 4
++#define DUK_BIDX_FUNCTION_PROTOTYPE                                   5
++#define DUK_BIDX_ARRAY_CONSTRUCTOR                                    6
++#define DUK_BIDX_ARRAY_PROTOTYPE                                      7
++#define DUK_BIDX_STRING_CONSTRUCTOR                                   8
++#define DUK_BIDX_STRING_PROTOTYPE                                     9
++#define DUK_BIDX_BOOLEAN_CONSTRUCTOR                                  10
++#define DUK_BIDX_BOOLEAN_PROTOTYPE                                    11
++#define DUK_BIDX_NUMBER_CONSTRUCTOR                                   12
++#define DUK_BIDX_NUMBER_PROTOTYPE                                     13
++#define DUK_BIDX_DATE_CONSTRUCTOR                                     14
++#define DUK_BIDX_DATE_PROTOTYPE                                       15
++#define DUK_BIDX_REGEXP_CONSTRUCTOR                                   16
++#define DUK_BIDX_REGEXP_PROTOTYPE                                     17
++#define DUK_BIDX_ERROR_CONSTRUCTOR                                    18
++#define DUK_BIDX_ERROR_PROTOTYPE                                      19
++#define DUK_BIDX_EVAL_ERROR_CONSTRUCTOR                               20
++#define DUK_BIDX_EVAL_ERROR_PROTOTYPE                                 21
++#define DUK_BIDX_RANGE_ERROR_CONSTRUCTOR                              22
++#define DUK_BIDX_RANGE_ERROR_PROTOTYPE                                23
++#define DUK_BIDX_REFERENCE_ERROR_CONSTRUCTOR                          24
++#define DUK_BIDX_REFERENCE_ERROR_PROTOTYPE                            25
++#define DUK_BIDX_SYNTAX_ERROR_CONSTRUCTOR                             26
++#define DUK_BIDX_SYNTAX_ERROR_PROTOTYPE                               27
++#define DUK_BIDX_TYPE_ERROR_CONSTRUCTOR                               28
++#define DUK_BIDX_TYPE_ERROR_PROTOTYPE                                 29
++#define DUK_BIDX_URI_ERROR_CONSTRUCTOR                                30
++#define DUK_BIDX_URI_ERROR_PROTOTYPE                                  31
++#define DUK_BIDX_MATH                                                 32
++#define DUK_BIDX_JSON                                                 33
++#define DUK_BIDX_TYPE_ERROR_THROWER                                   34
++#define DUK_BIDX_PROXY_CONSTRUCTOR                                    35
++#define DUK_BIDX_DUKTAPE                                              36
++#define DUK_BIDX_THREAD_CONSTRUCTOR                                   37
++#define DUK_BIDX_THREAD_PROTOTYPE                                     38
++#define DUK_BIDX_BUFFER_CONSTRUCTOR                                   39
++#define DUK_BIDX_BUFFER_PROTOTYPE                                     40
++#define DUK_BIDX_POINTER_CONSTRUCTOR                                  41
++#define DUK_BIDX_POINTER_PROTOTYPE                                    42
++#define DUK_BIDX_LOGGER_CONSTRUCTOR                                   43
++#define DUK_BIDX_LOGGER_PROTOTYPE                                     44
++#define DUK_BIDX_DOUBLE_ERROR                                         45
++
++#define DUK_NUM_BUILTINS                                              46
++
++#elif defined(DUK_USE_DOUBLE_ME)
++#if !defined(DUK_SINGLE_FILE)
++DUK_INTERNAL_DECL const duk_uint8_t duk_strings_data[1943];
++#endif  /* !DUK_SINGLE_FILE */
++
++#define DUK_STRDATA_DATA_LENGTH                                       1943
++#define DUK_STRDATA_MAX_STRLEN                                        24
++
++#define DUK_STRIDX_UC_LOGGER                                          0                              /* 'Logger' */
++#define DUK_STRIDX_UC_THREAD                                          1                              /* 'Thread' */
++#define DUK_STRIDX_UC_POINTER                                         2                              /* 'Pointer' */
++#define DUK_STRIDX_UC_BUFFER                                          3                              /* 'Buffer' */
++#define DUK_STRIDX_DEC_ENV                                            4                              /* 'DecEnv' */
++#define DUK_STRIDX_OBJ_ENV                                            5                              /* 'ObjEnv' */
++#define DUK_STRIDX_EMPTY_STRING                                       6                              /* '' */
++#define DUK_STRIDX_GLOBAL                                             7                              /* 'global' */
++#define DUK_STRIDX_UC_ARGUMENTS                                       8                              /* 'Arguments' */
++#define DUK_STRIDX_JSON                                               9                              /* 'JSON' */
++#define DUK_STRIDX_MATH                                               10                             /* 'Math' */
++#define DUK_STRIDX_UC_ERROR                                           11                             /* 'Error' */
++#define DUK_STRIDX_REG_EXP                                            12                             /* 'RegExp' */
++#define DUK_STRIDX_DATE                                               13                             /* 'Date' */
++#define DUK_STRIDX_UC_NUMBER                                          14                             /* 'Number' */
++#define DUK_STRIDX_UC_BOOLEAN                                         15                             /* 'Boolean' */
++#define DUK_STRIDX_UC_STRING                                          16                             /* 'String' */
++#define DUK_STRIDX_ARRAY                                              17                             /* 'Array' */
++#define DUK_STRIDX_UC_FUNCTION                                        18                             /* 'Function' */
++#define DUK_STRIDX_UC_OBJECT                                          19                             /* 'Object' */
++#define DUK_STRIDX_UC_NULL                                            20                             /* 'Null' */
++#define DUK_STRIDX_UC_UNDEFINED                                       21                             /* 'Undefined' */
++#define DUK_STRIDX_JSON_EXT_FUNCTION2                                 22                             /* '{_func:true}' */
++#define DUK_STRIDX_JSON_EXT_FUNCTION1                                 23                             /* '{"_func":true}' */
++#define DUK_STRIDX_JSON_EXT_NEGINF                                    24                             /* '{"_ninf":true}' */
++#define DUK_STRIDX_JSON_EXT_POSINF                                    25                             /* '{"_inf":true}' */
++#define DUK_STRIDX_JSON_EXT_NAN                                       26                             /* '{"_nan":true}' */
++#define DUK_STRIDX_JSON_EXT_UNDEFINED                                 27                             /* '{"_undef":true}' */
++#define DUK_STRIDX_TO_LOG_STRING                                      28                             /* 'toLogString' */
++#define DUK_STRIDX_CLOG                                               29                             /* 'clog' */
++#define DUK_STRIDX_LC_L                                               30                             /* 'l' */
++#define DUK_STRIDX_LC_N                                               31                             /* 'n' */
++#define DUK_STRIDX_LC_FATAL                                           32                             /* 'fatal' */
++#define DUK_STRIDX_LC_ERROR                                           33                             /* 'error' */
++#define DUK_STRIDX_LC_WARN                                            34                             /* 'warn' */
++#define DUK_STRIDX_LC_DEBUG                                           35                             /* 'debug' */
++#define DUK_STRIDX_LC_TRACE                                           36                             /* 'trace' */
++#define DUK_STRIDX_RAW                                                37                             /* 'raw' */
++#define DUK_STRIDX_FMT                                                38                             /* 'fmt' */
++#define DUK_STRIDX_CURRENT                                            39                             /* 'current' */
++#define DUK_STRIDX_RESUME                                             40                             /* 'resume' */
++#define DUK_STRIDX_COMPACT                                            41                             /* 'compact' */
++#define DUK_STRIDX_JC                                                 42                             /* 'jc' */
++#define DUK_STRIDX_JX                                                 43                             /* 'jx' */
++#define DUK_STRIDX_BASE64                                             44                             /* 'base64' */
++#define DUK_STRIDX_HEX                                                45                             /* 'hex' */
++#define DUK_STRIDX_DEC                                                46                             /* 'dec' */
++#define DUK_STRIDX_ENC                                                47                             /* 'enc' */
++#define DUK_STRIDX_FIN                                                48                             /* 'fin' */
++#define DUK_STRIDX_GC                                                 49                             /* 'gc' */
++#define DUK_STRIDX_ACT                                                50                             /* 'act' */
++#define DUK_STRIDX_LC_INFO                                            51                             /* 'info' */
++#define DUK_STRIDX_VERSION                                            52                             /* 'version' */
++#define DUK_STRIDX_ENV                                                53                             /* 'env' */
++#define DUK_STRIDX_MOD_LOADED                                         54                             /* 'modLoaded' */
++#define DUK_STRIDX_MOD_SEARCH                                         55                             /* 'modSearch' */
++#define DUK_STRIDX_ERR_THROW                                          56                             /* 'errThrow' */
++#define DUK_STRIDX_ERR_CREATE                                         57                             /* 'errCreate' */
++#define DUK_STRIDX_COMPILE                                            58                             /* 'compile' */
++#define DUK_STRIDX_INT_REGBASE                                        59                             /* '\x00Regbase' */
++#define DUK_STRIDX_INT_THREAD                                         60                             /* '\x00Thread' */
++#define DUK_STRIDX_INT_HANDLER                                        61                             /* '\x00Handler' */
++#define DUK_STRIDX_INT_FINALIZER                                      62                             /* '\x00Finalizer' */
++#define DUK_STRIDX_INT_CALLEE                                         63                             /* '\x00Callee' */
++#define DUK_STRIDX_INT_MAP                                            64                             /* '\x00Map' */
++#define DUK_STRIDX_INT_ARGS                                           65                             /* '\x00Args' */
++#define DUK_STRIDX_INT_THIS                                           66                             /* '\x00This' */
++#define DUK_STRIDX_INT_PC2LINE                                        67                             /* '\x00Pc2line' */
++#define DUK_STRIDX_INT_SOURCE                                         68                             /* '\x00Source' */
++#define DUK_STRIDX_INT_VARENV                                         69                             /* '\x00Varenv' */
++#define DUK_STRIDX_INT_LEXENV                                         70                             /* '\x00Lexenv' */
++#define DUK_STRIDX_INT_VARMAP                                         71                             /* '\x00Varmap' */
++#define DUK_STRIDX_INT_FORMALS                                        72                             /* '\x00Formals' */
++#define DUK_STRIDX_INT_BYTECODE                                       73                             /* '\x00Bytecode' */
++#define DUK_STRIDX_INT_NEXT                                           74                             /* '\x00Next' */
++#define DUK_STRIDX_INT_TARGET                                         75                             /* '\x00Target' */
++#define DUK_STRIDX_INT_VALUE                                          76                             /* '\x00Value' */
++#define DUK_STRIDX_LC_POINTER                                         77                             /* 'pointer' */
++#define DUK_STRIDX_LC_BUFFER                                          78                             /* 'buffer' */
++#define DUK_STRIDX_INT_TRACEDATA                                      79                             /* '\x00Tracedata' */
++#define DUK_STRIDX_LINE_NUMBER                                        80                             /* 'lineNumber' */
++#define DUK_STRIDX_FILE_NAME                                          81                             /* 'fileName' */
++#define DUK_STRIDX_PC                                                 82                             /* 'pc' */
++#define DUK_STRIDX_STACK                                              83                             /* 'stack' */
++#define DUK_STRIDX_THROW_TYPE_ERROR                                   84                             /* 'ThrowTypeError' */
++#define DUK_STRIDX_DUKTAPE                                            85                             /* 'Duktape' */
++#define DUK_STRIDX_ID                                                 86                             /* 'id' */
++#define DUK_STRIDX_REQUIRE                                            87                             /* 'require' */
++#define DUK_STRIDX___PROTO__                                          88                             /* '__proto__' */
++#define DUK_STRIDX_SET_PROTOTYPE_OF                                   89                             /* 'setPrototypeOf' */
++#define DUK_STRIDX_OWN_KEYS                                           90                             /* 'ownKeys' */
++#define DUK_STRIDX_ENUMERATE                                          91                             /* 'enumerate' */
++#define DUK_STRIDX_DELETE_PROPERTY                                    92                             /* 'deleteProperty' */
++#define DUK_STRIDX_HAS                                                93                             /* 'has' */
++#define DUK_STRIDX_PROXY                                              94                             /* 'Proxy' */
++#define DUK_STRIDX_CALLEE                                             95                             /* 'callee' */
++#define DUK_STRIDX_INVALID_DATE                                       96                             /* 'Invalid Date' */
++#define DUK_STRIDX_BRACKETED_ELLIPSIS                                 97                             /* '[...]' */
++#define DUK_STRIDX_NEWLINE_TAB                                        98                             /* '\n\t' */
++#define DUK_STRIDX_SPACE                                              99                             /* ' ' */
++#define DUK_STRIDX_COMMA                                              100                            /* ',' */
++#define DUK_STRIDX_MINUS_ZERO                                         101                            /* '-0' */
++#define DUK_STRIDX_PLUS_ZERO                                          102                            /* '+0' */
++#define DUK_STRIDX_ZERO                                               103                            /* '0' */
++#define DUK_STRIDX_MINUS_INFINITY                                     104                            /* '-Infinity' */
++#define DUK_STRIDX_PLUS_INFINITY                                      105                            /* '+Infinity' */
++#define DUK_STRIDX_INFINITY                                           106                            /* 'Infinity' */
++#define DUK_STRIDX_LC_OBJECT                                          107                            /* 'object' */
++#define DUK_STRIDX_LC_STRING                                          108                            /* 'string' */
++#define DUK_STRIDX_LC_NUMBER                                          109                            /* 'number' */
++#define DUK_STRIDX_LC_BOOLEAN                                         110                            /* 'boolean' */
++#define DUK_STRIDX_LC_UNDEFINED                                       111                            /* 'undefined' */
++#define DUK_STRIDX_STRINGIFY                                          112                            /* 'stringify' */
++#define DUK_STRIDX_TAN                                                113                            /* 'tan' */
++#define DUK_STRIDX_SQRT                                               114                            /* 'sqrt' */
++#define DUK_STRIDX_SIN                                                115                            /* 'sin' */
++#define DUK_STRIDX_ROUND                                              116                            /* 'round' */
++#define DUK_STRIDX_RANDOM                                             117                            /* 'random' */
++#define DUK_STRIDX_POW                                                118                            /* 'pow' */
++#define DUK_STRIDX_MIN                                                119                            /* 'min' */
++#define DUK_STRIDX_MAX                                                120                            /* 'max' */
++#define DUK_STRIDX_LOG                                                121                            /* 'log' */
++#define DUK_STRIDX_FLOOR                                              122                            /* 'floor' */
++#define DUK_STRIDX_EXP                                                123                            /* 'exp' */
++#define DUK_STRIDX_COS                                                124                            /* 'cos' */
++#define DUK_STRIDX_CEIL                                               125                            /* 'ceil' */
++#define DUK_STRIDX_ATAN2                                              126                            /* 'atan2' */
++#define DUK_STRIDX_ATAN                                               127                            /* 'atan' */
++#define DUK_STRIDX_ASIN                                               128                            /* 'asin' */
++#define DUK_STRIDX_ACOS                                               129                            /* 'acos' */
++#define DUK_STRIDX_ABS                                                130                            /* 'abs' */
++#define DUK_STRIDX_SQRT2                                              131                            /* 'SQRT2' */
++#define DUK_STRIDX_SQRT1_2                                            132                            /* 'SQRT1_2' */
++#define DUK_STRIDX_PI                                                 133                            /* 'PI' */
++#define DUK_STRIDX_LOG10E                                             134                            /* 'LOG10E' */
++#define DUK_STRIDX_LOG2E                                              135                            /* 'LOG2E' */
++#define DUK_STRIDX_LN2                                                136                            /* 'LN2' */
++#define DUK_STRIDX_LN10                                               137                            /* 'LN10' */
++#define DUK_STRIDX_E                                                  138                            /* 'E' */
++#define DUK_STRIDX_MESSAGE                                            139                            /* 'message' */
++#define DUK_STRIDX_NAME                                               140                            /* 'name' */
++#define DUK_STRIDX_INPUT                                              141                            /* 'input' */
++#define DUK_STRIDX_INDEX                                              142                            /* 'index' */
++#define DUK_STRIDX_ESCAPED_EMPTY_REGEXP                               143                            /* '(?:)' */
++#define DUK_STRIDX_LAST_INDEX                                         144                            /* 'lastIndex' */
++#define DUK_STRIDX_MULTILINE                                          145                            /* 'multiline' */
++#define DUK_STRIDX_IGNORE_CASE                                        146                            /* 'ignoreCase' */
++#define DUK_STRIDX_SOURCE                                             147                            /* 'source' */
++#define DUK_STRIDX_TEST                                               148                            /* 'test' */
++#define DUK_STRIDX_EXEC                                               149                            /* 'exec' */
++#define DUK_STRIDX_TO_GMT_STRING                                      150                            /* 'toGMTString' */
++#define DUK_STRIDX_SET_YEAR                                           151                            /* 'setYear' */
++#define DUK_STRIDX_GET_YEAR                                           152                            /* 'getYear' */
++#define DUK_STRIDX_TO_JSON                                            153                            /* 'toJSON' */
++#define DUK_STRIDX_TO_ISO_STRING                                      154                            /* 'toISOString' */
++#define DUK_STRIDX_TO_UTC_STRING                                      155                            /* 'toUTCString' */
++#define DUK_STRIDX_SET_UTC_FULL_YEAR                                  156                            /* 'setUTCFullYear' */
++#define DUK_STRIDX_SET_FULL_YEAR                                      157                            /* 'setFullYear' */
++#define DUK_STRIDX_SET_UTC_MONTH                                      158                            /* 'setUTCMonth' */
++#define DUK_STRIDX_SET_MONTH                                          159                            /* 'setMonth' */
++#define DUK_STRIDX_SET_UTC_DATE                                       160                            /* 'setUTCDate' */
++#define DUK_STRIDX_SET_DATE                                           161                            /* 'setDate' */
++#define DUK_STRIDX_SET_UTC_HOURS                                      162                            /* 'setUTCHours' */
++#define DUK_STRIDX_SET_HOURS                                          163                            /* 'setHours' */
++#define DUK_STRIDX_SET_UTC_MINUTES                                    164                            /* 'setUTCMinutes' */
++#define DUK_STRIDX_SET_MINUTES                                        165                            /* 'setMinutes' */
++#define DUK_STRIDX_SET_UTC_SECONDS                                    166                            /* 'setUTCSeconds' */
++#define DUK_STRIDX_SET_SECONDS                                        167                            /* 'setSeconds' */
++#define DUK_STRIDX_SET_UTC_MILLISECONDS                               168                            /* 'setUTCMilliseconds' */
++#define DUK_STRIDX_SET_MILLISECONDS                                   169                            /* 'setMilliseconds' */
++#define DUK_STRIDX_SET_TIME                                           170                            /* 'setTime' */
++#define DUK_STRIDX_GET_TIMEZONE_OFFSET                                171                            /* 'getTimezoneOffset' */
++#define DUK_STRIDX_GET_UTC_MILLISECONDS                               172                            /* 'getUTCMilliseconds' */
++#define DUK_STRIDX_GET_MILLISECONDS                                   173                            /* 'getMilliseconds' */
++#define DUK_STRIDX_GET_UTC_SECONDS                                    174                            /* 'getUTCSeconds' */
++#define DUK_STRIDX_GET_SECONDS                                        175                            /* 'getSeconds' */
++#define DUK_STRIDX_GET_UTC_MINUTES                                    176                            /* 'getUTCMinutes' */
++#define DUK_STRIDX_GET_MINUTES                                        177                            /* 'getMinutes' */
++#define DUK_STRIDX_GET_UTC_HOURS                                      178                            /* 'getUTCHours' */
++#define DUK_STRIDX_GET_HOURS                                          179                            /* 'getHours' */
++#define DUK_STRIDX_GET_UTC_DAY                                        180                            /* 'getUTCDay' */
++#define DUK_STRIDX_GET_DAY                                            181                            /* 'getDay' */
++#define DUK_STRIDX_GET_UTC_DATE                                       182                            /* 'getUTCDate' */
++#define DUK_STRIDX_GET_DATE                                           183                            /* 'getDate' */
++#define DUK_STRIDX_GET_UTC_MONTH                                      184                            /* 'getUTCMonth' */
++#define DUK_STRIDX_GET_MONTH                                          185                            /* 'getMonth' */
++#define DUK_STRIDX_GET_UTC_FULL_YEAR                                  186                            /* 'getUTCFullYear' */
++#define DUK_STRIDX_GET_FULL_YEAR                                      187                            /* 'getFullYear' */
++#define DUK_STRIDX_GET_TIME                                           188                            /* 'getTime' */
++#define DUK_STRIDX_TO_LOCALE_TIME_STRING                              189                            /* 'toLocaleTimeString' */
++#define DUK_STRIDX_TO_LOCALE_DATE_STRING                              190                            /* 'toLocaleDateString' */
++#define DUK_STRIDX_TO_TIME_STRING                                     191                            /* 'toTimeString' */
++#define DUK_STRIDX_TO_DATE_STRING                                     192                            /* 'toDateString' */
++#define DUK_STRIDX_NOW                                                193                            /* 'now' */
++#define DUK_STRIDX_UTC                                                194                            /* 'UTC' */
++#define DUK_STRIDX_PARSE                                              195                            /* 'parse' */
++#define DUK_STRIDX_TO_PRECISION                                       196                            /* 'toPrecision' */
++#define DUK_STRIDX_TO_EXPONENTIAL                                     197                            /* 'toExponential' */
++#define DUK_STRIDX_TO_FIXED                                           198                            /* 'toFixed' */
++#define DUK_STRIDX_POSITIVE_INFINITY                                  199                            /* 'POSITIVE_INFINITY' */
++#define DUK_STRIDX_NEGATIVE_INFINITY                                  200                            /* 'NEGATIVE_INFINITY' */
++#define DUK_STRIDX_NAN                                                201                            /* 'NaN' */
++#define DUK_STRIDX_MIN_VALUE                                          202                            /* 'MIN_VALUE' */
++#define DUK_STRIDX_MAX_VALUE                                          203                            /* 'MAX_VALUE' */
++#define DUK_STRIDX_SUBSTR                                             204                            /* 'substr' */
++#define DUK_STRIDX_TRIM                                               205                            /* 'trim' */
++#define DUK_STRIDX_TO_LOCALE_UPPER_CASE                               206                            /* 'toLocaleUpperCase' */
++#define DUK_STRIDX_TO_UPPER_CASE                                      207                            /* 'toUpperCase' */
++#define DUK_STRIDX_TO_LOCALE_LOWER_CASE                               208                            /* 'toLocaleLowerCase' */
++#define DUK_STRIDX_TO_LOWER_CASE                                      209                            /* 'toLowerCase' */
++#define DUK_STRIDX_SUBSTRING                                          210                            /* 'substring' */
++#define DUK_STRIDX_SPLIT                                              211                            /* 'split' */
++#define DUK_STRIDX_SEARCH                                             212                            /* 'search' */
++#define DUK_STRIDX_REPLACE                                            213                            /* 'replace' */
++#define DUK_STRIDX_MATCH                                              214                            /* 'match' */
++#define DUK_STRIDX_LOCALE_COMPARE                                     215                            /* 'localeCompare' */
++#define DUK_STRIDX_CHAR_CODE_AT                                       216                            /* 'charCodeAt' */
++#define DUK_STRIDX_CHAR_AT                                            217                            /* 'charAt' */
++#define DUK_STRIDX_FROM_CHAR_CODE                                     218                            /* 'fromCharCode' */
++#define DUK_STRIDX_REDUCE_RIGHT                                       219                            /* 'reduceRight' */
++#define DUK_STRIDX_REDUCE                                             220                            /* 'reduce' */
++#define DUK_STRIDX_FILTER                                             221                            /* 'filter' */
++#define DUK_STRIDX_MAP                                                222                            /* 'map' */
++#define DUK_STRIDX_FOR_EACH                                           223                            /* 'forEach' */
++#define DUK_STRIDX_SOME                                               224                            /* 'some' */
++#define DUK_STRIDX_EVERY                                              225                            /* 'every' */
++#define DUK_STRIDX_LAST_INDEX_OF                                      226                            /* 'lastIndexOf' */
++#define DUK_STRIDX_INDEX_OF                                           227                            /* 'indexOf' */
++#define DUK_STRIDX_UNSHIFT                                            228                            /* 'unshift' */
++#define DUK_STRIDX_SPLICE                                             229                            /* 'splice' */
++#define DUK_STRIDX_SORT                                               230                            /* 'sort' */
++#define DUK_STRIDX_SLICE                                              231                            /* 'slice' */
++#define DUK_STRIDX_SHIFT                                              232                            /* 'shift' */
++#define DUK_STRIDX_REVERSE                                            233                            /* 'reverse' */
++#define DUK_STRIDX_PUSH                                               234                            /* 'push' */
++#define DUK_STRIDX_POP                                                235                            /* 'pop' */
++#define DUK_STRIDX_JOIN                                               236                            /* 'join' */
++#define DUK_STRIDX_CONCAT                                             237                            /* 'concat' */
++#define DUK_STRIDX_IS_ARRAY                                           238                            /* 'isArray' */
++#define DUK_STRIDX_LC_ARGUMENTS                                       239                            /* 'arguments' */
++#define DUK_STRIDX_CALLER                                             240                            /* 'caller' */
++#define DUK_STRIDX_BIND                                               241                            /* 'bind' */
++#define DUK_STRIDX_CALL                                               242                            /* 'call' */
++#define DUK_STRIDX_APPLY                                              243                            /* 'apply' */
++#define DUK_STRIDX_PROPERTY_IS_ENUMERABLE                             244                            /* 'propertyIsEnumerable' */
++#define DUK_STRIDX_IS_PROTOTYPE_OF                                    245                            /* 'isPrototypeOf' */
++#define DUK_STRIDX_HAS_OWN_PROPERTY                                   246                            /* 'hasOwnProperty' */
++#define DUK_STRIDX_VALUE_OF                                           247                            /* 'valueOf' */
++#define DUK_STRIDX_TO_LOCALE_STRING                                   248                            /* 'toLocaleString' */
++#define DUK_STRIDX_TO_STRING                                          249                            /* 'toString' */
++#define DUK_STRIDX_CONSTRUCTOR                                        250                            /* 'constructor' */
++#define DUK_STRIDX_SET                                                251                            /* 'set' */
++#define DUK_STRIDX_GET                                                252                            /* 'get' */
++#define DUK_STRIDX_ENUMERABLE                                         253                            /* 'enumerable' */
++#define DUK_STRIDX_CONFIGURABLE                                       254                            /* 'configurable' */
++#define DUK_STRIDX_WRITABLE                                           255                            /* 'writable' */
++#define DUK_STRIDX_VALUE                                              256                            /* 'value' */
++#define DUK_STRIDX_KEYS                                               257                            /* 'keys' */
++#define DUK_STRIDX_IS_EXTENSIBLE                                      258                            /* 'isExtensible' */
++#define DUK_STRIDX_IS_FROZEN                                          259                            /* 'isFrozen' */
++#define DUK_STRIDX_IS_SEALED                                          260                            /* 'isSealed' */
++#define DUK_STRIDX_PREVENT_EXTENSIONS                                 261                            /* 'preventExtensions' */
++#define DUK_STRIDX_FREEZE                                             262                            /* 'freeze' */
++#define DUK_STRIDX_SEAL                                               263                            /* 'seal' */
++#define DUK_STRIDX_DEFINE_PROPERTIES                                  264                            /* 'defineProperties' */
++#define DUK_STRIDX_DEFINE_PROPERTY                                    265                            /* 'defineProperty' */
++#define DUK_STRIDX_CREATE                                             266                            /* 'create' */
++#define DUK_STRIDX_GET_OWN_PROPERTY_NAMES                             267                            /* 'getOwnPropertyNames' */
++#define DUK_STRIDX_GET_OWN_PROPERTY_DESCRIPTOR                        268                            /* 'getOwnPropertyDescriptor' */
++#define DUK_STRIDX_GET_PROTOTYPE_OF                                   269                            /* 'getPrototypeOf' */
++#define DUK_STRIDX_PROTOTYPE                                          270                            /* 'prototype' */
++#define DUK_STRIDX_LENGTH                                             271                            /* 'length' */
++#define DUK_STRIDX_ALERT                                              272                            /* 'alert' */
++#define DUK_STRIDX_PRINT                                              273                            /* 'print' */
++#define DUK_STRIDX_UNESCAPE                                           274                            /* 'unescape' */
++#define DUK_STRIDX_ESCAPE                                             275                            /* 'escape' */
++#define DUK_STRIDX_ENCODE_URI_COMPONENT                               276                            /* 'encodeURIComponent' */
++#define DUK_STRIDX_ENCODE_URI                                         277                            /* 'encodeURI' */
++#define DUK_STRIDX_DECODE_URI_COMPONENT                               278                            /* 'decodeURIComponent' */
++#define DUK_STRIDX_DECODE_URI                                         279                            /* 'decodeURI' */
++#define DUK_STRIDX_IS_FINITE                                          280                            /* 'isFinite' */
++#define DUK_STRIDX_IS_NAN                                             281                            /* 'isNaN' */
++#define DUK_STRIDX_PARSE_FLOAT                                        282                            /* 'parseFloat' */
++#define DUK_STRIDX_PARSE_INT                                          283                            /* 'parseInt' */
++#define DUK_STRIDX_EVAL                                               284                            /* 'eval' */
++#define DUK_STRIDX_URI_ERROR                                          285                            /* 'URIError' */
++#define DUK_STRIDX_TYPE_ERROR                                         286                            /* 'TypeError' */
++#define DUK_STRIDX_SYNTAX_ERROR                                       287                            /* 'SyntaxError' */
++#define DUK_STRIDX_REFERENCE_ERROR                                    288                            /* 'ReferenceError' */
++#define DUK_STRIDX_RANGE_ERROR                                        289                            /* 'RangeError' */
++#define DUK_STRIDX_EVAL_ERROR                                         290                            /* 'EvalError' */
++#define DUK_STRIDX_BREAK                                              291                            /* 'break' */
++#define DUK_STRIDX_CASE                                               292                            /* 'case' */
++#define DUK_STRIDX_CATCH                                              293                            /* 'catch' */
++#define DUK_STRIDX_CONTINUE                                           294                            /* 'continue' */
++#define DUK_STRIDX_DEBUGGER                                           295                            /* 'debugger' */
++#define DUK_STRIDX_DEFAULT                                            296                            /* 'default' */
++#define DUK_STRIDX_DELETE                                             297                            /* 'delete' */
++#define DUK_STRIDX_DO                                                 298                            /* 'do' */
++#define DUK_STRIDX_ELSE                                               299                            /* 'else' */
++#define DUK_STRIDX_FINALLY                                            300                            /* 'finally' */
++#define DUK_STRIDX_FOR                                                301                            /* 'for' */
++#define DUK_STRIDX_LC_FUNCTION                                        302                            /* 'function' */
++#define DUK_STRIDX_IF                                                 303                            /* 'if' */
++#define DUK_STRIDX_IN                                                 304                            /* 'in' */
++#define DUK_STRIDX_INSTANCEOF                                         305                            /* 'instanceof' */
++#define DUK_STRIDX_NEW                                                306                            /* 'new' */
++#define DUK_STRIDX_RETURN                                             307                            /* 'return' */
++#define DUK_STRIDX_SWITCH                                             308                            /* 'switch' */
++#define DUK_STRIDX_THIS                                               309                            /* 'this' */
++#define DUK_STRIDX_THROW                                              310                            /* 'throw' */
++#define DUK_STRIDX_TRY                                                311                            /* 'try' */
++#define DUK_STRIDX_TYPEOF                                             312                            /* 'typeof' */
++#define DUK_STRIDX_VAR                                                313                            /* 'var' */
++#define DUK_STRIDX_VOID                                               314                            /* 'void' */
++#define DUK_STRIDX_WHILE                                              315                            /* 'while' */
++#define DUK_STRIDX_WITH                                               316                            /* 'with' */
++#define DUK_STRIDX_CLASS                                              317                            /* 'class' */
++#define DUK_STRIDX_CONST                                              318                            /* 'const' */
++#define DUK_STRIDX_ENUM                                               319                            /* 'enum' */
++#define DUK_STRIDX_EXPORT                                             320                            /* 'export' */
++#define DUK_STRIDX_EXTENDS                                            321                            /* 'extends' */
++#define DUK_STRIDX_IMPORT                                             322                            /* 'import' */
++#define DUK_STRIDX_SUPER                                              323                            /* 'super' */
++#define DUK_STRIDX_LC_NULL                                            324                            /* 'null' */
++#define DUK_STRIDX_TRUE                                               325                            /* 'true' */
++#define DUK_STRIDX_FALSE                                              326                            /* 'false' */
++#define DUK_STRIDX_IMPLEMENTS                                         327                            /* 'implements' */
++#define DUK_STRIDX_INTERFACE                                          328                            /* 'interface' */
++#define DUK_STRIDX_LET                                                329                            /* 'let' */
++#define DUK_STRIDX_PACKAGE                                            330                            /* 'package' */
++#define DUK_STRIDX_PRIVATE                                            331                            /* 'private' */
++#define DUK_STRIDX_PROTECTED                                          332                            /* 'protected' */
++#define DUK_STRIDX_PUBLIC                                             333                            /* 'public' */
++#define DUK_STRIDX_STATIC                                             334                            /* 'static' */
++#define DUK_STRIDX_YIELD                                              335                            /* 'yield' */
++
++#define DUK_HEAP_STRING_UC_LOGGER(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_LOGGER)
++#define DUK_HTHREAD_STRING_UC_LOGGER(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_LOGGER)
++#define DUK_HEAP_STRING_UC_THREAD(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_THREAD)
++#define DUK_HTHREAD_STRING_UC_THREAD(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_THREAD)
++#define DUK_HEAP_STRING_UC_POINTER(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_POINTER)
++#define DUK_HTHREAD_STRING_UC_POINTER(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_POINTER)
++#define DUK_HEAP_STRING_UC_BUFFER(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_BUFFER)
++#define DUK_HTHREAD_STRING_UC_BUFFER(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_BUFFER)
++#define DUK_HEAP_STRING_DEC_ENV(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEC_ENV)
++#define DUK_HTHREAD_STRING_DEC_ENV(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEC_ENV)
++#define DUK_HEAP_STRING_OBJ_ENV(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_OBJ_ENV)
++#define DUK_HTHREAD_STRING_OBJ_ENV(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_OBJ_ENV)
++#define DUK_HEAP_STRING_EMPTY_STRING(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EMPTY_STRING)
++#define DUK_HTHREAD_STRING_EMPTY_STRING(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EMPTY_STRING)
++#define DUK_HEAP_STRING_GLOBAL(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GLOBAL)
++#define DUK_HTHREAD_STRING_GLOBAL(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GLOBAL)
++#define DUK_HEAP_STRING_UC_ARGUMENTS(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_ARGUMENTS)
++#define DUK_HTHREAD_STRING_UC_ARGUMENTS(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_ARGUMENTS)
++#define DUK_HEAP_STRING_JSON(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON)
++#define DUK_HTHREAD_STRING_JSON(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON)
++#define DUK_HEAP_STRING_MATH(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MATH)
++#define DUK_HTHREAD_STRING_MATH(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MATH)
++#define DUK_HEAP_STRING_UC_ERROR(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_ERROR)
++#define DUK_HTHREAD_STRING_UC_ERROR(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_ERROR)
++#define DUK_HEAP_STRING_REG_EXP(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REG_EXP)
++#define DUK_HTHREAD_STRING_REG_EXP(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REG_EXP)
++#define DUK_HEAP_STRING_DATE(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DATE)
++#define DUK_HTHREAD_STRING_DATE(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DATE)
++#define DUK_HEAP_STRING_UC_NUMBER(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_NUMBER)
++#define DUK_HTHREAD_STRING_UC_NUMBER(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_NUMBER)
++#define DUK_HEAP_STRING_UC_BOOLEAN(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_BOOLEAN)
++#define DUK_HTHREAD_STRING_UC_BOOLEAN(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_BOOLEAN)
++#define DUK_HEAP_STRING_UC_STRING(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_STRING)
++#define DUK_HTHREAD_STRING_UC_STRING(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_STRING)
++#define DUK_HEAP_STRING_ARRAY(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ARRAY)
++#define DUK_HTHREAD_STRING_ARRAY(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ARRAY)
++#define DUK_HEAP_STRING_UC_FUNCTION(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_FUNCTION)
++#define DUK_HTHREAD_STRING_UC_FUNCTION(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_FUNCTION)
++#define DUK_HEAP_STRING_UC_OBJECT(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_OBJECT)
++#define DUK_HTHREAD_STRING_UC_OBJECT(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_OBJECT)
++#define DUK_HEAP_STRING_UC_NULL(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_NULL)
++#define DUK_HTHREAD_STRING_UC_NULL(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_NULL)
++#define DUK_HEAP_STRING_UC_UNDEFINED(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UC_UNDEFINED)
++#define DUK_HTHREAD_STRING_UC_UNDEFINED(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UC_UNDEFINED)
++#define DUK_HEAP_STRING_JSON_EXT_FUNCTION2(heap)                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_FUNCTION2)
++#define DUK_HTHREAD_STRING_JSON_EXT_FUNCTION2(thr)                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_FUNCTION2)
++#define DUK_HEAP_STRING_JSON_EXT_FUNCTION1(heap)                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_FUNCTION1)
++#define DUK_HTHREAD_STRING_JSON_EXT_FUNCTION1(thr)                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_FUNCTION1)
++#define DUK_HEAP_STRING_JSON_EXT_NEGINF(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_NEGINF)
++#define DUK_HTHREAD_STRING_JSON_EXT_NEGINF(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_NEGINF)
++#define DUK_HEAP_STRING_JSON_EXT_POSINF(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_POSINF)
++#define DUK_HTHREAD_STRING_JSON_EXT_POSINF(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_POSINF)
++#define DUK_HEAP_STRING_JSON_EXT_NAN(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_NAN)
++#define DUK_HTHREAD_STRING_JSON_EXT_NAN(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_NAN)
++#define DUK_HEAP_STRING_JSON_EXT_UNDEFINED(heap)                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JSON_EXT_UNDEFINED)
++#define DUK_HTHREAD_STRING_JSON_EXT_UNDEFINED(thr)                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JSON_EXT_UNDEFINED)
++#define DUK_HEAP_STRING_TO_LOG_STRING(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOG_STRING)
++#define DUK_HTHREAD_STRING_TO_LOG_STRING(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOG_STRING)
++#define DUK_HEAP_STRING_CLOG(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CLOG)
++#define DUK_HTHREAD_STRING_CLOG(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CLOG)
++#define DUK_HEAP_STRING_LC_L(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_L)
++#define DUK_HTHREAD_STRING_LC_L(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_L)
++#define DUK_HEAP_STRING_LC_N(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_N)
++#define DUK_HTHREAD_STRING_LC_N(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_N)
++#define DUK_HEAP_STRING_LC_FATAL(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_FATAL)
++#define DUK_HTHREAD_STRING_LC_FATAL(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_FATAL)
++#define DUK_HEAP_STRING_LC_ERROR(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_ERROR)
++#define DUK_HTHREAD_STRING_LC_ERROR(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_ERROR)
++#define DUK_HEAP_STRING_LC_WARN(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_WARN)
++#define DUK_HTHREAD_STRING_LC_WARN(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_WARN)
++#define DUK_HEAP_STRING_LC_DEBUG(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_DEBUG)
++#define DUK_HTHREAD_STRING_LC_DEBUG(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_DEBUG)
++#define DUK_HEAP_STRING_LC_TRACE(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_TRACE)
++#define DUK_HTHREAD_STRING_LC_TRACE(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_TRACE)
++#define DUK_HEAP_STRING_RAW(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RAW)
++#define DUK_HTHREAD_STRING_RAW(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RAW)
++#define DUK_HEAP_STRING_FMT(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FMT)
++#define DUK_HTHREAD_STRING_FMT(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FMT)
++#define DUK_HEAP_STRING_CURRENT(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CURRENT)
++#define DUK_HTHREAD_STRING_CURRENT(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CURRENT)
++#define DUK_HEAP_STRING_RESUME(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RESUME)
++#define DUK_HTHREAD_STRING_RESUME(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RESUME)
++#define DUK_HEAP_STRING_COMPACT(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COMPACT)
++#define DUK_HTHREAD_STRING_COMPACT(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COMPACT)
++#define DUK_HEAP_STRING_JC(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JC)
++#define DUK_HTHREAD_STRING_JC(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JC)
++#define DUK_HEAP_STRING_JX(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JX)
++#define DUK_HTHREAD_STRING_JX(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JX)
++#define DUK_HEAP_STRING_BASE64(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BASE64)
++#define DUK_HTHREAD_STRING_BASE64(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BASE64)
++#define DUK_HEAP_STRING_HEX(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_HEX)
++#define DUK_HTHREAD_STRING_HEX(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_HEX)
++#define DUK_HEAP_STRING_DEC(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEC)
++#define DUK_HTHREAD_STRING_DEC(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEC)
++#define DUK_HEAP_STRING_ENC(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENC)
++#define DUK_HTHREAD_STRING_ENC(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENC)
++#define DUK_HEAP_STRING_FIN(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FIN)
++#define DUK_HTHREAD_STRING_FIN(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FIN)
++#define DUK_HEAP_STRING_GC(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GC)
++#define DUK_HTHREAD_STRING_GC(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GC)
++#define DUK_HEAP_STRING_ACT(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ACT)
++#define DUK_HTHREAD_STRING_ACT(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ACT)
++#define DUK_HEAP_STRING_LC_INFO(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_INFO)
++#define DUK_HTHREAD_STRING_LC_INFO(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_INFO)
++#define DUK_HEAP_STRING_VERSION(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VERSION)
++#define DUK_HTHREAD_STRING_VERSION(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VERSION)
++#define DUK_HEAP_STRING_ENV(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENV)
++#define DUK_HTHREAD_STRING_ENV(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENV)
++#define DUK_HEAP_STRING_MOD_LOADED(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MOD_LOADED)
++#define DUK_HTHREAD_STRING_MOD_LOADED(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MOD_LOADED)
++#define DUK_HEAP_STRING_MOD_SEARCH(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MOD_SEARCH)
++#define DUK_HTHREAD_STRING_MOD_SEARCH(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MOD_SEARCH)
++#define DUK_HEAP_STRING_ERR_THROW(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ERR_THROW)
++#define DUK_HTHREAD_STRING_ERR_THROW(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ERR_THROW)
++#define DUK_HEAP_STRING_ERR_CREATE(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ERR_CREATE)
++#define DUK_HTHREAD_STRING_ERR_CREATE(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ERR_CREATE)
++#define DUK_HEAP_STRING_COMPILE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COMPILE)
++#define DUK_HTHREAD_STRING_COMPILE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COMPILE)
++#define DUK_HEAP_STRING_INT_REGBASE(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_REGBASE)
++#define DUK_HTHREAD_STRING_INT_REGBASE(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_REGBASE)
++#define DUK_HEAP_STRING_INT_THREAD(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_THREAD)
++#define DUK_HTHREAD_STRING_INT_THREAD(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_THREAD)
++#define DUK_HEAP_STRING_INT_HANDLER(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_HANDLER)
++#define DUK_HTHREAD_STRING_INT_HANDLER(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_HANDLER)
++#define DUK_HEAP_STRING_INT_FINALIZER(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_FINALIZER)
++#define DUK_HTHREAD_STRING_INT_FINALIZER(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_FINALIZER)
++#define DUK_HEAP_STRING_INT_CALLEE(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_CALLEE)
++#define DUK_HTHREAD_STRING_INT_CALLEE(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_CALLEE)
++#define DUK_HEAP_STRING_INT_MAP(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_MAP)
++#define DUK_HTHREAD_STRING_INT_MAP(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_MAP)
++#define DUK_HEAP_STRING_INT_ARGS(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_ARGS)
++#define DUK_HTHREAD_STRING_INT_ARGS(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_ARGS)
++#define DUK_HEAP_STRING_INT_THIS(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_THIS)
++#define DUK_HTHREAD_STRING_INT_THIS(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_THIS)
++#define DUK_HEAP_STRING_INT_PC2LINE(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_PC2LINE)
++#define DUK_HTHREAD_STRING_INT_PC2LINE(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_PC2LINE)
++#define DUK_HEAP_STRING_INT_SOURCE(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_SOURCE)
++#define DUK_HTHREAD_STRING_INT_SOURCE(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_SOURCE)
++#define DUK_HEAP_STRING_INT_VARENV(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_VARENV)
++#define DUK_HTHREAD_STRING_INT_VARENV(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_VARENV)
++#define DUK_HEAP_STRING_INT_LEXENV(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_LEXENV)
++#define DUK_HTHREAD_STRING_INT_LEXENV(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_LEXENV)
++#define DUK_HEAP_STRING_INT_VARMAP(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_VARMAP)
++#define DUK_HTHREAD_STRING_INT_VARMAP(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_VARMAP)
++#define DUK_HEAP_STRING_INT_FORMALS(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_FORMALS)
++#define DUK_HTHREAD_STRING_INT_FORMALS(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_FORMALS)
++#define DUK_HEAP_STRING_INT_BYTECODE(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_BYTECODE)
++#define DUK_HTHREAD_STRING_INT_BYTECODE(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_BYTECODE)
++#define DUK_HEAP_STRING_INT_NEXT(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_NEXT)
++#define DUK_HTHREAD_STRING_INT_NEXT(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_NEXT)
++#define DUK_HEAP_STRING_INT_TARGET(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_TARGET)
++#define DUK_HTHREAD_STRING_INT_TARGET(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_TARGET)
++#define DUK_HEAP_STRING_INT_VALUE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_VALUE)
++#define DUK_HTHREAD_STRING_INT_VALUE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_VALUE)
++#define DUK_HEAP_STRING_LC_POINTER(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_POINTER)
++#define DUK_HTHREAD_STRING_LC_POINTER(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_POINTER)
++#define DUK_HEAP_STRING_LC_BUFFER(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_BUFFER)
++#define DUK_HTHREAD_STRING_LC_BUFFER(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_BUFFER)
++#define DUK_HEAP_STRING_INT_TRACEDATA(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INT_TRACEDATA)
++#define DUK_HTHREAD_STRING_INT_TRACEDATA(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INT_TRACEDATA)
++#define DUK_HEAP_STRING_LINE_NUMBER(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LINE_NUMBER)
++#define DUK_HTHREAD_STRING_LINE_NUMBER(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LINE_NUMBER)
++#define DUK_HEAP_STRING_FILE_NAME(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FILE_NAME)
++#define DUK_HTHREAD_STRING_FILE_NAME(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FILE_NAME)
++#define DUK_HEAP_STRING_PC(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PC)
++#define DUK_HTHREAD_STRING_PC(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PC)
++#define DUK_HEAP_STRING_STACK(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_STACK)
++#define DUK_HTHREAD_STRING_STACK(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_STACK)
++#define DUK_HEAP_STRING_THROW_TYPE_ERROR(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_THROW_TYPE_ERROR)
++#define DUK_HTHREAD_STRING_THROW_TYPE_ERROR(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_THROW_TYPE_ERROR)
++#define DUK_HEAP_STRING_DUKTAPE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DUKTAPE)
++#define DUK_HTHREAD_STRING_DUKTAPE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DUKTAPE)
++#define DUK_HEAP_STRING_ID(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ID)
++#define DUK_HTHREAD_STRING_ID(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ID)
++#define DUK_HEAP_STRING_REQUIRE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REQUIRE)
++#define DUK_HTHREAD_STRING_REQUIRE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REQUIRE)
++#define DUK_HEAP_STRING___PROTO__(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX___PROTO__)
++#define DUK_HTHREAD_STRING___PROTO__(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX___PROTO__)
++#define DUK_HEAP_STRING_SET_PROTOTYPE_OF(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_PROTOTYPE_OF)
++#define DUK_HTHREAD_STRING_SET_PROTOTYPE_OF(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_PROTOTYPE_OF)
++#define DUK_HEAP_STRING_OWN_KEYS(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_OWN_KEYS)
++#define DUK_HTHREAD_STRING_OWN_KEYS(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_OWN_KEYS)
++#define DUK_HEAP_STRING_ENUMERATE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENUMERATE)
++#define DUK_HTHREAD_STRING_ENUMERATE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENUMERATE)
++#define DUK_HEAP_STRING_DELETE_PROPERTY(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DELETE_PROPERTY)
++#define DUK_HTHREAD_STRING_DELETE_PROPERTY(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DELETE_PROPERTY)
++#define DUK_HEAP_STRING_HAS(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_HAS)
++#define DUK_HTHREAD_STRING_HAS(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_HAS)
++#define DUK_HEAP_STRING_PROXY(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROXY)
++#define DUK_HTHREAD_STRING_PROXY(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROXY)
++#define DUK_HEAP_STRING_CALLEE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CALLEE)
++#define DUK_HTHREAD_STRING_CALLEE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CALLEE)
++#define DUK_HEAP_STRING_INVALID_DATE(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INVALID_DATE)
++#define DUK_HTHREAD_STRING_INVALID_DATE(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INVALID_DATE)
++#define DUK_HEAP_STRING_BRACKETED_ELLIPSIS(heap)                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BRACKETED_ELLIPSIS)
++#define DUK_HTHREAD_STRING_BRACKETED_ELLIPSIS(thr)                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BRACKETED_ELLIPSIS)
++#define DUK_HEAP_STRING_NEWLINE_TAB(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NEWLINE_TAB)
++#define DUK_HTHREAD_STRING_NEWLINE_TAB(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NEWLINE_TAB)
++#define DUK_HEAP_STRING_SPACE(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SPACE)
++#define DUK_HTHREAD_STRING_SPACE(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SPACE)
++#define DUK_HEAP_STRING_COMMA(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COMMA)
++#define DUK_HTHREAD_STRING_COMMA(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COMMA)
++#define DUK_HEAP_STRING_MINUS_ZERO(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MINUS_ZERO)
++#define DUK_HTHREAD_STRING_MINUS_ZERO(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MINUS_ZERO)
++#define DUK_HEAP_STRING_PLUS_ZERO(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PLUS_ZERO)
++#define DUK_HTHREAD_STRING_PLUS_ZERO(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PLUS_ZERO)
++#define DUK_HEAP_STRING_ZERO(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ZERO)
++#define DUK_HTHREAD_STRING_ZERO(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ZERO)
++#define DUK_HEAP_STRING_MINUS_INFINITY(heap)                          DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MINUS_INFINITY)
++#define DUK_HTHREAD_STRING_MINUS_INFINITY(thr)                        DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MINUS_INFINITY)
++#define DUK_HEAP_STRING_PLUS_INFINITY(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PLUS_INFINITY)
++#define DUK_HTHREAD_STRING_PLUS_INFINITY(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PLUS_INFINITY)
++#define DUK_HEAP_STRING_INFINITY(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INFINITY)
++#define DUK_HTHREAD_STRING_INFINITY(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INFINITY)
++#define DUK_HEAP_STRING_LC_OBJECT(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_OBJECT)
++#define DUK_HTHREAD_STRING_LC_OBJECT(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_OBJECT)
++#define DUK_HEAP_STRING_LC_STRING(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_STRING)
++#define DUK_HTHREAD_STRING_LC_STRING(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_STRING)
++#define DUK_HEAP_STRING_LC_NUMBER(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_NUMBER)
++#define DUK_HTHREAD_STRING_LC_NUMBER(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_NUMBER)
++#define DUK_HEAP_STRING_LC_BOOLEAN(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_BOOLEAN)
++#define DUK_HTHREAD_STRING_LC_BOOLEAN(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_BOOLEAN)
++#define DUK_HEAP_STRING_LC_UNDEFINED(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_UNDEFINED)
++#define DUK_HTHREAD_STRING_LC_UNDEFINED(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_UNDEFINED)
++#define DUK_HEAP_STRING_STRINGIFY(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_STRINGIFY)
++#define DUK_HTHREAD_STRING_STRINGIFY(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_STRINGIFY)
++#define DUK_HEAP_STRING_TAN(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TAN)
++#define DUK_HTHREAD_STRING_TAN(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TAN)
++#define DUK_HEAP_STRING_SQRT(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SQRT)
++#define DUK_HTHREAD_STRING_SQRT(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SQRT)
++#define DUK_HEAP_STRING_SIN(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SIN)
++#define DUK_HTHREAD_STRING_SIN(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SIN)
++#define DUK_HEAP_STRING_ROUND(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ROUND)
++#define DUK_HTHREAD_STRING_ROUND(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ROUND)
++#define DUK_HEAP_STRING_RANDOM(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RANDOM)
++#define DUK_HTHREAD_STRING_RANDOM(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RANDOM)
++#define DUK_HEAP_STRING_POW(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_POW)
++#define DUK_HTHREAD_STRING_POW(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_POW)
++#define DUK_HEAP_STRING_MIN(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MIN)
++#define DUK_HTHREAD_STRING_MIN(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MIN)
++#define DUK_HEAP_STRING_MAX(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MAX)
++#define DUK_HTHREAD_STRING_MAX(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MAX)
++#define DUK_HEAP_STRING_LOG(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LOG)
++#define DUK_HTHREAD_STRING_LOG(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LOG)
++#define DUK_HEAP_STRING_FLOOR(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FLOOR)
++#define DUK_HTHREAD_STRING_FLOOR(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FLOOR)
++#define DUK_HEAP_STRING_EXP(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXP)
++#define DUK_HTHREAD_STRING_EXP(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXP)
++#define DUK_HEAP_STRING_COS(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_COS)
++#define DUK_HTHREAD_STRING_COS(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_COS)
++#define DUK_HEAP_STRING_CEIL(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CEIL)
++#define DUK_HTHREAD_STRING_CEIL(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CEIL)
++#define DUK_HEAP_STRING_ATAN2(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ATAN2)
++#define DUK_HTHREAD_STRING_ATAN2(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ATAN2)
++#define DUK_HEAP_STRING_ATAN(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ATAN)
++#define DUK_HTHREAD_STRING_ATAN(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ATAN)
++#define DUK_HEAP_STRING_ASIN(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ASIN)
++#define DUK_HTHREAD_STRING_ASIN(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ASIN)
++#define DUK_HEAP_STRING_ACOS(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ACOS)
++#define DUK_HTHREAD_STRING_ACOS(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ACOS)
++#define DUK_HEAP_STRING_ABS(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ABS)
++#define DUK_HTHREAD_STRING_ABS(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ABS)
++#define DUK_HEAP_STRING_SQRT2(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SQRT2)
++#define DUK_HTHREAD_STRING_SQRT2(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SQRT2)
++#define DUK_HEAP_STRING_SQRT1_2(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SQRT1_2)
++#define DUK_HTHREAD_STRING_SQRT1_2(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SQRT1_2)
++#define DUK_HEAP_STRING_PI(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PI)
++#define DUK_HTHREAD_STRING_PI(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PI)
++#define DUK_HEAP_STRING_LOG10E(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LOG10E)
++#define DUK_HTHREAD_STRING_LOG10E(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LOG10E)
++#define DUK_HEAP_STRING_LOG2E(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LOG2E)
++#define DUK_HTHREAD_STRING_LOG2E(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LOG2E)
++#define DUK_HEAP_STRING_LN2(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LN2)
++#define DUK_HTHREAD_STRING_LN2(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LN2)
++#define DUK_HEAP_STRING_LN10(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LN10)
++#define DUK_HTHREAD_STRING_LN10(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LN10)
++#define DUK_HEAP_STRING_E(heap)                                       DUK_HEAP_GET_STRING((heap),DUK_STRIDX_E)
++#define DUK_HTHREAD_STRING_E(thr)                                     DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_E)
++#define DUK_HEAP_STRING_MESSAGE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MESSAGE)
++#define DUK_HTHREAD_STRING_MESSAGE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MESSAGE)
++#define DUK_HEAP_STRING_NAME(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NAME)
++#define DUK_HTHREAD_STRING_NAME(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NAME)
++#define DUK_HEAP_STRING_INPUT(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INPUT)
++#define DUK_HTHREAD_STRING_INPUT(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INPUT)
++#define DUK_HEAP_STRING_INDEX(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INDEX)
++#define DUK_HTHREAD_STRING_INDEX(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INDEX)
++#define DUK_HEAP_STRING_ESCAPED_EMPTY_REGEXP(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ESCAPED_EMPTY_REGEXP)
++#define DUK_HTHREAD_STRING_ESCAPED_EMPTY_REGEXP(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ESCAPED_EMPTY_REGEXP)
++#define DUK_HEAP_STRING_LAST_INDEX(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LAST_INDEX)
++#define DUK_HTHREAD_STRING_LAST_INDEX(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LAST_INDEX)
++#define DUK_HEAP_STRING_MULTILINE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MULTILINE)
++#define DUK_HTHREAD_STRING_MULTILINE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MULTILINE)
++#define DUK_HEAP_STRING_IGNORE_CASE(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IGNORE_CASE)
++#define DUK_HTHREAD_STRING_IGNORE_CASE(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IGNORE_CASE)
++#define DUK_HEAP_STRING_SOURCE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SOURCE)
++#define DUK_HTHREAD_STRING_SOURCE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SOURCE)
++#define DUK_HEAP_STRING_TEST(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TEST)
++#define DUK_HTHREAD_STRING_TEST(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TEST)
++#define DUK_HEAP_STRING_EXEC(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXEC)
++#define DUK_HTHREAD_STRING_EXEC(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXEC)
++#define DUK_HEAP_STRING_TO_GMT_STRING(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_GMT_STRING)
++#define DUK_HTHREAD_STRING_TO_GMT_STRING(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_GMT_STRING)
++#define DUK_HEAP_STRING_SET_YEAR(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_YEAR)
++#define DUK_HTHREAD_STRING_SET_YEAR(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_YEAR)
++#define DUK_HEAP_STRING_GET_YEAR(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_YEAR)
++#define DUK_HTHREAD_STRING_GET_YEAR(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_YEAR)
++#define DUK_HEAP_STRING_TO_JSON(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_JSON)
++#define DUK_HTHREAD_STRING_TO_JSON(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_JSON)
++#define DUK_HEAP_STRING_TO_ISO_STRING(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_ISO_STRING)
++#define DUK_HTHREAD_STRING_TO_ISO_STRING(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_ISO_STRING)
++#define DUK_HEAP_STRING_TO_UTC_STRING(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_UTC_STRING)
++#define DUK_HTHREAD_STRING_TO_UTC_STRING(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_UTC_STRING)
++#define DUK_HEAP_STRING_SET_UTC_FULL_YEAR(heap)                       DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_FULL_YEAR)
++#define DUK_HTHREAD_STRING_SET_UTC_FULL_YEAR(thr)                     DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_FULL_YEAR)
++#define DUK_HEAP_STRING_SET_FULL_YEAR(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_FULL_YEAR)
++#define DUK_HTHREAD_STRING_SET_FULL_YEAR(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_FULL_YEAR)
++#define DUK_HEAP_STRING_SET_UTC_MONTH(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_MONTH)
++#define DUK_HTHREAD_STRING_SET_UTC_MONTH(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_MONTH)
++#define DUK_HEAP_STRING_SET_MONTH(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_MONTH)
++#define DUK_HTHREAD_STRING_SET_MONTH(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_MONTH)
++#define DUK_HEAP_STRING_SET_UTC_DATE(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_DATE)
++#define DUK_HTHREAD_STRING_SET_UTC_DATE(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_DATE)
++#define DUK_HEAP_STRING_SET_DATE(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_DATE)
++#define DUK_HTHREAD_STRING_SET_DATE(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_DATE)
++#define DUK_HEAP_STRING_SET_UTC_HOURS(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_HOURS)
++#define DUK_HTHREAD_STRING_SET_UTC_HOURS(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_HOURS)
++#define DUK_HEAP_STRING_SET_HOURS(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_HOURS)
++#define DUK_HTHREAD_STRING_SET_HOURS(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_HOURS)
++#define DUK_HEAP_STRING_SET_UTC_MINUTES(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_MINUTES)
++#define DUK_HTHREAD_STRING_SET_UTC_MINUTES(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_MINUTES)
++#define DUK_HEAP_STRING_SET_MINUTES(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_MINUTES)
++#define DUK_HTHREAD_STRING_SET_MINUTES(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_MINUTES)
++#define DUK_HEAP_STRING_SET_UTC_SECONDS(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_SECONDS)
++#define DUK_HTHREAD_STRING_SET_UTC_SECONDS(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_SECONDS)
++#define DUK_HEAP_STRING_SET_SECONDS(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_SECONDS)
++#define DUK_HTHREAD_STRING_SET_SECONDS(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_SECONDS)
++#define DUK_HEAP_STRING_SET_UTC_MILLISECONDS(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_UTC_MILLISECONDS)
++#define DUK_HTHREAD_STRING_SET_UTC_MILLISECONDS(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_UTC_MILLISECONDS)
++#define DUK_HEAP_STRING_SET_MILLISECONDS(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_MILLISECONDS)
++#define DUK_HTHREAD_STRING_SET_MILLISECONDS(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_MILLISECONDS)
++#define DUK_HEAP_STRING_SET_TIME(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET_TIME)
++#define DUK_HTHREAD_STRING_SET_TIME(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET_TIME)
++#define DUK_HEAP_STRING_GET_TIMEZONE_OFFSET(heap)                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_TIMEZONE_OFFSET)
++#define DUK_HTHREAD_STRING_GET_TIMEZONE_OFFSET(thr)                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_TIMEZONE_OFFSET)
++#define DUK_HEAP_STRING_GET_UTC_MILLISECONDS(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_MILLISECONDS)
++#define DUK_HTHREAD_STRING_GET_UTC_MILLISECONDS(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_MILLISECONDS)
++#define DUK_HEAP_STRING_GET_MILLISECONDS(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_MILLISECONDS)
++#define DUK_HTHREAD_STRING_GET_MILLISECONDS(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_MILLISECONDS)
++#define DUK_HEAP_STRING_GET_UTC_SECONDS(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_SECONDS)
++#define DUK_HTHREAD_STRING_GET_UTC_SECONDS(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_SECONDS)
++#define DUK_HEAP_STRING_GET_SECONDS(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_SECONDS)
++#define DUK_HTHREAD_STRING_GET_SECONDS(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_SECONDS)
++#define DUK_HEAP_STRING_GET_UTC_MINUTES(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_MINUTES)
++#define DUK_HTHREAD_STRING_GET_UTC_MINUTES(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_MINUTES)
++#define DUK_HEAP_STRING_GET_MINUTES(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_MINUTES)
++#define DUK_HTHREAD_STRING_GET_MINUTES(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_MINUTES)
++#define DUK_HEAP_STRING_GET_UTC_HOURS(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_HOURS)
++#define DUK_HTHREAD_STRING_GET_UTC_HOURS(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_HOURS)
++#define DUK_HEAP_STRING_GET_HOURS(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_HOURS)
++#define DUK_HTHREAD_STRING_GET_HOURS(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_HOURS)
++#define DUK_HEAP_STRING_GET_UTC_DAY(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_DAY)
++#define DUK_HTHREAD_STRING_GET_UTC_DAY(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_DAY)
++#define DUK_HEAP_STRING_GET_DAY(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_DAY)
++#define DUK_HTHREAD_STRING_GET_DAY(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_DAY)
++#define DUK_HEAP_STRING_GET_UTC_DATE(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_DATE)
++#define DUK_HTHREAD_STRING_GET_UTC_DATE(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_DATE)
++#define DUK_HEAP_STRING_GET_DATE(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_DATE)
++#define DUK_HTHREAD_STRING_GET_DATE(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_DATE)
++#define DUK_HEAP_STRING_GET_UTC_MONTH(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_MONTH)
++#define DUK_HTHREAD_STRING_GET_UTC_MONTH(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_MONTH)
++#define DUK_HEAP_STRING_GET_MONTH(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_MONTH)
++#define DUK_HTHREAD_STRING_GET_MONTH(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_MONTH)
++#define DUK_HEAP_STRING_GET_UTC_FULL_YEAR(heap)                       DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_UTC_FULL_YEAR)
++#define DUK_HTHREAD_STRING_GET_UTC_FULL_YEAR(thr)                     DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_UTC_FULL_YEAR)
++#define DUK_HEAP_STRING_GET_FULL_YEAR(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_FULL_YEAR)
++#define DUK_HTHREAD_STRING_GET_FULL_YEAR(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_FULL_YEAR)
++#define DUK_HEAP_STRING_GET_TIME(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_TIME)
++#define DUK_HTHREAD_STRING_GET_TIME(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_TIME)
++#define DUK_HEAP_STRING_TO_LOCALE_TIME_STRING(heap)                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_TIME_STRING)
++#define DUK_HTHREAD_STRING_TO_LOCALE_TIME_STRING(thr)                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_TIME_STRING)
++#define DUK_HEAP_STRING_TO_LOCALE_DATE_STRING(heap)                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_DATE_STRING)
++#define DUK_HTHREAD_STRING_TO_LOCALE_DATE_STRING(thr)                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_DATE_STRING)
++#define DUK_HEAP_STRING_TO_TIME_STRING(heap)                          DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_TIME_STRING)
++#define DUK_HTHREAD_STRING_TO_TIME_STRING(thr)                        DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_TIME_STRING)
++#define DUK_HEAP_STRING_TO_DATE_STRING(heap)                          DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_DATE_STRING)
++#define DUK_HTHREAD_STRING_TO_DATE_STRING(thr)                        DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_DATE_STRING)
++#define DUK_HEAP_STRING_NOW(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NOW)
++#define DUK_HTHREAD_STRING_NOW(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NOW)
++#define DUK_HEAP_STRING_UTC(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UTC)
++#define DUK_HTHREAD_STRING_UTC(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UTC)
++#define DUK_HEAP_STRING_PARSE(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PARSE)
++#define DUK_HTHREAD_STRING_PARSE(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PARSE)
++#define DUK_HEAP_STRING_TO_PRECISION(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_PRECISION)
++#define DUK_HTHREAD_STRING_TO_PRECISION(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_PRECISION)
++#define DUK_HEAP_STRING_TO_EXPONENTIAL(heap)                          DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_EXPONENTIAL)
++#define DUK_HTHREAD_STRING_TO_EXPONENTIAL(thr)                        DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_EXPONENTIAL)
++#define DUK_HEAP_STRING_TO_FIXED(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_FIXED)
++#define DUK_HTHREAD_STRING_TO_FIXED(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_FIXED)
++#define DUK_HEAP_STRING_POSITIVE_INFINITY(heap)                       DUK_HEAP_GET_STRING((heap),DUK_STRIDX_POSITIVE_INFINITY)
++#define DUK_HTHREAD_STRING_POSITIVE_INFINITY(thr)                     DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_POSITIVE_INFINITY)
++#define DUK_HEAP_STRING_NEGATIVE_INFINITY(heap)                       DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NEGATIVE_INFINITY)
++#define DUK_HTHREAD_STRING_NEGATIVE_INFINITY(thr)                     DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NEGATIVE_INFINITY)
++#define DUK_HEAP_STRING_NAN(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NAN)
++#define DUK_HTHREAD_STRING_NAN(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NAN)
++#define DUK_HEAP_STRING_MIN_VALUE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MIN_VALUE)
++#define DUK_HTHREAD_STRING_MIN_VALUE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MIN_VALUE)
++#define DUK_HEAP_STRING_MAX_VALUE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MAX_VALUE)
++#define DUK_HTHREAD_STRING_MAX_VALUE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MAX_VALUE)
++#define DUK_HEAP_STRING_SUBSTR(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SUBSTR)
++#define DUK_HTHREAD_STRING_SUBSTR(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SUBSTR)
++#define DUK_HEAP_STRING_TRIM(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TRIM)
++#define DUK_HTHREAD_STRING_TRIM(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TRIM)
++#define DUK_HEAP_STRING_TO_LOCALE_UPPER_CASE(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_UPPER_CASE)
++#define DUK_HTHREAD_STRING_TO_LOCALE_UPPER_CASE(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_UPPER_CASE)
++#define DUK_HEAP_STRING_TO_UPPER_CASE(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_UPPER_CASE)
++#define DUK_HTHREAD_STRING_TO_UPPER_CASE(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_UPPER_CASE)
++#define DUK_HEAP_STRING_TO_LOCALE_LOWER_CASE(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_LOWER_CASE)
++#define DUK_HTHREAD_STRING_TO_LOCALE_LOWER_CASE(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_LOWER_CASE)
++#define DUK_HEAP_STRING_TO_LOWER_CASE(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOWER_CASE)
++#define DUK_HTHREAD_STRING_TO_LOWER_CASE(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOWER_CASE)
++#define DUK_HEAP_STRING_SUBSTRING(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SUBSTRING)
++#define DUK_HTHREAD_STRING_SUBSTRING(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SUBSTRING)
++#define DUK_HEAP_STRING_SPLIT(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SPLIT)
++#define DUK_HTHREAD_STRING_SPLIT(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SPLIT)
++#define DUK_HEAP_STRING_SEARCH(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SEARCH)
++#define DUK_HTHREAD_STRING_SEARCH(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SEARCH)
++#define DUK_HEAP_STRING_REPLACE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REPLACE)
++#define DUK_HTHREAD_STRING_REPLACE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REPLACE)
++#define DUK_HEAP_STRING_MATCH(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MATCH)
++#define DUK_HTHREAD_STRING_MATCH(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MATCH)
++#define DUK_HEAP_STRING_LOCALE_COMPARE(heap)                          DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LOCALE_COMPARE)
++#define DUK_HTHREAD_STRING_LOCALE_COMPARE(thr)                        DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LOCALE_COMPARE)
++#define DUK_HEAP_STRING_CHAR_CODE_AT(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CHAR_CODE_AT)
++#define DUK_HTHREAD_STRING_CHAR_CODE_AT(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CHAR_CODE_AT)
++#define DUK_HEAP_STRING_CHAR_AT(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CHAR_AT)
++#define DUK_HTHREAD_STRING_CHAR_AT(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CHAR_AT)
++#define DUK_HEAP_STRING_FROM_CHAR_CODE(heap)                          DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FROM_CHAR_CODE)
++#define DUK_HTHREAD_STRING_FROM_CHAR_CODE(thr)                        DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FROM_CHAR_CODE)
++#define DUK_HEAP_STRING_REDUCE_RIGHT(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REDUCE_RIGHT)
++#define DUK_HTHREAD_STRING_REDUCE_RIGHT(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REDUCE_RIGHT)
++#define DUK_HEAP_STRING_REDUCE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REDUCE)
++#define DUK_HTHREAD_STRING_REDUCE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REDUCE)
++#define DUK_HEAP_STRING_FILTER(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FILTER)
++#define DUK_HTHREAD_STRING_FILTER(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FILTER)
++#define DUK_HEAP_STRING_MAP(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_MAP)
++#define DUK_HTHREAD_STRING_MAP(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_MAP)
++#define DUK_HEAP_STRING_FOR_EACH(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FOR_EACH)
++#define DUK_HTHREAD_STRING_FOR_EACH(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FOR_EACH)
++#define DUK_HEAP_STRING_SOME(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SOME)
++#define DUK_HTHREAD_STRING_SOME(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SOME)
++#define DUK_HEAP_STRING_EVERY(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EVERY)
++#define DUK_HTHREAD_STRING_EVERY(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EVERY)
++#define DUK_HEAP_STRING_LAST_INDEX_OF(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LAST_INDEX_OF)
++#define DUK_HTHREAD_STRING_LAST_INDEX_OF(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LAST_INDEX_OF)
++#define DUK_HEAP_STRING_INDEX_OF(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INDEX_OF)
++#define DUK_HTHREAD_STRING_INDEX_OF(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INDEX_OF)
++#define DUK_HEAP_STRING_UNSHIFT(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UNSHIFT)
++#define DUK_HTHREAD_STRING_UNSHIFT(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UNSHIFT)
++#define DUK_HEAP_STRING_SPLICE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SPLICE)
++#define DUK_HTHREAD_STRING_SPLICE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SPLICE)
++#define DUK_HEAP_STRING_SORT(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SORT)
++#define DUK_HTHREAD_STRING_SORT(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SORT)
++#define DUK_HEAP_STRING_SLICE(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SLICE)
++#define DUK_HTHREAD_STRING_SLICE(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SLICE)
++#define DUK_HEAP_STRING_SHIFT(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SHIFT)
++#define DUK_HTHREAD_STRING_SHIFT(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SHIFT)
++#define DUK_HEAP_STRING_REVERSE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REVERSE)
++#define DUK_HTHREAD_STRING_REVERSE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REVERSE)
++#define DUK_HEAP_STRING_PUSH(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PUSH)
++#define DUK_HTHREAD_STRING_PUSH(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PUSH)
++#define DUK_HEAP_STRING_POP(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_POP)
++#define DUK_HTHREAD_STRING_POP(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_POP)
++#define DUK_HEAP_STRING_JOIN(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_JOIN)
++#define DUK_HTHREAD_STRING_JOIN(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_JOIN)
++#define DUK_HEAP_STRING_CONCAT(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONCAT)
++#define DUK_HTHREAD_STRING_CONCAT(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONCAT)
++#define DUK_HEAP_STRING_IS_ARRAY(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_ARRAY)
++#define DUK_HTHREAD_STRING_IS_ARRAY(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_ARRAY)
++#define DUK_HEAP_STRING_LC_ARGUMENTS(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_ARGUMENTS)
++#define DUK_HTHREAD_STRING_LC_ARGUMENTS(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_ARGUMENTS)
++#define DUK_HEAP_STRING_CALLER(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CALLER)
++#define DUK_HTHREAD_STRING_CALLER(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CALLER)
++#define DUK_HEAP_STRING_BIND(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BIND)
++#define DUK_HTHREAD_STRING_BIND(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BIND)
++#define DUK_HEAP_STRING_CALL(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CALL)
++#define DUK_HTHREAD_STRING_CALL(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CALL)
++#define DUK_HEAP_STRING_APPLY(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_APPLY)
++#define DUK_HTHREAD_STRING_APPLY(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_APPLY)
++#define DUK_HEAP_STRING_PROPERTY_IS_ENUMERABLE(heap)                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROPERTY_IS_ENUMERABLE)
++#define DUK_HTHREAD_STRING_PROPERTY_IS_ENUMERABLE(thr)                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROPERTY_IS_ENUMERABLE)
++#define DUK_HEAP_STRING_IS_PROTOTYPE_OF(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_PROTOTYPE_OF)
++#define DUK_HTHREAD_STRING_IS_PROTOTYPE_OF(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_PROTOTYPE_OF)
++#define DUK_HEAP_STRING_HAS_OWN_PROPERTY(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_HAS_OWN_PROPERTY)
++#define DUK_HTHREAD_STRING_HAS_OWN_PROPERTY(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_HAS_OWN_PROPERTY)
++#define DUK_HEAP_STRING_VALUE_OF(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VALUE_OF)
++#define DUK_HTHREAD_STRING_VALUE_OF(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VALUE_OF)
++#define DUK_HEAP_STRING_TO_LOCALE_STRING(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_LOCALE_STRING)
++#define DUK_HTHREAD_STRING_TO_LOCALE_STRING(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_LOCALE_STRING)
++#define DUK_HEAP_STRING_TO_STRING(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TO_STRING)
++#define DUK_HTHREAD_STRING_TO_STRING(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TO_STRING)
++#define DUK_HEAP_STRING_CONSTRUCTOR(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONSTRUCTOR)
++#define DUK_HTHREAD_STRING_CONSTRUCTOR(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONSTRUCTOR)
++#define DUK_HEAP_STRING_SET(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SET)
++#define DUK_HTHREAD_STRING_SET(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SET)
++#define DUK_HEAP_STRING_GET(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET)
++#define DUK_HTHREAD_STRING_GET(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET)
++#define DUK_HEAP_STRING_ENUMERABLE(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENUMERABLE)
++#define DUK_HTHREAD_STRING_ENUMERABLE(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENUMERABLE)
++#define DUK_HEAP_STRING_CONFIGURABLE(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONFIGURABLE)
++#define DUK_HTHREAD_STRING_CONFIGURABLE(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONFIGURABLE)
++#define DUK_HEAP_STRING_WRITABLE(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WRITABLE)
++#define DUK_HTHREAD_STRING_WRITABLE(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WRITABLE)
++#define DUK_HEAP_STRING_VALUE(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VALUE)
++#define DUK_HTHREAD_STRING_VALUE(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VALUE)
++#define DUK_HEAP_STRING_KEYS(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_KEYS)
++#define DUK_HTHREAD_STRING_KEYS(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_KEYS)
++#define DUK_HEAP_STRING_IS_EXTENSIBLE(heap)                           DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_EXTENSIBLE)
++#define DUK_HTHREAD_STRING_IS_EXTENSIBLE(thr)                         DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_EXTENSIBLE)
++#define DUK_HEAP_STRING_IS_FROZEN(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_FROZEN)
++#define DUK_HTHREAD_STRING_IS_FROZEN(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_FROZEN)
++#define DUK_HEAP_STRING_IS_SEALED(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_SEALED)
++#define DUK_HTHREAD_STRING_IS_SEALED(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_SEALED)
++#define DUK_HEAP_STRING_PREVENT_EXTENSIONS(heap)                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PREVENT_EXTENSIONS)
++#define DUK_HTHREAD_STRING_PREVENT_EXTENSIONS(thr)                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PREVENT_EXTENSIONS)
++#define DUK_HEAP_STRING_FREEZE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FREEZE)
++#define DUK_HTHREAD_STRING_FREEZE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FREEZE)
++#define DUK_HEAP_STRING_SEAL(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SEAL)
++#define DUK_HTHREAD_STRING_SEAL(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SEAL)
++#define DUK_HEAP_STRING_DEFINE_PROPERTIES(heap)                       DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEFINE_PROPERTIES)
++#define DUK_HTHREAD_STRING_DEFINE_PROPERTIES(thr)                     DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEFINE_PROPERTIES)
++#define DUK_HEAP_STRING_DEFINE_PROPERTY(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEFINE_PROPERTY)
++#define DUK_HTHREAD_STRING_DEFINE_PROPERTY(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEFINE_PROPERTY)
++#define DUK_HEAP_STRING_CREATE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CREATE)
++#define DUK_HTHREAD_STRING_CREATE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CREATE)
++#define DUK_HEAP_STRING_GET_OWN_PROPERTY_NAMES(heap)                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_OWN_PROPERTY_NAMES)
++#define DUK_HTHREAD_STRING_GET_OWN_PROPERTY_NAMES(thr)                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_OWN_PROPERTY_NAMES)
++#define DUK_HEAP_STRING_GET_OWN_PROPERTY_DESCRIPTOR(heap)             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_OWN_PROPERTY_DESCRIPTOR)
++#define DUK_HTHREAD_STRING_GET_OWN_PROPERTY_DESCRIPTOR(thr)           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_OWN_PROPERTY_DESCRIPTOR)
++#define DUK_HEAP_STRING_GET_PROTOTYPE_OF(heap)                        DUK_HEAP_GET_STRING((heap),DUK_STRIDX_GET_PROTOTYPE_OF)
++#define DUK_HTHREAD_STRING_GET_PROTOTYPE_OF(thr)                      DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_GET_PROTOTYPE_OF)
++#define DUK_HEAP_STRING_PROTOTYPE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROTOTYPE)
++#define DUK_HTHREAD_STRING_PROTOTYPE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROTOTYPE)
++#define DUK_HEAP_STRING_LENGTH(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LENGTH)
++#define DUK_HTHREAD_STRING_LENGTH(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LENGTH)
++#define DUK_HEAP_STRING_ALERT(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ALERT)
++#define DUK_HTHREAD_STRING_ALERT(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ALERT)
++#define DUK_HEAP_STRING_PRINT(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PRINT)
++#define DUK_HTHREAD_STRING_PRINT(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PRINT)
++#define DUK_HEAP_STRING_UNESCAPE(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_UNESCAPE)
++#define DUK_HTHREAD_STRING_UNESCAPE(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_UNESCAPE)
++#define DUK_HEAP_STRING_ESCAPE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ESCAPE)
++#define DUK_HTHREAD_STRING_ESCAPE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ESCAPE)
++#define DUK_HEAP_STRING_ENCODE_URI_COMPONENT(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENCODE_URI_COMPONENT)
++#define DUK_HTHREAD_STRING_ENCODE_URI_COMPONENT(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENCODE_URI_COMPONENT)
++#define DUK_HEAP_STRING_ENCODE_URI(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENCODE_URI)
++#define DUK_HTHREAD_STRING_ENCODE_URI(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENCODE_URI)
++#define DUK_HEAP_STRING_DECODE_URI_COMPONENT(heap)                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DECODE_URI_COMPONENT)
++#define DUK_HTHREAD_STRING_DECODE_URI_COMPONENT(thr)                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DECODE_URI_COMPONENT)
++#define DUK_HEAP_STRING_DECODE_URI(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DECODE_URI)
++#define DUK_HTHREAD_STRING_DECODE_URI(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DECODE_URI)
++#define DUK_HEAP_STRING_IS_FINITE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_FINITE)
++#define DUK_HTHREAD_STRING_IS_FINITE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_FINITE)
++#define DUK_HEAP_STRING_IS_NAN(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IS_NAN)
++#define DUK_HTHREAD_STRING_IS_NAN(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IS_NAN)
++#define DUK_HEAP_STRING_PARSE_FLOAT(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PARSE_FLOAT)
++#define DUK_HTHREAD_STRING_PARSE_FLOAT(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PARSE_FLOAT)
++#define DUK_HEAP_STRING_PARSE_INT(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PARSE_INT)
++#define DUK_HTHREAD_STRING_PARSE_INT(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PARSE_INT)
++#define DUK_HEAP_STRING_EVAL(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EVAL)
++#define DUK_HTHREAD_STRING_EVAL(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EVAL)
++#define DUK_HEAP_STRING_URI_ERROR(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_URI_ERROR)
++#define DUK_HTHREAD_STRING_URI_ERROR(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_URI_ERROR)
++#define DUK_HEAP_STRING_TYPE_ERROR(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TYPE_ERROR)
++#define DUK_HTHREAD_STRING_TYPE_ERROR(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TYPE_ERROR)
++#define DUK_HEAP_STRING_SYNTAX_ERROR(heap)                            DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SYNTAX_ERROR)
++#define DUK_HTHREAD_STRING_SYNTAX_ERROR(thr)                          DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SYNTAX_ERROR)
++#define DUK_HEAP_STRING_REFERENCE_ERROR(heap)                         DUK_HEAP_GET_STRING((heap),DUK_STRIDX_REFERENCE_ERROR)
++#define DUK_HTHREAD_STRING_REFERENCE_ERROR(thr)                       DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_REFERENCE_ERROR)
++#define DUK_HEAP_STRING_RANGE_ERROR(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RANGE_ERROR)
++#define DUK_HTHREAD_STRING_RANGE_ERROR(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RANGE_ERROR)
++#define DUK_HEAP_STRING_EVAL_ERROR(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EVAL_ERROR)
++#define DUK_HTHREAD_STRING_EVAL_ERROR(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EVAL_ERROR)
++#define DUK_HEAP_STRING_BREAK(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_BREAK)
++#define DUK_HTHREAD_STRING_BREAK(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_BREAK)
++#define DUK_HEAP_STRING_CASE(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CASE)
++#define DUK_HTHREAD_STRING_CASE(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CASE)
++#define DUK_HEAP_STRING_CATCH(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CATCH)
++#define DUK_HTHREAD_STRING_CATCH(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CATCH)
++#define DUK_HEAP_STRING_CONTINUE(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONTINUE)
++#define DUK_HTHREAD_STRING_CONTINUE(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONTINUE)
++#define DUK_HEAP_STRING_DEBUGGER(heap)                                DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEBUGGER)
++#define DUK_HTHREAD_STRING_DEBUGGER(thr)                              DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEBUGGER)
++#define DUK_HEAP_STRING_DEFAULT(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DEFAULT)
++#define DUK_HTHREAD_STRING_DEFAULT(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DEFAULT)
++#define DUK_HEAP_STRING_DELETE(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DELETE)
++#define DUK_HTHREAD_STRING_DELETE(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DELETE)
++#define DUK_HEAP_STRING_DO(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_DO)
++#define DUK_HTHREAD_STRING_DO(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_DO)
++#define DUK_HEAP_STRING_ELSE(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ELSE)
++#define DUK_HTHREAD_STRING_ELSE(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ELSE)
++#define DUK_HEAP_STRING_FINALLY(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FINALLY)
++#define DUK_HTHREAD_STRING_FINALLY(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FINALLY)
++#define DUK_HEAP_STRING_FOR(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FOR)
++#define DUK_HTHREAD_STRING_FOR(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FOR)
++#define DUK_HEAP_STRING_LC_FUNCTION(heap)                             DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_FUNCTION)
++#define DUK_HTHREAD_STRING_LC_FUNCTION(thr)                           DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_FUNCTION)
++#define DUK_HEAP_STRING_IF(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IF)
++#define DUK_HTHREAD_STRING_IF(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IF)
++#define DUK_HEAP_STRING_IN(heap)                                      DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IN)
++#define DUK_HTHREAD_STRING_IN(thr)                                    DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IN)
++#define DUK_HEAP_STRING_INSTANCEOF(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INSTANCEOF)
++#define DUK_HTHREAD_STRING_INSTANCEOF(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INSTANCEOF)
++#define DUK_HEAP_STRING_NEW(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_NEW)
++#define DUK_HTHREAD_STRING_NEW(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_NEW)
++#define DUK_HEAP_STRING_RETURN(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_RETURN)
++#define DUK_HTHREAD_STRING_RETURN(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_RETURN)
++#define DUK_HEAP_STRING_SWITCH(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SWITCH)
++#define DUK_HTHREAD_STRING_SWITCH(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SWITCH)
++#define DUK_HEAP_STRING_THIS(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_THIS)
++#define DUK_HTHREAD_STRING_THIS(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_THIS)
++#define DUK_HEAP_STRING_THROW(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_THROW)
++#define DUK_HTHREAD_STRING_THROW(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_THROW)
++#define DUK_HEAP_STRING_TRY(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TRY)
++#define DUK_HTHREAD_STRING_TRY(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TRY)
++#define DUK_HEAP_STRING_TYPEOF(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TYPEOF)
++#define DUK_HTHREAD_STRING_TYPEOF(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TYPEOF)
++#define DUK_HEAP_STRING_VAR(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VAR)
++#define DUK_HTHREAD_STRING_VAR(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VAR)
++#define DUK_HEAP_STRING_VOID(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_VOID)
++#define DUK_HTHREAD_STRING_VOID(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_VOID)
++#define DUK_HEAP_STRING_WHILE(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WHILE)
++#define DUK_HTHREAD_STRING_WHILE(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WHILE)
++#define DUK_HEAP_STRING_WITH(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_WITH)
++#define DUK_HTHREAD_STRING_WITH(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_WITH)
++#define DUK_HEAP_STRING_CLASS(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CLASS)
++#define DUK_HTHREAD_STRING_CLASS(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CLASS)
++#define DUK_HEAP_STRING_CONST(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_CONST)
++#define DUK_HTHREAD_STRING_CONST(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_CONST)
++#define DUK_HEAP_STRING_ENUM(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_ENUM)
++#define DUK_HTHREAD_STRING_ENUM(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_ENUM)
++#define DUK_HEAP_STRING_EXPORT(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXPORT)
++#define DUK_HTHREAD_STRING_EXPORT(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXPORT)
++#define DUK_HEAP_STRING_EXTENDS(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_EXTENDS)
++#define DUK_HTHREAD_STRING_EXTENDS(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_EXTENDS)
++#define DUK_HEAP_STRING_IMPORT(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IMPORT)
++#define DUK_HTHREAD_STRING_IMPORT(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IMPORT)
++#define DUK_HEAP_STRING_SUPER(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_SUPER)
++#define DUK_HTHREAD_STRING_SUPER(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_SUPER)
++#define DUK_HEAP_STRING_LC_NULL(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LC_NULL)
++#define DUK_HTHREAD_STRING_LC_NULL(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LC_NULL)
++#define DUK_HEAP_STRING_TRUE(heap)                                    DUK_HEAP_GET_STRING((heap),DUK_STRIDX_TRUE)
++#define DUK_HTHREAD_STRING_TRUE(thr)                                  DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_TRUE)
++#define DUK_HEAP_STRING_FALSE(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_FALSE)
++#define DUK_HTHREAD_STRING_FALSE(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_FALSE)
++#define DUK_HEAP_STRING_IMPLEMENTS(heap)                              DUK_HEAP_GET_STRING((heap),DUK_STRIDX_IMPLEMENTS)
++#define DUK_HTHREAD_STRING_IMPLEMENTS(thr)                            DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_IMPLEMENTS)
++#define DUK_HEAP_STRING_INTERFACE(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_INTERFACE)
++#define DUK_HTHREAD_STRING_INTERFACE(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_INTERFACE)
++#define DUK_HEAP_STRING_LET(heap)                                     DUK_HEAP_GET_STRING((heap),DUK_STRIDX_LET)
++#define DUK_HTHREAD_STRING_LET(thr)                                   DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_LET)
++#define DUK_HEAP_STRING_PACKAGE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PACKAGE)
++#define DUK_HTHREAD_STRING_PACKAGE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PACKAGE)
++#define DUK_HEAP_STRING_PRIVATE(heap)                                 DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PRIVATE)
++#define DUK_HTHREAD_STRING_PRIVATE(thr)                               DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PRIVATE)
++#define DUK_HEAP_STRING_PROTECTED(heap)                               DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PROTECTED)
++#define DUK_HTHREAD_STRING_PROTECTED(thr)                             DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PROTECTED)
++#define DUK_HEAP_STRING_PUBLIC(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_PUBLIC)
++#define DUK_HTHREAD_STRING_PUBLIC(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_PUBLIC)
++#define DUK_HEAP_STRING_STATIC(heap)                                  DUK_HEAP_GET_STRING((heap),DUK_STRIDX_STATIC)
++#define DUK_HTHREAD_STRING_STATIC(thr)                                DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_STATIC)
++#define DUK_HEAP_STRING_YIELD(heap)                                   DUK_HEAP_GET_STRING((heap),DUK_STRIDX_YIELD)
++#define DUK_HTHREAD_STRING_YIELD(thr)                                 DUK_HTHREAD_GET_STRING((thr),DUK_STRIDX_YIELD)
++
++#define DUK_HEAP_NUM_STRINGS                                          336
++
++#define DUK_STRIDX_START_RESERVED                                     291
++#define DUK_STRIDX_START_STRICT_RESERVED                              327
++#define DUK_STRIDX_END_RESERVED                                       336                            /* exclusive endpoint */
++
++#if !defined(DUK_SINGLE_FILE)
++DUK_INTERNAL_DECL const duk_c_function duk_bi_native_functions[128];
++DUK_INTERNAL_DECL const duk_uint8_t duk_builtins_data[1341];
++#ifdef DUK_USE_BUILTIN_INITJS
++DUK_INTERNAL_DECL const duk_uint8_t duk_initjs_data[187];
++#endif  /* DUK_USE_BUILTIN_INITJS */
++#endif  /* !DUK_SINGLE_FILE */
++
++#define DUK_BUILTINS_DATA_LENGTH                                      1341
++#ifdef DUK_USE_BUILTIN_INITJS
++#define DUK_BUILTIN_INITJS_DATA_LENGTH                                187
++#endif  /* DUK_USE_BUILTIN_INITJS */
++
++#define DUK_BIDX_GLOBAL                                               0
++#define DUK_BIDX_GLOBAL_ENV                                           1
++#define DUK_BIDX_OBJECT_CONSTRUCTOR                                   2
++#define DUK_BIDX_OBJECT_PROTOTYPE                                     3
++#define DUK_BIDX_FUNCTION_CONSTRUCTOR                                 4
++#define DUK_BIDX_FUNCTION_PROTOTYPE                                   5
++#define DUK_BIDX_ARRAY_CONSTRUCTOR                                    6
++#define DUK_BIDX_ARRAY_PROTOTYPE                                      7
++#define DUK_BIDX_STRING_CONSTRUCTOR                                   8
++#define DUK_BIDX_STRING_PROTOTYPE                                     9
++#define DUK_BIDX_BOOLEAN_CONSTRUCTOR                                  10
++#define DUK_BIDX_BOOLEAN_PROTOTYPE                                    11
++#define DUK_BIDX_NUMBER_CONSTRUCTOR                                   12
++#define DUK_BIDX_NUMBER_PROTOTYPE                                     13
++#define DUK_BIDX_DATE_CONSTRUCTOR                                     14
++#define DUK_BIDX_DATE_PROTOTYPE                                       15
++#define DUK_BIDX_REGEXP_CONSTRUCTOR                                   16
++#define DUK_BIDX_REGEXP_PROTOTYPE                                     17
++#define DUK_BIDX_ERROR_CONSTRUCTOR                                    18
++#define DUK_BIDX_ERROR_PROTOTYPE                                      19
++#define DUK_BIDX_EVAL_ERROR_CONSTRUCTOR                               20
++#define DUK_BIDX_EVAL_ERROR_PROTOTYPE                                 21
++#define DUK_BIDX_RANGE_ERROR_CONSTRUCTOR                              22
++#define DUK_BIDX_RANGE_ERROR_PROTOTYPE                                23
++#define DUK_BIDX_REFERENCE_ERROR_CONSTRUCTOR                          24
++#define DUK_BIDX_REFERENCE_ERROR_PROTOTYPE                            25
++#define DUK_BIDX_SYNTAX_ERROR_CONSTRUCTOR                             26
++#define DUK_BIDX_SYNTAX_ERROR_PROTOTYPE                               27
++#define DUK_BIDX_TYPE_ERROR_CONSTRUCTOR                               28
++#define DUK_BIDX_TYPE_ERROR_PROTOTYPE                                 29
++#define DUK_BIDX_URI_ERROR_CONSTRUCTOR                                30
++#define DUK_BIDX_URI_ERROR_PROTOTYPE                                  31
++#define DUK_BIDX_MATH                                                 32
++#define DUK_BIDX_JSON                                                 33
++#define DUK_BIDX_TYPE_ERROR_THROWER                                   34
++#define DUK_BIDX_PROXY_CONSTRUCTOR                                    35
++#define DUK_BIDX_DUKTAPE                                              36
++#define DUK_BIDX_THREAD_CONSTRUCTOR                                   37
++#define DUK_BIDX_THREAD_PROTOTYPE                                     38
++#define DUK_BIDX_BUFFER_CONSTRUCTOR                                   39
++#define DUK_BIDX_BUFFER_PROTOTYPE                                     40
++#define DUK_BIDX_POINTER_CONSTRUCTOR                                  41
++#define DUK_BIDX_POINTER_PROTOTYPE                                    42
++#define DUK_BIDX_LOGGER_CONSTRUCTOR                                   43
++#define DUK_BIDX_LOGGER_PROTOTYPE                                     44
++#define DUK_BIDX_DOUBLE_ERROR                                         45
++
++#define DUK_NUM_BUILTINS                                              46
++
++#else
++#error invalid endianness defines
++#endif
++#endif  /* DUK_BUILTINS_H_INCLUDED */
++#line 50 "duk_internal.h"
++
++#line 1 "duk_strings.h"
++/*
++ *  Shared error messages: declarations and macros
++ *
++ *  Error messages are accessed through macros with fine-grained, explicit
++ *  error message distinctions.  Concrete error messages are selected by the
++ *  macros and multiple macros can map to the same concrete string to save
++ *  on code footprint.  This allows flexible footprint/verbosity tuning with
++ *  minimal code impact.  There are a few limitations to this approach:
++ *  (1) switching between plain messages and format strings doesn't work
++ *  conveniently, and (2) conditional strings are a bit awkward to handle.
++ *
++ *  Because format strings behave differently in the call site (they need to
++ *  be followed by format arguments), they have a special prefix (DUK_STR_FMT_
++ *  and duk_str_fmt_).
++ *
++ *  On some compilers using explicit shared strings is preferable; on others
++ *  it may be better to use straight literals because the compiler will combine
++ *  them anyway, and such strings won't end up unnecessarily in a symbol table.
++ */
++
++#ifndef DUK_ERRMSG_H_INCLUDED
++#define DUK_ERRMSG_H_INCLUDED
++
++#define DUK_STR_INTERNAL_ERROR duk_str_internal_error
++#define DUK_STR_INVALID_COUNT duk_str_invalid_count
++#define DUK_STR_INVALID_CALL_ARGS duk_str_invalid_call_args
++#define DUK_STR_NOT_CONSTRUCTABLE duk_str_not_constructable
++#define DUK_STR_NOT_CALLABLE duk_str_not_callable
++#define DUK_STR_NOT_EXTENSIBLE duk_str_not_extensible
++#define DUK_STR_NOT_WRITABLE duk_str_not_writable
++#define DUK_STR_NOT_CONFIGURABLE duk_str_not_configurable
++
++#if !defined(DUK_SINGLE_FILE)
++DUK_INTERNAL_DECL const char *duk_str_internal_error;
++DUK_INTERNAL_DECL const char *duk_str_invalid_count;
++DUK_INTERNAL_DECL const char *duk_str_invalid_call_args;
++DUK_INTERNAL_DECL const char *duk_str_not_constructable;
++DUK_INTERNAL_DECL const char *duk_str_not_callable;
++DUK_INTERNAL_DECL const char *duk_str_not_extensible;
++DUK_INTERNAL_DECL const char *duk_str_not_writable;
++DUK_INTERNAL_DECL const char *duk_str_not_configurable;
++#endif  /* !DUK_SINGLE_FILE */
++
++#define DUK_STR_INVALID_CONTEXT duk_str_invalid_context
++#define DUK_STR_INVALID_INDEX duk_str_invalid_index
++#define DUK_STR_PUSH_BEYOND_ALLOC_STACK duk_str_push_beyond_alloc_stack
++#define DUK_STR_NOT_UNDEFINED duk_str_not_undefined
++#define DUK_STR_NOT_NULL duk_str_not_null
++#define DUK_STR_NOT_BOOLEAN duk_str_not_boolean
++#define DUK_STR_NOT_NUMBER duk_str_not_number
++#define DUK_STR_NOT_STRING duk_str_not_string
++#define DUK_STR_NOT_POINTER duk_str_not_pointer
++#define DUK_STR_NOT_BUFFER duk_str_not_buffer
++#define DUK_STR_UNEXPECTED_TYPE duk_str_unexpected_type
++#define DUK_STR_NOT_THREAD duk_str_not_thread
++#if 0  /*unused*/
++#define DUK_STR_NOT_COMPILEDFUNCTION duk_str_not_compiledfunction
++#endif
++#define DUK_STR_NOT_NATIVEFUNCTION duk_str_not_nativefunction
++#define DUK_STR_NOT_C_FUNCTION duk_str_not_c_function
++#define DUK_STR_DEFAULTVALUE_COERCE_FAILED duk_str_defaultvalue_coerce_failed
++#define DUK_STR_NUMBER_OUTSIDE_RANGE duk_str_number_outside_range
++#define DUK_STR_NOT_OBJECT_COERCIBLE duk_str_not_object_coercible
++#define DUK_STR_STRING_TOO_LONG duk_str_string_too_long
++#define DUK_STR_BUFFER_TOO_LONG duk_str_buffer_too_long
++#define DUK_STR_SPRINTF_TOO_LONG duk_str_sprintf_too_long
++#define DUK_STR_OBJECT_ALLOC_FAILED duk_str_object_alloc_failed
++#define DUK_STR_THREAD_ALLOC_FAILED duk_str_thread_alloc_failed
++#define DUK_STR_FUNC_ALLOC_FAILED duk_str_func_alloc_failed
++#define DUK_STR_BUFFER_ALLOC_FAILED duk_str_buffer_alloc_failed
++#define DUK_STR_POP_TOO_MANY duk_str_pop_too_many
++#define DUK_STR_BUFFER_NOT_DYNAMIC duk_str_buffer_not_dynamic
++#define DUK_STR_FAILED_TO_EXTEND_VALSTACK duk_str_failed_to_extend_valstack
++#define DUK_STR_BASE64_ENCODE_FAILED duk_str_base64_encode_failed
++#define DUK_STR_BASE64_DECODE_FAILED duk_str_base64_decode_failed
++#define DUK_STR_HEX_DECODE_FAILED duk_str_hex_decode_failed
++#define DUK_STR_NO_SOURCECODE duk_str_no_sourcecode
++#define DUK_STR_CONCAT_RESULT_TOO_LONG duk_str_concat_result_too_long
++#define DUK_STR_UNIMPLEMENTED duk_str_unimplemented
++#define DUK_STR_ARRAY_LENGTH_OVER_2G duk_str_array_length_over_2g
++
++#if !defined(DUK_SINGLE_FILE)
++DUK_INTERNAL_DECL const char *duk_str_invalid_context;
++DUK_INTERNAL_DECL const char *duk_str_invalid_index;
++DUK_INTERNAL_DECL const char *duk_str_push_beyond_alloc_stack;
++DUK_INTERNAL_DECL const char *duk_str_not_undefined;
++DUK_INTERNAL_DECL const char *duk_str_not_null;
++DUK_INTERNAL_DECL const char *duk_str_not_boolean;
++DUK_INTERNAL_DECL const char *duk_str_not_number;
++DUK_INTERNAL_DECL const char *duk_str_not_string;
++DUK_INTERNAL_DECL const char *duk_str_not_pointer;
++DUK_INTERNAL_DECL const char *duk_str_not_buffer;
++DUK_INTERNAL_DECL const char *duk_str_unexpected_type;
++DUK_INTERNAL_DECL const char *duk_str_not_thread;
++#if 0  /*unused*/
++DUK_INTERNAL_DECL const char *duk_str_not_compiledfunction;
++#endif
++DUK_INTERNAL_DECL const char *duk_str_not_nativefunction;
++DUK_INTERNAL_DECL const char *duk_str_not_c_function;
++DUK_INTERNAL_DECL const char *duk_str_defaultvalue_coerce_failed;
++DUK_INTERNAL_DECL const char *duk_str_number_outside_range;
++DUK_INTERNAL_DECL const char *duk_str_not_object_coercible;
++DUK_INTERNAL_DECL const char *duk_str_string_too_long;
++DUK_INTERNAL_DECL const char *duk_str_buffer_too_long;
++DUK_INTERNAL_DECL const char *duk_str_sprintf_too_long;
++DUK_INTERNAL_DECL const char *duk_str_object_alloc_failed;
++DUK_INTERNAL_DECL const char *duk_str_thread_alloc_failed;
++DUK_INTERNAL_DECL const char *duk_str_func_alloc_failed;
++DUK_INTERNAL_DECL const char *duk_str_buffer_alloc_failed;
++DUK_INTERNAL_DECL const char *duk_str_pop_too_many;
++DUK_INTERNAL_DECL const char *duk_str_buffer_not_dynamic;
++DUK_INTERNAL_DECL const char *duk_str_failed_to_extend_valstack;
++DUK_INTERNAL_DECL const char *duk_str_base64_encode_failed;
++DUK_INTERNAL_DECL const char *duk_str_base64_decode_failed;
++DUK_INTERNAL_DECL const char *duk_str_hex_decode_failed;
++DUK_INTERNAL_DECL const char *duk_str_no_sourcecode;
++DUK_INTERNAL_DECL const char *duk_str_concat_result_too_long;
++DUK_INTERNAL_DECL const char *duk_str_unimplemented;
++DUK_INTERNAL_DECL const char *duk_str_array_length_over_2g;
++#endif  /* !DUK_SINGLE_FILE */
++
++#define DUK_STR_FMT_PTR duk_str_fmt_ptr
++#define DUK_STR_FMT_INVALID_JSON duk_str_fmt_invalid_json
++#define DUK_STR_JSONDEC_RECLIMIT duk_str_jsondec_reclimit
++#define DUK_STR_JSONENC_RECLIMIT duk_str_jsonenc_reclimit
++#define DUK_STR_CYCLIC_INPUT duk_str_cyclic_input
++
++#if !defined(DUK_SINGLE_FILE)
++DUK_INTERNAL_DECL const char *duk_str_fmt_ptr;
++DUK_INTERNAL_DECL const char *duk_str_fmt_invalid_json;
++DUK_INTERNAL_DECL const char *duk_str_jsondec_reclimit;
++DUK_INTERNAL_DECL const char *duk_str_jsonenc_reclimit;
++DUK_INTERNAL_DECL const char *duk_str_cyclic_input;
++#endif  /* !DUK_SINGLE_FILE */
++
++#define DUK_STR_PROXY_REVOKED duk_str_proxy_revoked
++#define DUK_STR_OBJECT_RESIZE_FAILED duk_str_object_resize_failed
++#define DUK_STR_INVALID_BASE duk_str_invalid_base
++#define DUK_STR_STRICT_CALLER_READ duk_str_strict_caller_read
++#define DUK_STR_PROXY_REJECTED duk_str_proxy_rejected
++#define DUK_STR_INVALID_ARRAY_LENGTH duk_str_invalid_array_length
++#define DUK_STR_ARRAY_LENGTH_WRITE_FAILED duk_str_array_length_write_failed
++#define DUK_STR_ARRAY_LENGTH_NOT_WRITABLE duk_str_array_length_not_writable
++#define DUK_STR_SETTER_UNDEFINED duk_str_setter_undefined
++#define DUK_STR_REDEFINE_VIRT_PROP duk_str_redefine_virt_prop
++#define DUK_STR_INVALID_DESCRIPTOR duk_str_invalid_descriptor
++#define DUK_STR_PROPERTY_IS_VIRTUAL duk_str_property_is_virtual
++
++#if !defined(DUK_SINGLE_FILE)
++DUK_INTERNAL_DECL const char *duk_str_proxy_revoked;
++DUK_INTERNAL_DECL const char *duk_str_object_resize_failed;
++DUK_INTERNAL_DECL const char *duk_str_invalid_base;
++DUK_INTERNAL_DECL const char *duk_str_strict_caller_read;
++DUK_INTERNAL_DECL const char *duk_str_proxy_rejected;
++DUK_INTERNAL_DECL const char *duk_str_invalid_array_length;
++DUK_INTERNAL_DECL const char *duk_str_array_length_write_failed;
++DUK_INTERNAL_DECL const char *duk_str_array_length_not_writable;
++DUK_INTERNAL_DECL const char *duk_str_setter_undefined;
++DUK_INTERNAL_DECL const char *duk_str_redefine_virt_prop;
++DUK_INTERNAL_DECL const char *duk_str_invalid_descriptor;
++DUK_INTERNAL_DECL const char *duk_str_property_is_virtual;
++#endif  /* !DUK_SINGLE_FILE */
++
++#define DUK_STR_PARSE_ERROR duk_str_parse_error
++#define DUK_STR_DUPLICATE_LABEL duk_str_duplicate_label
++#define DUK_STR_INVALID_LABEL duk_str_invalid_label
++#define DUK_STR_INVALID_ARRAY_LITERAL duk_str_invalid_array_literal
++#define DUK_STR_INVALID_OBJECT_LITERAL duk_str_invalid_object_literal
++#define DUK_STR_INVALID_VAR_DECLARATION duk_str_invalid_var_declaration
++#define DUK_STR_CANNOT_DELETE_IDENTIFIER duk_str_cannot_delete_identifier
++#define DUK_STR_INVALID_EXPRESSION duk_str_invalid_expression
++#define DUK_STR_INVALID_LVALUE duk_str_invalid_lvalue
++#define DUK_STR_EXPECTED_IDENTIFIER duk_str_expected_identifier
++#define DUK_STR_EMPTY_EXPR_NOT_ALLOWED duk_str_empty_expr_not_allowed
++#define DUK_STR_INVALID_FOR duk_str_invalid_for
++#define DUK_STR_INVALID_SWITCH duk_str_invalid_switch
++#define DUK_STR_INVALID_BREAK_CONT_LABEL duk_str_invalid_break_cont_label
++#define DUK_STR_INVALID_RETURN duk_str_invalid_return
++#define DUK_STR_INVALID_TRY duk_str_invalid_try
++#define DUK_STR_INVALID_THROW duk_str_invalid_throw
++#define DUK_STR_WITH_IN_STRICT_MODE duk_str_with_in_strict_mode
++#define DUK_STR_FUNC_STMT_NOT_ALLOWED duk_str_func_stmt_not_allowed
++#define DUK_STR_UNTERMINATED_STMT duk_str_unterminated_stmt
++#define DUK_STR_INVALID_ARG_NAME duk_str_invalid_arg_name
++#define DUK_STR_INVALID_FUNC_NAME duk_str_invalid_func_name
++#define DUK_STR_INVALID_GETSET_NAME duk_str_invalid_getset_name
++#define DUK_STR_FUNC_NAME_REQUIRED duk_str_func_name_required
++
++#if !defined(DUK_SINGLE_FILE)
++DUK_INTERNAL_DECL const char *duk_str_parse_error;
++DUK_INTERNAL_DECL const char *duk_str_duplicate_label;
++DUK_INTERNAL_DECL const char *duk_str_invalid_label;
++DUK_INTERNAL_DECL const char *duk_str_invalid_array_literal;
++DUK_INTERNAL_DECL const char *duk_str_invalid_object_literal;
++DUK_INTERNAL_DECL const char *duk_str_invalid_var_declaration;
++DUK_INTERNAL_DECL const char *duk_str_cannot_delete_identifier;
++DUK_INTERNAL_DECL const char *duk_str_invalid_expression;
++DUK_INTERNAL_DECL const char *duk_str_invalid_lvalue;
++DUK_INTERNAL_DECL const char *duk_str_expected_identifier;
++DUK_INTERNAL_DECL const char *duk_str_empty_expr_not_allowed;
++DUK_INTERNAL_DECL const char *duk_str_invalid_for;
++DUK_INTERNAL_DECL const char *duk_str_invalid_switch;
++DUK_INTERNAL_DECL const char *duk_str_invalid_break_cont_label;
++DUK_INTERNAL_DECL const char *duk_str_invalid_return;
++DUK_INTERNAL_DECL const char *duk_str_invalid_try;
++DUK_INTERNAL_DECL const char *duk_str_invalid_throw;
++DUK_INTERNAL_DECL const char *duk_str_with_in_strict_mode;
++DUK_INTERNAL_DECL const char *duk_str_func_stmt_not_allowed;
++DUK_INTERNAL_DECL const char *duk_str_unterminated_stmt;
++DUK_INTERNAL_DECL const char *duk_str_invalid_arg_name;
++DUK_INTERNAL_DECL const char *duk_str_invalid_func_name;
++DUK_INTERNAL_DECL const char *duk_str_invalid_getset_name;
++DUK_INTERNAL_DECL const char *duk_str_func_name_required;
++#endif  /* !DUK_SINGLE_FILE */
++
++#define DUK_STR_INTERNAL_ERROR_EXEC_LONGJMP duk_str_internal_error_exec_longjmp
++
++#if !defined(DUK_SINGLE_FILE)
++DUK_INTERNAL_DECL const char *duk_str_internal_error_exec_longjmp;
++#endif  /* !DUK_SINGLE_FILE */
++
++#define DUK_STR_INVALID_QUANTIFIER_NO_ATOM duk_str_invalid_quantifier_no_atom
++#define DUK_STR_INVALID_QUANTIFIER_VALUES duk_str_invalid_quantifier_values
++#define DUK_STR_QUANTIFIER_TOO_MANY_COPIES duk_str_quantifier_too_many_copies
++#define DUK_STR_UNEXPECTED_CLOSING_PAREN duk_str_unexpected_closing_paren
++#define DUK_STR_UNEXPECTED_END_OF_PATTERN duk_str_unexpected_end_of_pattern
++#define DUK_STR_UNEXPECTED_REGEXP_TOKEN duk_str_unexpected_regexp_token
++#define DUK_STR_INVALID_REGEXP_FLAGS duk_str_invalid_regexp_flags
++#define DUK_STR_INVALID_BACKREFS duk_str_invalid_backrefs
++#define DUK_STR_REGEXP_BACKTRACK_FAILED duk_str_regexp_backtrack_failed
++#define DUK_STR_REGEXP_ADVANCE_FAILED duk_str_regexp_advance_failed
++#define DUK_STR_REGEXP_INTERNAL_ERROR duk_str_regexp_internal_error
++
++#if !defined(DUK_SINGLE_FILE)
++DUK_INTERNAL_DECL const char *duk_str_invalid_quantifier_no_atom;
++DUK_INTERNAL_DECL const char *duk_str_invalid_quantifier_values;
++DUK_INTERNAL_DECL const char *duk_str_quantifier_too_many_copies;
++DUK_INTERNAL_DECL const char *duk_str_unexpected_closing_paren;
++DUK_INTERNAL_DECL const char *duk_str_unexpected_end_of_pattern;
++DUK_INTERNAL_DECL const char *duk_str_unexpected_regexp_token;
++DUK_INTERNAL_DECL const char *duk_str_invalid_regexp_flags;
++DUK_INTERNAL_DECL const char *duk_str_invalid_backrefs;
++DUK_INTERNAL_DECL const char *duk_str_regexp_backtrack_failed;
++DUK_INTERNAL_DECL const char *duk_str_regexp_advance_failed;
++DUK_INTERNAL_DECL const char *duk_str_regexp_internal_error;
++#endif  /* !DUK_SINGLE_FILE */
++
++#define DUK_STR_VALSTACK_LIMIT duk_str_valstack_limit
++#define DUK_STR_CALLSTACK_LIMIT duk_str_callstack_limit
++#define DUK_STR_CATCHSTACK_LIMIT duk_str_catchstack_limit
++#define DUK_STR_OBJECT_PROPERTY_LIMIT duk_str_object_property_limit
++#define DUK_STR_PROTOTYPE_CHAIN_LIMIT duk_str_prototype_chain_limit
++#define DUK_STR_BOUND_CHAIN_LIMIT duk_str_bound_chain_limit
++#define DUK_STR_C_CALLSTACK_LIMIT duk_str_c_callstack_limit
++#define DUK_STR_COMPILER_RECURSION_LIMIT duk_str_compiler_recursion_limit
++#define DUK_STR_BYTECODE_LIMIT duk_str_bytecode_limit
++#define DUK_STR_REG_LIMIT duk_str_reg_limit
++#define DUK_STR_TEMP_LIMIT duk_str_temp_limit
++#define DUK_STR_CONST_LIMIT duk_str_const_limit
++#define DUK_STR_FUNC_LIMIT duk_str_func_limit
++#define DUK_STR_REGEXP_COMPILER_RECURSION_LIMIT duk_str_regexp_compiler_recursion_limit
++#define DUK_STR_REGEXP_EXECUTOR_RECURSION_LIMIT duk_str_regexp_executor_recursion_limit
++#define DUK_STR_REGEXP_EXECUTOR_STEP_LIMIT duk_str_regexp_executor_step_limit
++
++#if !defined(DUK_SINGLE_FILE)
++DUK_INTERNAL_DECL const char *duk_str_valstack_limit;
++DUK_INTERNAL_DECL const char *duk_str_callstack_limit;
++DUK_INTERNAL_DECL const char *duk_str_catchstack_limit;
++DUK_INTERNAL_DECL const char *duk_str_object_property_limit;
++DUK_INTERNAL_DECL const char *duk_str_prototype_chain_limit;
++DUK_INTERNAL_DECL const char *duk_str_bound_chain_limit;
++DUK_INTERNAL_DECL const char *duk_str_c_callstack_limit;
++DUK_INTERNAL_DECL const char *duk_str_compiler_recursion_limit;
++DUK_INTERNAL_DECL const char *duk_str_bytecode_limit;
++DUK_INTERNAL_DECL const char *duk_str_reg_limit;
++DUK_INTERNAL_DECL const char *duk_str_temp_limit;
++DUK_INTERNAL_DECL const char *duk_str_const_limit;
++DUK_INTERNAL_DECL const char *duk_str_func_limit;
++DUK_INTERNAL_DECL const char *duk_str_regexp_compiler_recursion_limit;
++DUK_INTERNAL_DECL const char *duk_str_regexp_executor_recursion_limit;
++DUK_INTERNAL_DECL const char *duk_str_regexp_executor_step_limit;
++#endif  /* !DUK_SINGLE_FILE */
++
++#define DUK_STR_ANON duk_str_anon
++#define DUK_STR_REALLOC_FAILED duk_str_realloc_failed
++
++#if !defined(DUK_SINGLE_FILE)
++DUK_INTERNAL_DECL const char *duk_str_anon;
++DUK_INTERNAL_DECL const char *duk_str_realloc_failed;
++#endif  /* !DUK_SINGLE_FILE */
++
++#endif  /* DUK_ERRMSG_H_INCLUDED */
++#line 1 "duk_js_bytecode.h"
++/*
++ *  Ecmascript bytecode
++ */
++
++#ifndef DUK_JS_BYTECODE_H_INCLUDED
++#define DUK_JS_BYTECODE_H_INCLUDED
++
++/*
++ *  Logical instruction layout
++ *  ==========================
++ *
++ *  !3!3!2!2!2!2!2!2!2!2!2!2!1!1!1!1!1!1!1!1!1!1! ! ! ! ! ! ! ! ! ! !
++ *  !1!0!9!8!7!6!5!4!3!2!1!0!9!8!7!6!5!4!3!2!1!0!9!8!7!6!5!4!3!2!1!0!
++ *  +---------------------------------------------------+-----------+
++ *  !       C         !       B         !      A        !    OP     !
++ *  +---------------------------------------------------+-----------+
++ *
++ *  OP (6 bits):  opcode (DUK_OP_*), access should be fastest
++ *  A (8 bits):   typically a target register number
++ *  B (9 bits):   typically first source register/constant number
++ *  C (9 bits):   typically second source register/constant number
++ *
++ *  Some instructions combine BC or ABC together for larger parameter values.
++ *  Signed integers (e.g. jump offsets) are encoded as unsigned, with an opcode
++ *  specific bias.  B and C may denote a register or a constant, see
++ *  DUK_BC_ISREG() and DUK_BC_ISCONST().
++ *
++ *  Note: macro naming is a bit misleading, e.g. "ABC" in macro name but
++ *  the field layout is logically "CBA".
++ */
++
++typedef duk_uint32_t duk_instr_t;
++
++#define DUK_DEC_OP(x)               ((x) & 0x3fUL)
++#define DUK_DEC_A(x)                (((x) >> 6) & 0xffUL)
++#define DUK_DEC_B(x)                (((x) >> 14) & 0x1ffUL)
++#define DUK_DEC_C(x)                (((x) >> 23) & 0x1ffUL)
++#define DUK_DEC_BC(x)               (((x) >> 14) & 0x3ffffUL)
++#define DUK_DEC_ABC(x)              (((x) >> 6) & 0x3ffffffUL)
++
++#define DUK_ENC_OP(op)              ((duk_instr_t) (op))
++#define DUK_ENC_OP_ABC(op,abc)      ((duk_instr_t) ( \
++                                        (((duk_instr_t) (abc)) << 6) | \
++                                        ((duk_instr_t) (op)) \
++                                    ))
++#define DUK_ENC_OP_A_BC(op,a,bc)    ((duk_instr_t) ( \
++                                        (((duk_instr_t) (bc)) << 14) | \
++                                        (((duk_instr_t) (a)) << 6) | \
++                                        ((duk_instr_t) (op)) \
++                                    ))
++#define DUK_ENC_OP_A_B_C(op,a,b,c)  ((duk_instr_t) ( \
++                                        (((duk_instr_t) (c)) << 23) | \
++                                        (((duk_instr_t) (b)) << 14) | \
++                                        (((duk_instr_t) (a)) << 6) | \
++                                        ((duk_instr_t) (op)) \
++                                    ))
++#define DUK_ENC_OP_A_B(op,a,b)      DUK_ENC_OP_A_B_C(op,a,b,0)
++#define DUK_ENC_OP_A(op,a)          DUK_ENC_OP_A_B_C(op,a,0,0)
++
++/* Constants should be signed so that signed arithmetic involving them
++ * won't cause values to be coerced accidentally to unsigned.
++ */
++#define DUK_BC_OP_MIN               0
++#define DUK_BC_OP_MAX               0x3fL
++#define DUK_BC_A_MIN                0
++#define DUK_BC_A_MAX                0xffL
++#define DUK_BC_B_MIN                0
++#define DUK_BC_B_MAX                0x1ffL
++#define DUK_BC_C_MIN                0
++#define DUK_BC_C_MAX                0x1ffL
++#define DUK_BC_BC_MIN               0
++#define DUK_BC_BC_MAX               0x3ffffL
++#define DUK_BC_ABC_MIN              0
++#define DUK_BC_ABC_MAX              0x3ffffffL
++#define DUK_BC_EXTRAOP_MIN          DUK_BC_A_MIN
++#define DUK_BC_EXTRAOP_MAX          DUK_BC_A_MAX
++
++#define DUK_OP_LDREG                0
++#define DUK_OP_STREG                1
++#define DUK_OP_LDCONST              2
++#define DUK_OP_LDINT                3
++#define DUK_OP_LDINTX               4
++#define DUK_OP_MPUTOBJ              5
++#define DUK_OP_MPUTOBJI             6
++#define DUK_OP_MPUTARR              7
++#define DUK_OP_MPUTARRI             8
++#define DUK_OP_NEW                  9
++#define DUK_OP_NEWI                 10
++#define DUK_OP_REGEXP               11
++#define DUK_OP_CSREG                12
++#define DUK_OP_CSREGI               13
++#define DUK_OP_GETVAR               14
++#define DUK_OP_PUTVAR               15
++#define DUK_OP_DECLVAR              16
++#define DUK_OP_DELVAR               17
++#define DUK_OP_CSVAR                18
++#define DUK_OP_CSVARI               19
++#define DUK_OP_CLOSURE              20
++#define DUK_OP_GETPROP              21
++#define DUK_OP_PUTPROP              22
++#define DUK_OP_DELPROP              23
++#define DUK_OP_CSPROP               24
++#define DUK_OP_CSPROPI              25
++#define DUK_OP_ADD                  26
++#define DUK_OP_SUB                  27
++#define DUK_OP_MUL                  28
++#define DUK_OP_DIV                  29
++#define DUK_OP_MOD                  30
++#define DUK_OP_BAND                 31
++#define DUK_OP_BOR                  32
++#define DUK_OP_BXOR                 33
++#define DUK_OP_BASL                 34
++#define DUK_OP_BLSR                 35
++#define DUK_OP_BASR                 36
++#define DUK_OP_EQ                   37
++#define DUK_OP_NEQ                  38
++#define DUK_OP_SEQ                  39
++#define DUK_OP_SNEQ                 40
++#define DUK_OP_GT                   41
++#define DUK_OP_GE                   42
++#define DUK_OP_LT                   43
++#define DUK_OP_LE                   44
++#define DUK_OP_IF                   45
++#define DUK_OP_JUMP                 46
++#define DUK_OP_RETURN               47
++#define DUK_OP_CALL                 48
++#define DUK_OP_CALLI                49
++#define DUK_OP_TRYCATCH             50
++#define DUK_OP_EXTRA                51
++#define DUK_OP_PREINCR              52  /* pre/post opcode values have constraints, */
++#define DUK_OP_PREDECR              53  /* see duk_js_executor.c */
++#define DUK_OP_POSTINCR             54
++#define DUK_OP_POSTDECR             55
++#define DUK_OP_PREINCV              56
++#define DUK_OP_PREDECV              57
++#define DUK_OP_POSTINCV             58
++#define DUK_OP_POSTDECV             59
++#define DUK_OP_PREINCP              60
++#define DUK_OP_PREDECP              61
++#define DUK_OP_POSTINCP             62
++#define DUK_OP_POSTDECP             63
++#define DUK_OP_NONE                 64  /* dummy value used as marker */
++
++/* DUK_OP_EXTRA, sub-operation in A */
++#define DUK_EXTRAOP_NOP             0
++#define DUK_EXTRAOP_INVALID         1
++#define DUK_EXTRAOP_LDTHIS          2
++#define DUK_EXTRAOP_LDUNDEF         3
++#define DUK_EXTRAOP_LDNULL          4
++#define DUK_EXTRAOP_LDTRUE          5
++#define DUK_EXTRAOP_LDFALSE         6
++#define DUK_EXTRAOP_NEWOBJ          7
++#define DUK_EXTRAOP_NEWARR          8
++#define DUK_EXTRAOP_SETALEN         9
++#define DUK_EXTRAOP_TYPEOF          10
++#define DUK_EXTRAOP_TYPEOFID        11
++#define DUK_EXTRAOP_INITENUM        12
++#define DUK_EXTRAOP_NEXTENUM        13
++#define DUK_EXTRAOP_INITSET         14
++#define DUK_EXTRAOP_INITSETI        15
++#define DUK_EXTRAOP_INITGET         16
++#define DUK_EXTRAOP_INITGETI        17
++#define DUK_EXTRAOP_ENDTRY          18
++#define DUK_EXTRAOP_ENDCATCH        19
++#define DUK_EXTRAOP_ENDFIN          20
++#define DUK_EXTRAOP_THROW           21
++#define DUK_EXTRAOP_INVLHS          22
++#define DUK_EXTRAOP_UNM             23
++#define DUK_EXTRAOP_UNP             24
++#define DUK_EXTRAOP_DEBUGGER        25
++#define DUK_EXTRAOP_BREAK           26
++#define DUK_EXTRAOP_CONTINUE        27
++#define DUK_EXTRAOP_BNOT            28
++#define DUK_EXTRAOP_LNOT            29
++#define DUK_EXTRAOP_INSTOF          30
++#define DUK_EXTRAOP_IN              31
++#define DUK_EXTRAOP_LABEL           32
++#define DUK_EXTRAOP_ENDLABEL        33
++
++/* DUK_OP_EXTRA for debugging */
++#define DUK_EXTRAOP_DUMPREG         128
++#define DUK_EXTRAOP_DUMPREGS        129
++#define DUK_EXTRAOP_LOGMARK         130
++
++/* DUK_OP_CALL flags in A */
++#define DUK_BC_CALL_FLAG_TAILCALL           (1 << 0)
++#define DUK_BC_CALL_FLAG_EVALCALL           (1 << 1)
++
++/* DUK_OP_TRYCATCH flags in A */
++#define DUK_BC_TRYCATCH_FLAG_HAVE_CATCH     (1 << 0)
++#define DUK_BC_TRYCATCH_FLAG_HAVE_FINALLY   (1 << 1)
++#define DUK_BC_TRYCATCH_FLAG_CATCH_BINDING  (1 << 2)
++#define DUK_BC_TRYCATCH_FLAG_WITH_BINDING   (1 << 3)
++
++/* DUK_OP_RETURN flags in A */
++#define DUK_BC_RETURN_FLAG_FAST             (1 << 0)
++#define DUK_BC_RETURN_FLAG_HAVE_RETVAL      (1 << 1)
++
++/* DUK_OP_DECLVAR flags in A; bottom bits are reserved for propdesc flags (DUK_PROPDESC_FLAG_XXX) */
++#define DUK_BC_DECLVAR_FLAG_UNDEF_VALUE     (1 << 4)  /* use 'undefined' for value automatically */
++#define DUK_BC_DECLVAR_FLAG_FUNC_DECL       (1 << 5)  /* function declaration */
++
++/* misc constants and helper macros */
++#define DUK_BC_REGLIMIT             256  /* if B/C is >= this value, refers to a const */
++#define DUK_BC_ISREG(x)             ((x) < DUK_BC_REGLIMIT)
++#define DUK_BC_ISCONST(x)           ((x) >= DUK_BC_REGLIMIT)
++#define DUK_BC_LDINT_BIAS           (1L << 17)
++#define DUK_BC_LDINTX_SHIFT         18
++#define DUK_BC_JUMP_BIAS            (1L << 25)
++
++#endif  /* DUK_JS_BYTECODE_H_INCLUDED */
++#line 1 "duk_lexer.h"
++/*
++ *  Lexer defines.
++ */
++
++#ifndef DUK_LEXER_H_INCLUDED
++#define DUK_LEXER_H_INCLUDED
++
++typedef void (*duk_re_range_callback)(void *user, duk_codepoint_t r1, duk_codepoint_t r2, duk_bool_t direct);
++
++/*
++ *  A token is interpreted as any possible production of InputElementDiv
++ *  and InputElementRegExp, see E5 Section 7 in its entirety.  Note that
++ *  the E5 "Token" production does not cover all actual tokens of the
++ *  language (which is explicitly stated in the specification, Section 7.5).
++ *  Null and boolean literals are defined as part of both ReservedWord
++ *  (E5 Section 7.6.1) and Literal (E5 Section 7.8) productions.  Here,
++ *  null and boolean values have literal tokens, and are not reserved
++ *  words.
++ *
++ *  Decimal literal negative/positive sign is -not- part of DUK_TOK_NUMBER.
++ *  The number tokens always have a non-negative value.  The unary minus
++ *  operator in "-1.0" is optimized during compilation to yield a single
++ *  negative constant.
++ *
++ *  Token numbering is free except that reserved words are required to be
++ *  in a continuous range and in a particular order.  See genstrings.py.
++ */
++
++#define DUK_LEXER_INITCTX(ctx)        duk_lexer_initctx((ctx))
++
++#define DUK_LEXER_SETPOINT(ctx,pt)    duk_lexer_setpoint((ctx), (pt))
++
++#define DUK_LEXER_GETPOINT(ctx,pt)    do { (pt)->offset = (ctx)->offsets[0]; \
++                                           (pt)->line = (ctx)->lines[0]; } while (0)
++
++/* currently 6 characters of lookup are actually needed (duk_lexer.c) */
++#define DUK_LEXER_WINDOW_SIZE                     8
++
++#define DUK_TOK_MINVAL                            0
++
++/* returned after EOF (infinite amount) */
++#define DUK_TOK_EOF                               0
++
++/* line terminator or multi-line comment with internal lineterm (E5 Sections 7.3, 7.4) */
++#define DUK_TOK_LINETERM                          1
++
++/* single-line comment or multi-line comment without internal lineterm (E5 Section 7.4) */
++#define DUK_TOK_COMMENT                           2
++
++/* identifier names (E5 Section 7.6) */
++#define DUK_TOK_IDENTIFIER                        3
++
++/* reserved words: keywords */
++#define DUK_TOK_START_RESERVED                    4
++#define DUK_TOK_BREAK                             4
++#define DUK_TOK_CASE                              5
++#define DUK_TOK_CATCH                             6
++#define DUK_TOK_CONTINUE                          7
++#define DUK_TOK_DEBUGGER                          8
++#define DUK_TOK_DEFAULT                           9
++#define DUK_TOK_DELETE                            10
++#define DUK_TOK_DO                                11
++#define DUK_TOK_ELSE                              12
++#define DUK_TOK_FINALLY                           13
++#define DUK_TOK_FOR                               14
++#define DUK_TOK_FUNCTION                          15
++#define DUK_TOK_IF                                16
++#define DUK_TOK_IN                                17
++#define DUK_TOK_INSTANCEOF                        18
++#define DUK_TOK_NEW                               19
++#define DUK_TOK_RETURN                            20
++#define DUK_TOK_SWITCH                            21
++#define DUK_TOK_THIS                              22
++#define DUK_TOK_THROW                             23
++#define DUK_TOK_TRY                               24
++#define DUK_TOK_TYPEOF                            25
++#define DUK_TOK_VAR                               26
++#define DUK_TOK_VOID                              27
++#define DUK_TOK_WHILE                             28
++#define DUK_TOK_WITH                              29
++
++/* reserved words: future reserved words */
++#define DUK_TOK_CLASS                             30
++#define DUK_TOK_CONST                             31
++#define DUK_TOK_ENUM                              32
++#define DUK_TOK_EXPORT                            33
++#define DUK_TOK_EXTENDS                           34
++#define DUK_TOK_IMPORT                            35
++#define DUK_TOK_SUPER                             36
++
++/* "null", "true", and "false" are always reserved words.
++ * Note that "get" and "set" are not!
++ */
++#define DUK_TOK_NULL                              37
++#define DUK_TOK_TRUE                              38
++#define DUK_TOK_FALSE                             39
++
++/* reserved words: additional future reserved words in strict mode */
++#define DUK_TOK_START_STRICT_RESERVED             40  /* inclusive */
++#define DUK_TOK_IMPLEMENTS                        40
++#define DUK_TOK_INTERFACE                         41
++#define DUK_TOK_LET                               42
++#define DUK_TOK_PACKAGE                           43
++#define DUK_TOK_PRIVATE                           44
++#define DUK_TOK_PROTECTED                         45
++#define DUK_TOK_PUBLIC                            46
++#define DUK_TOK_STATIC                            47
++#define DUK_TOK_YIELD                             48
++
++#define DUK_TOK_END_RESERVED                      49  /* exclusive */
++
++/* "get" and "set" are tokens but NOT ReservedWords.  They are currently
++ * parsed and identifiers and these defines are actually now unused.
++ */
++#define DUK_TOK_GET                               49
++#define DUK_TOK_SET                               50
++
++/* punctuators (unlike the spec, also includes "/" and "/=") */
++#define DUK_TOK_LCURLY                            51
++#define DUK_TOK_RCURLY                            52
++#define DUK_TOK_LBRACKET                          53
++#define DUK_TOK_RBRACKET                          54
++#define DUK_TOK_LPAREN                            55
++#define DUK_TOK_RPAREN                            56
++#define DUK_TOK_PERIOD                            57
++#define DUK_TOK_SEMICOLON                         58
++#define DUK_TOK_COMMA                             59
++#define DUK_TOK_LT                                60
++#define DUK_TOK_GT                                61
++#define DUK_TOK_LE                                62
++#define DUK_TOK_GE                                63
++#define DUK_TOK_EQ                                64
++#define DUK_TOK_NEQ                               65
++#define DUK_TOK_SEQ                               66
++#define DUK_TOK_SNEQ                              67
++#define DUK_TOK_ADD                               68
++#define DUK_TOK_SUB                               69
++#define DUK_TOK_MUL                               70
++#define DUK_TOK_DIV                               71
++#define DUK_TOK_MOD                               72
++#define DUK_TOK_INCREMENT                         73
++#define DUK_TOK_DECREMENT                         74
++#define DUK_TOK_ALSHIFT                           75  /* named "arithmetic" because result is signed */
++#define DUK_TOK_ARSHIFT                           76
++#define DUK_TOK_RSHIFT                            77
++#define DUK_TOK_BAND                              78
++#define DUK_TOK_BOR                               79
++#define DUK_TOK_BXOR                              80
++#define DUK_TOK_LNOT                              81
++#define DUK_TOK_BNOT                              82
++#define DUK_TOK_LAND                              83
++#define DUK_TOK_LOR                               84
++#define DUK_TOK_QUESTION                          85
++#define DUK_TOK_COLON                             86
++#define DUK_TOK_EQUALSIGN                         87
++#define DUK_TOK_ADD_EQ                            88
++#define DUK_TOK_SUB_EQ                            89
++#define DUK_TOK_MUL_EQ                            90
++#define DUK_TOK_DIV_EQ                            91
++#define DUK_TOK_MOD_EQ                            92
++#define DUK_TOK_ALSHIFT_EQ                        93
++#define DUK_TOK_ARSHIFT_EQ                        94
++#define DUK_TOK_RSHIFT_EQ                         95
++#define DUK_TOK_BAND_EQ                           96
++#define DUK_TOK_BOR_EQ                            97
++#define DUK_TOK_BXOR_EQ                           98
++
++/* literals (E5 Section 7.8), except null, true, false, which are treated
++ * like reserved words (above).
++ */
++#define DUK_TOK_NUMBER                            99
++#define DUK_TOK_STRING                            100
++#define DUK_TOK_REGEXP                            101
++
++#define DUK_TOK_MAXVAL                            101  /* inclusive */
++
++/* Convert heap string index to a token (reserved words) */
++#define DUK_STRIDX_TO_TOK(x)                        ((x) - DUK_STRIDX_START_RESERVED + DUK_TOK_START_RESERVED)
++
++/* Sanity check */
++#if (DUK_TOK_MAXVAL > 255)
++#error DUK_TOK_MAXVAL too large, code assumes it fits into 8 bits
++#endif
++
++/* Sanity checks for string and token defines */
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_BREAK) != DUK_TOK_BREAK)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_CASE) != DUK_TOK_CASE)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_CATCH) != DUK_TOK_CATCH)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_CONTINUE) != DUK_TOK_CONTINUE)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_DEBUGGER) != DUK_TOK_DEBUGGER)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_DEFAULT) != DUK_TOK_DEFAULT)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_DELETE) != DUK_TOK_DELETE)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_DO) != DUK_TOK_DO)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_ELSE) != DUK_TOK_ELSE)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_FINALLY) != DUK_TOK_FINALLY)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_FOR) != DUK_TOK_FOR)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_LC_FUNCTION) != DUK_TOK_FUNCTION)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_IF) != DUK_TOK_IF)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_IN) != DUK_TOK_IN)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_INSTANCEOF) != DUK_TOK_INSTANCEOF)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_NEW) != DUK_TOK_NEW)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_RETURN) != DUK_TOK_RETURN)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_SWITCH) != DUK_TOK_SWITCH)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_THIS) != DUK_TOK_THIS)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_THROW) != DUK_TOK_THROW)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_TRY) != DUK_TOK_TRY)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_TYPEOF) != DUK_TOK_TYPEOF)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_VAR) != DUK_TOK_VAR)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_VOID) != DUK_TOK_VOID)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_WHILE) != DUK_TOK_WHILE)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_WITH) != DUK_TOK_WITH)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_CLASS) != DUK_TOK_CLASS)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_CONST) != DUK_TOK_CONST)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_ENUM) != DUK_TOK_ENUM)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_EXPORT) != DUK_TOK_EXPORT)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_EXTENDS) != DUK_TOK_EXTENDS)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_IMPORT) != DUK_TOK_IMPORT)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_SUPER) != DUK_TOK_SUPER)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_LC_NULL) != DUK_TOK_NULL)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_TRUE) != DUK_TOK_TRUE)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_FALSE) != DUK_TOK_FALSE)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_IMPLEMENTS) != DUK_TOK_IMPLEMENTS)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_INTERFACE) != DUK_TOK_INTERFACE)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_LET) != DUK_TOK_LET)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_PACKAGE) != DUK_TOK_PACKAGE)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_PRIVATE) != DUK_TOK_PRIVATE)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_PROTECTED) != DUK_TOK_PROTECTED)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_PUBLIC) != DUK_TOK_PUBLIC)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_STATIC) != DUK_TOK_STATIC)
++#error mismatch in token defines
++#endif
++#if (DUK_STRIDX_TO_TOK(DUK_STRIDX_YIELD) != DUK_TOK_YIELD)
++#error mismatch in token defines
++#endif
++
++/* Regexp tokens */
++#define DUK_RETOK_EOF                              0
++#define DUK_RETOK_DISJUNCTION                      1
++#define DUK_RETOK_QUANTIFIER                       2
++#define DUK_RETOK_ASSERT_START                     3
++#define DUK_RETOK_ASSERT_END                       4
++#define DUK_RETOK_ASSERT_WORD_BOUNDARY             5
++#define DUK_RETOK_ASSERT_NOT_WORD_BOUNDARY         6
++#define DUK_RETOK_ASSERT_START_POS_LOOKAHEAD       7
++#define DUK_RETOK_ASSERT_START_NEG_LOOKAHEAD       8
++#define DUK_RETOK_ATOM_PERIOD                      9
++#define DUK_RETOK_ATOM_CHAR                        10
++#define DUK_RETOK_ATOM_DIGIT                       11
++#define DUK_RETOK_ATOM_NOT_DIGIT                   12
++#define DUK_RETOK_ATOM_WHITE                       13
++#define DUK_RETOK_ATOM_NOT_WHITE                   14
++#define DUK_RETOK_ATOM_WORD_CHAR                   15
++#define DUK_RETOK_ATOM_NOT_WORD_CHAR               16
++#define DUK_RETOK_ATOM_BACKREFERENCE               17
++#define DUK_RETOK_ATOM_START_CAPTURE_GROUP         18
++#define DUK_RETOK_ATOM_START_NONCAPTURE_GROUP      19
++#define DUK_RETOK_ATOM_START_CHARCLASS             20
++#define DUK_RETOK_ATOM_START_CHARCLASS_INVERTED    21
++#define DUK_RETOK_ATOM_END_GROUP                   22
++
++/* constants for duk_lexer_ctx.buf */
++#define DUK_LEXER_TEMP_BUF_INITIAL                 64
++#define DUK_LEXER_TEMP_BUF_LIMIT                   256
++
++/* A token value.  Can be memcpy()'d, but note that slot1/slot2 values are on the valstack. */
++struct duk_token {
++	duk_small_int_t t;            /* token type (with reserved word identification) */
++	duk_small_int_t t_nores;      /* token type (with reserved words as DUK_TOK_IDENTIFER) */
++	duk_double_t num;             /* numeric value of token */
++	duk_hstring *str1;            /* string 1 of token (borrowed, stored to ctx->slot1_idx) */
++	duk_hstring *str2;            /* string 2 of token (borrowed, stored to ctx->slot1_idx) */
++	duk_size_t start_offset;      /* start byte offset of token in lexer input */
++	duk_int_t start_line;         /* start line of token (first char) */
++	duk_int_t num_escapes;        /* number of escapes and line continuations (for directive prologue) */
++	duk_bool_t lineterm;          /* token was preceded by a lineterm */
++	duk_bool_t allow_auto_semi;   /* token allows automatic semicolon insertion (eof or preceded by newline) */
++};
++
++#define DUK_RE_QUANTIFIER_INFINITE         ((duk_uint32_t) 0xffffffffUL)
++
++/* A regexp token value. */
++struct duk_re_token {
++	duk_small_int_t t;           /* token type */
++	duk_small_int_t greedy;
++	duk_uint_fast32_t num;       /* numeric value (character, count) */
++	duk_uint_fast32_t qmin;
++	duk_uint_fast32_t qmax;
++};
++
++/* A structure for 'snapshotting' a point for rewinding */
++struct duk_lexer_point {
++	duk_size_t offset;
++	duk_int_t line;
++};
++
++/* Lexer context.  Same context is used for Ecmascript and Regexp parsing. */
++struct duk_lexer_ctx {
++	duk_hthread *thr;                              /* thread; minimizes argument passing */
++
++	const duk_uint8_t *input;                      /* input string (may be a user pointer) */
++	duk_size_t input_length;                       /* input byte length */
++	duk_size_t input_offset;                       /* input offset for window leading edge (not window[0]) */
++
++	duk_codepoint_t window[DUK_LEXER_WINDOW_SIZE]; /* window of unicode code points */
++	duk_size_t offsets[DUK_LEXER_WINDOW_SIZE];     /* input byte offset for each char */
++	duk_int_t lines[DUK_LEXER_WINDOW_SIZE];        /* input lines for each char */
++	duk_int_t input_line;                          /* input linenumber at input_offset (not window[0]), init to 1 */
++	duk_idx_t slot1_idx;                           /* valstack slot for 1st token value */
++	duk_idx_t slot2_idx;                           /* valstack slot for 2nd token value */
++	duk_idx_t buf_idx;                             /* valstack slot for temp buffer */
++	duk_hbuffer_dynamic *buf;                      /* temp accumulation buffer (on valstack) */
++
++	duk_int_t token_count;                         /* number of tokens parsed */
++	duk_int_t token_limit;                         /* maximum token count before error (sanity backstop) */
++};
++
++/*
++ *  Prototypes
++ */
++
++DUK_INTERNAL_DECL void duk_lexer_initctx(duk_lexer_ctx *lex_ctx);
++
++DUK_INTERNAL_DECL void duk_lexer_setpoint(duk_lexer_ctx *lex_ctx, duk_lexer_point *pt);
++
++DUK_INTERNAL_DECL
++void duk_lexer_parse_js_input_element(duk_lexer_ctx *lex_ctx,
++                                      duk_token *out_token,
++                                      duk_bool_t strict_mode,
++                                      duk_bool_t regexp_mode);
++#ifdef DUK_USE_REGEXP_SUPPORT
++DUK_INTERNAL_DECL void duk_lexer_parse_re_token(duk_lexer_ctx *lex_ctx, duk_re_token *out_token);
++DUK_INTERNAL_DECL void duk_lexer_parse_re_ranges(duk_lexer_ctx *lex_ctx, duk_re_range_callback gen_range, void *userdata);
++#endif  /* DUK_USE_REGEXP_SUPPORT */
++
++#endif  /* DUK_LEXER_H_INCLUDED */
++#line 1 "duk_js_compiler.h"
++/*
++ *  Ecmascript compiler.
++ */
++
++#ifndef DUK_JS_COMPILER_H_INCLUDED
++#define DUK_JS_COMPILER_H_INCLUDED
++
++/* ecmascript compiler limits */
++#if defined(DUK_USE_DEEP_C_STACK)
++#define DUK_COMPILER_RECURSION_LIMIT       2500L
++#else
++#define DUK_COMPILER_RECURSION_LIMIT       50L
++#endif
++#define DUK_COMPILER_TOKEN_LIMIT           100000000L  /* 1e8: protects against deeply nested inner functions */
++
++/* maximum loopcount for peephole optimization */
++#define DUK_COMPILER_PEEPHOLE_MAXITER      3
++
++/* maximum bytecode length in instructions */
++#define DUK_COMPILER_MAX_BYTECODE_LENGTH   (256L * 1024L * 1024L)  /* 1 GB */
++
++/*
++ *  Compiler intermediate values
++ *
++ *  Intermediate values describe either plain values (e.g. strings or
++ *  numbers) or binary operations which have not yet been coerced into
++ *  either a left-hand-side or right-hand-side role (e.g. object property).
++ */
++
++#define DUK_IVAL_NONE          0   /* no value */
++#define DUK_IVAL_PLAIN         1   /* register, constant, or value */
++#define DUK_IVAL_ARITH         2   /* binary arithmetic; DUK_OP_ADD, DUK_OP_EQ, other binary ops */
++#define DUK_IVAL_ARITH_EXTRAOP 3   /* binary arithmetic using extraops; DUK_EXTRAOP_INSTOF etc */
++#define DUK_IVAL_PROP          4   /* property access */
++#define DUK_IVAL_VAR           5   /* variable access */
++
++#define DUK_ISPEC_NONE         0   /* no value */
++#define DUK_ISPEC_VALUE        1   /* value resides in 'valstack_idx' */
++#define DUK_ISPEC_REGCONST     2   /* value resides in a register or constant */
++
++/* bit mask which indicates that a regconst is a constant instead of a register */
++#define DUK_JS_CONST_MARKER    0x80000000UL
++
++/* type to represent a reg/const reference during compilation */
++typedef duk_uint32_t duk_regconst_t;
++
++/* type to represent a straight register reference, with <0 indicating none */
++typedef duk_int32_t duk_reg_t;
++
++typedef struct {
++	duk_small_uint_t t;          /* DUK_ISPEC_XXX */
++	duk_regconst_t regconst;
++	duk_idx_t valstack_idx;      /* always set; points to a reserved valstack slot */
++} duk_ispec;
++
++typedef struct {
++	/*
++	 *  PLAIN: x1
++	 *  ARITH: x1 <op> x2
++	 *  PROP: x1.x2
++	 *  VAR: x1 (name)
++	 */
++
++	/* XXX: can be optimized for smaller footprint esp. on 32-bit environments */
++	duk_small_uint_t t;          /* DUK_IVAL_XXX */
++	duk_small_uint_t op;         /* bytecode opcode (or extraop) for binary ops */
++	duk_ispec x1;
++	duk_ispec x2;
++} duk_ivalue;
++
++/*
++ *  Bytecode instruction representation during compilation
++ *
++ *  Contains the actual instruction and (optionally) debug info.
++ */
++
++struct duk_compiler_instr {
++	duk_instr_t ins;
++#if defined(DUK_USE_PC2LINE)
++	duk_uint32_t line;
++#endif
++};
++
++/*
++ *  Compiler state
++ */
++
++#define DUK_LABEL_FLAG_ALLOW_BREAK       (1 << 0)
++#define DUK_LABEL_FLAG_ALLOW_CONTINUE    (1 << 1)
++
++#define DUK_DECL_TYPE_VAR                0
++#define DUK_DECL_TYPE_FUNC               1
++
++/* XXX: optimize to 16 bytes */
++typedef struct {
++	duk_small_uint_t flags;
++	duk_int_t label_id;          /* numeric label_id (-1 reserved as marker) */
++	duk_hstring *h_label;        /* borrowed label name */
++	duk_int_t catch_depth;       /* catch depth at point of definition */
++	duk_int_t pc_label;          /* pc of label statement:
++	                              * pc+1: break jump site
++	                              * pc+2: continue jump site
++	                              */
++
++	/* Fast jumps (which avoid longjmp) jump directly to the jump sites
++	 * which are always known even while the iteration/switch statement
++	 * is still being parsed.  A final peephole pass "straightens out"
++	 * the jumps.
++	 */
++} duk_labelinfo;
++
++/* Compiling state of one function, eventually converted to duk_hcompiledfunction */
++struct duk_compiler_func {
++	/* These pointers are at the start of the struct so that they pack
++	 * nicely.  Mixing pointers and integer values is bad on some
++	 * platforms (e.g. if int is 32 bits and pointers are 64 bits).
++	 */
++
++	duk_hstring *h_name;                /* function name (borrowed reference), ends up in _name */
++	duk_hbuffer_dynamic *h_code;        /* C array of duk_compiler_instr */
++	duk_hobject *h_consts;              /* array */
++	duk_hobject *h_funcs;               /* array of function templates: [func1, offset1, line1, func2, offset2, line2]
++	                                     * offset/line points to closing brace to allow skipping on pass 2
++	                                     */
++	duk_hobject *h_decls;               /* array of declarations: [ name1, val1, name2, val2, ... ]
++	                                     * valN = (typeN) | (fnum << 8), where fnum is inner func number (0 for vars)
++	                                     * record function and variable declarations in pass 1
++	                                     */
++	duk_hobject *h_labelnames;          /* array of active label names */
++	duk_hbuffer_dynamic *h_labelinfos;  /* C array of duk_labelinfo */
++	duk_hobject *h_argnames;            /* array of formal argument names (-> _Formals) */
++	duk_hobject *h_varmap;              /* variable map for pass 2 (identifier -> register number or null (unmapped)) */
++
++	/* value stack indices for tracking objects */
++	duk_idx_t code_idx;
++	duk_idx_t consts_idx;
++	duk_idx_t funcs_idx;
++	duk_idx_t decls_idx;
++	duk_idx_t labelnames_idx;
++	duk_idx_t labelinfos_idx;
++	duk_idx_t argnames_idx;
++	duk_idx_t varmap_idx;
++
++	/* temp reg handling */
++	duk_reg_t temp_first;               /* first register that is a temporary (below: variables) */
++	duk_reg_t temp_next;                /* next temporary register to allocate */
++	duk_reg_t temp_max;                 /* highest value of temp_reg (temp_max - 1 is highest used reg) */
++
++	/* shuffle registers if large number of regs/consts */
++	duk_reg_t shuffle1;
++	duk_reg_t shuffle2;
++	duk_reg_t shuffle3;
++
++	/* stats for current expression being parsed */
++	duk_int_t nud_count;
++	duk_int_t led_count;
++	duk_int_t paren_level;              /* parenthesis count, 0 = top level */
++	duk_bool_t expr_lhs;                /* expression is left-hand-side compatible */
++	duk_bool_t allow_in;                /* current paren level allows 'in' token */
++
++	/* misc */
++	duk_int_t stmt_next;                /* statement id allocation (running counter) */
++	duk_int_t label_next;               /* label id allocation (running counter) */
++	duk_int_t catch_depth;              /* catch stack depth */
++	duk_int_t with_depth;               /* with stack depth (affects identifier lookups) */
++	duk_int_t fnum_next;                /* inner function numbering */
++	duk_int_t num_formals;              /* number of formal arguments */
++	duk_reg_t reg_stmt_value;           /* register for writing value of 'non-empty' statements (global or eval code), -1 is marker */
++#if defined(DUK_USE_DEBUGGER_SUPPORT)
++	duk_int_t min_line;                 /* XXX: typing (duk_hcompiledfunction has duk_uint32_t) */
++	duk_int_t max_line;
++#endif
++
++	/* status booleans */
++	duk_bool_t is_function;             /* is an actual function (not global/eval code) */
++	duk_bool_t is_eval;                 /* is eval code */
++	duk_bool_t is_global;               /* is global code */
++	duk_bool_t is_setget;               /* is a setter/getter */
++	duk_bool_t is_decl;                 /* is a function declaration (as opposed to function expression) */
++	duk_bool_t is_strict;               /* function is strict */
++	duk_bool_t is_notail;               /* function must not be tailcalled */
++	duk_bool_t in_directive_prologue;   /* parsing in "directive prologue", recognize directives */
++	duk_bool_t in_scanning;             /* parsing in "scanning" phase (first pass) */
++	duk_bool_t may_direct_eval;         /* function may call direct eval */
++	duk_bool_t id_access_arguments;     /* function refers to 'arguments' identifier */
++	duk_bool_t id_access_slow;          /* function makes one or more slow path accesses */
++	duk_bool_t is_arguments_shadowed;   /* argument/function declaration shadows 'arguments' */
++	duk_bool_t needs_shuffle;           /* function needs shuffle registers */
++	duk_bool_t reject_regexp_in_adv;    /* reject RegExp literal on next advance() call; needed for handling IdentifierName productions */
++};
++
++struct duk_compiler_ctx {
++	duk_hthread *thr;
++
++	/* filename being compiled (ends up in functions' '_filename' property) */
++	duk_hstring *h_filename;            /* borrowed reference */
++
++	/* lexing (tokenization) state (contains two valstack slot indices) */
++	duk_lexer_ctx lex;
++
++	/* current and previous token for parsing */
++	duk_token prev_token;
++	duk_token curr_token;
++	duk_idx_t tok11_idx;                /* curr_token slot1 (matches 'lex' slot1_idx) */
++	duk_idx_t tok12_idx;                /* curr_token slot2 (matches 'lex' slot2_idx) */
++	duk_idx_t tok21_idx;                /* prev_token slot1 */
++	duk_idx_t tok22_idx;                /* prev_token slot2 */
++
++	/* recursion limit */
++	duk_int_t recursion_depth;
++	duk_int_t recursion_limit;
++
++	/* code emission temporary */
++	duk_int_t emit_jumpslot_pc;
++
++	/* current function being compiled (embedded instead of pointer for more compact access) */
++	duk_compiler_func curr_func;
++};
++
++/*
++ *  Prototypes
++ */
++
++#define DUK_JS_COMPILE_FLAG_EVAL      (1 << 0)  /* source is eval code (not program) */
++#define DUK_JS_COMPILE_FLAG_STRICT    (1 << 1)  /* strict outer context */
++#define DUK_JS_COMPILE_FLAG_FUNCEXPR  (1 << 2)  /* source is a function expression (used for Function constructor) */
++
++DUK_INTERNAL_DECL void duk_js_compile(duk_hthread *thr, const duk_uint8_t *src_buffer, duk_size_t src_length, duk_small_uint_t flags);
++
++#endif  /* DUK_JS_COMPILER_H_INCLUDED */
++#line 1 "duk_regexp.h"
++/*
++ *  Regular expression structs, constants, and bytecode defines.
++ */
++
++#ifndef DUK_REGEXP_H_INCLUDED
++#define DUK_REGEXP_H_INCLUDED
++
++/* maximum bytecode copies for {n,m} quantifiers */
++#define DUK_RE_MAX_ATOM_COPIES             1000
++
++/* regexp compilation limits */
++#if defined(DUK_USE_DEEP_C_STACK)
++#define DUK_RE_COMPILE_RECURSION_LIMIT     10000
++#else
++#define DUK_RE_COMPILE_RECURSION_LIMIT     100
++#endif
++#define DUK_RE_COMPILE_TOKEN_LIMIT         100000000L   /* 1e8 */
++
++/* regexp execution limits */
++#if defined(DUK_USE_DEEP_C_STACK)
++#define DUK_RE_EXECUTE_RECURSION_LIMIT     10000
++#else
++#define DUK_RE_EXECUTE_RECURSION_LIMIT     100
++#endif
++#define DUK_RE_EXECUTE_STEPS_LIMIT         1000000000L  /* 1e9 */
++
++/* regexp opcodes */
++#define DUK_REOP_MATCH                     1
++#define DUK_REOP_CHAR                      2
++#define DUK_REOP_PERIOD                    3
++#define DUK_REOP_RANGES                    4
++#define DUK_REOP_INVRANGES                 5
++#define DUK_REOP_JUMP                      6
++#define DUK_REOP_SPLIT1                    7
++#define DUK_REOP_SPLIT2                    8
++#define DUK_REOP_SQMINIMAL                 9
++#define DUK_REOP_SQGREEDY                  10
++#define DUK_REOP_SAVE                      11
++#define DUK_REOP_WIPERANGE                 12
++#define DUK_REOP_LOOKPOS                   13
++#define DUK_REOP_LOOKNEG                   14
++#define DUK_REOP_BACKREFERENCE             15
++#define DUK_REOP_ASSERT_START              16
++#define DUK_REOP_ASSERT_END                17
++#define DUK_REOP_ASSERT_WORD_BOUNDARY      18
++#define DUK_REOP_ASSERT_NOT_WORD_BOUNDARY  19
++
++/* flags */
++#define DUK_RE_FLAG_GLOBAL                 (1 << 0)
++#define DUK_RE_FLAG_IGNORE_CASE            (1 << 1)
++#define DUK_RE_FLAG_MULTILINE              (1 << 2)
++
++struct duk_re_matcher_ctx {
++	duk_hthread *thr;
++
++	duk_uint32_t re_flags;
++	const duk_uint8_t *input;
++	const duk_uint8_t *input_end;
++	const duk_uint8_t *bytecode;
++	const duk_uint8_t *bytecode_end;
++	const duk_uint8_t **saved;  /* allocated from valstack (fixed buffer) */
++	duk_uint32_t nsaved;
++	duk_uint32_t recursion_depth;
++	duk_uint32_t recursion_limit;
++	duk_uint32_t steps_count;
++	duk_uint32_t steps_limit;
++};
++
++struct duk_re_compiler_ctx {
++	duk_hthread *thr;
++
++	duk_uint32_t re_flags;
++	duk_lexer_ctx lex;
++	duk_re_token curr_token;
++	duk_hbuffer_dynamic *buf;
++	duk_uint32_t captures;  /* highest capture number emitted so far (used as: ++captures) */
++	duk_uint32_t highest_backref;
++	duk_uint32_t recursion_depth;
++	duk_uint32_t recursion_limit;
++	duk_uint32_t nranges;  /* internal temporary value, used for char classes */
++};
++
++/*
++ *  Prototypes
++ */
++
++DUK_INTERNAL_DECL void duk_regexp_compile(duk_hthread *thr);
++DUK_INTERNAL_DECL void duk_regexp_create_instance(duk_hthread *thr);
++DUK_INTERNAL_DECL void duk_regexp_match(duk_hthread *thr);
++DUK_INTERNAL_DECL void duk_regexp_match_force_global(duk_hthread *thr);  /* hacky helper for String.prototype.split() */
++
++#endif  /* DUK_REGEXP_H_INCLUDED */
++#line 1 "duk_tval.h"
++/*
++ *  Tagged type definition (duk_tval) and accessor macros.
++ *
++ *  Access all fields through the accessor macros, as the representation
++ *  is quite tricky.
++ *
++ *  There are two packed type alternatives: an 8-byte representation
++ *  based on an IEEE double (preferred for compactness), and a 12-byte
++ *  representation (portability).  The latter is needed also in e.g.
++ *  64-bit environments (it usually pads to 16 bytes per value).
++ *
++ *  Selecting the tagged type format involves many trade-offs (memory
++ *  use, size and performance of generated code, portability, etc),
++ *  see doc/types.txt for a detailed discussion (especially of how the
++ *  IEEE double format is used to pack tagged values).
++ *
++ *  NB: because macro arguments are often expressions, macros should
++ *  avoid evaluating their argument more than once.
++ */
++
++#ifndef DUK_TVAL_H_INCLUDED
++#define DUK_TVAL_H_INCLUDED
++
++/* sanity */
++#if !defined(DUK_USE_DOUBLE_LE) && !defined(DUK_USE_DOUBLE_ME) && !defined(DUK_USE_DOUBLE_BE)
++#error unsupported: cannot determine byte order variant
++#endif
++
++#ifdef DUK_USE_PACKED_TVAL
++/* ======================================================================== */
++
++/*
++ *  Packed 8-byte representation
++ */
++
++/* sanity */
++#if !defined(DUK_USE_PACKED_TVAL_POSSIBLE)
++#error packed representation not supported
++#endif
++
++/* use duk_double_union as duk_tval directly */
++typedef union duk_double_union duk_tval;
++
++/* tags */
++#define DUK_TAG_NORMALIZED_NAN    0x7ff8UL   /* the NaN variant we use */
++/* avoid tag 0xfff0, no risk of confusion with negative infinity */
++#if defined(DUK_USE_FASTINT)
++#define DUK_TAG_FASTINT           0xfff1UL   /* embed: integer value */
++#endif
++#define DUK_TAG_UNDEFINED         0xfff2UL   /* embed: 0 or 1 (normal or unused) */
++#define DUK_TAG_NULL              0xfff3UL   /* embed: nothing */
++#define DUK_TAG_BOOLEAN           0xfff4UL   /* embed: 0 or 1 (false or true) */
++/* DUK_TAG_NUMBER would logically go here, but it has multiple 'tags' */
++#define DUK_TAG_POINTER           0xfff5UL   /* embed: void ptr */
++#define DUK_TAG_LIGHTFUNC         0xfff6UL   /* embed: func ptr */
++#define DUK_TAG_STRING            0xfff7UL   /* embed: duk_hstring ptr */
++#define DUK_TAG_OBJECT            0xfff8UL   /* embed: duk_hobject ptr */
++#define DUK_TAG_BUFFER            0xfff9UL   /* embed: duk_hbuffer ptr */
++
++/* for convenience */
++#define DUK_XTAG_UNDEFINED_ACTUAL 0xfff20000UL
++#define DUK_XTAG_UNDEFINED_UNUSED 0xfff20001UL
++#define DUK_XTAG_NULL             0xfff30000UL
++#define DUK_XTAG_BOOLEAN_FALSE    0xfff40000UL
++#define DUK_XTAG_BOOLEAN_TRUE     0xfff40001UL
++
++/* two casts to avoid gcc warning: "warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]" */
++#ifdef DUK_USE_64BIT_OPS
++#ifdef DUK_USE_DOUBLE_ME
++#define DUK__TVAL_SET_TAGGEDPOINTER(v,h,tag)  do { \
++		(v)->ull[DUK_DBL_IDX_ULL0] = (((duk_uint64_t) (tag)) << 16) | (((duk_uint64_t) (duk_uint32_t) (h)) << 32); \
++	} while (0)
++#else
++#define DUK__TVAL_SET_TAGGEDPOINTER(v,h,tag)  do { \
++		(v)->ull[DUK_DBL_IDX_ULL0] = (((duk_uint64_t) (tag)) << 48) | ((duk_uint64_t) (duk_uint32_t) (h)); \
++	} while (0)
++#endif
++#else  /* DUK_USE_64BIT_OPS */
++#define DUK__TVAL_SET_TAGGEDPOINTER(v,h,tag)  do { \
++		(v)->ui[DUK_DBL_IDX_UI0] = ((duk_uint32_t) (tag)) << 16; \
++		(v)->ui[DUK_DBL_IDX_UI1] = (duk_uint32_t) (h); \
++	} while (0)
++#endif  /* DUK_USE_64BIT_OPS */
++
++#ifdef DUK_USE_64BIT_OPS
++/* Double casting for pointer to avoid gcc warning (cast from pointer to integer of different size) */
++#ifdef DUK_USE_DOUBLE_ME
++#define DUK__TVAL_SET_LIGHTFUNC(v,fp,flags)  do { \
++		(v)->ull[DUK_DBL_IDX_ULL0] = (((duk_uint64_t) DUK_TAG_LIGHTFUNC) << 16) | \
++		                             ((duk_uint64_t) (flags)) | \
++		                             (((duk_uint64_t) (duk_uint32_t) (fp)) << 32); \
++	} while (0)
++#else
++#define DUK__TVAL_SET_LIGHTFUNC(v,fp,flags)  do { \
++		(v)->ull[DUK_DBL_IDX_ULL0] = (((duk_uint64_t) DUK_TAG_LIGHTFUNC) << 48) | \
++		                             (((duk_uint64_t) (flags)) << 32) | \
++		                             ((duk_uint64_t) (duk_uint32_t) (fp)); \
++	} while (0)
++#endif
++#else  /* DUK_USE_64BIT_OPS */
++#define DUK__TVAL_SET_LIGHTFUNC(v,fp,flags)  do { \
++		(v)->ui[DUK_DBL_IDX_UI0] = (((duk_uint32_t) DUK_TAG_LIGHTFUNC) << 16) | ((duk_uint32_t) (flags)); \
++		(v)->ui[DUK_DBL_IDX_UI1] = (duk_uint32_t) (fp); \
++	} while (0)
++#endif  /* DUK_USE_64BIT_OPS */
++
++#if defined(DUK_USE_FASTINT)
++/* Note: masking is done for 'i' to deal with negative numbers correctly */
++#ifdef DUK_USE_DOUBLE_ME
++#define DUK__TVAL_SET_FASTINT(v,i)  do { \
++		(v)->ui[DUK_DBL_IDX_UI0] = ((duk_uint32_t) DUK_TAG_FASTINT) << 16 | (((duk_uint32_t) ((i) >> 32)) & 0x0000ffffUL); \
++		(v)->ui[DUK_DBL_IDX_UI1] = (duk_uint32_t) (i); \
++	} while (0)
++#define DUK__TVAL_SET_FASTINT_U32(v,i)  do { \
++		(v)->ui[DUK_DBL_IDX_UI0] = ((duk_uint32_t) DUK_TAG_FASTINT) << 16; \
++		(v)->ui[DUK_DBL_IDX_UI1] = (duk_uint32_t) (i); \
++	} while (0)
++#else
++#define DUK__TVAL_SET_FASTINT(v,i)  do { \
++		(v)->ull[DUK_DBL_IDX_ULL0] = (((duk_uint64_t) DUK_TAG_FASTINT) << 48) | (((duk_uint64_t) (i)) & 0x0000ffffffffffffULL); \
++	} while (0)
++#define DUK__TVAL_SET_FASTINT_U32(v,i)  do { \
++		(v)->ull[DUK_DBL_IDX_ULL0] = (((duk_uint64_t) DUK_TAG_FASTINT) << 48) | (duk_uint64_t) (i); \
++	} while (0)
++#endif
++
++#define DUK__TVAL_SET_FASTINT_I32(v,i)  do { \
++		duk_int64_t duk__tmp = (duk_int64_t) (i); \
++		DUK_TVAL_SET_FASTINT((v), duk__tmp); \
++	} while (0)
++
++/* XXX: clumsy sign extend and masking of 16 topmost bits */
++#ifdef DUK_USE_DOUBLE_ME
++#define DUK__TVAL_GET_FASTINT(v)      (((duk_int64_t) ((((duk_uint64_t) (v)->ui[DUK_DBL_IDX_UI0]) << 32) | ((duk_uint64_t) (v)->ui[DUK_DBL_IDX_UI1]))) << 16 >> 16)
++#else
++#define DUK__TVAL_GET_FASTINT(v)      ((((duk_int64_t) (v)->ull[DUK_DBL_IDX_ULL0]) << 16) >> 16)
++#endif
++#define DUK__TVAL_GET_FASTINT_U32(v)  ((v)->ui[DUK_DBL_IDX_UI1])
++#define DUK__TVAL_GET_FASTINT_I32(v)  ((duk_int32_t) (v)->ui[DUK_DBL_IDX_UI1])
++#endif  /* DUK_USE_FASTINT */
++
++#define DUK_TVAL_SET_UNDEFINED_ACTUAL(v)    DUK_DBLUNION_SET_HIGH32((v), DUK_XTAG_UNDEFINED_ACTUAL)
++#define DUK_TVAL_SET_UNDEFINED_UNUSED(v)    DUK_DBLUNION_SET_HIGH32((v), DUK_XTAG_UNDEFINED_UNUSED)
++
++/* Note: 16-bit initializer suffices (unlike for undefined/boolean) */
++#define DUK_TVAL_SET_NULL(v)  do { \
++		(v)->us[DUK_DBL_IDX_US0] = (duk_uint16_t) DUK_TAG_NULL; \
++	} while (0)
++
++#define DUK_TVAL_SET_BOOLEAN(v,val)         DUK_DBLUNION_SET_HIGH32((v), (((duk_uint32_t) DUK_TAG_BOOLEAN) << 16) | ((duk_uint32_t) (val)))
++
++#define DUK_TVAL_SET_NAN(v)                 DUK_DBLUNION_SET_NAN_FULL((v))
++
++/* Assumes that caller has normalized NaNs, otherwise trouble ahead. */
++#if defined(DUK_USE_FASTINT)
++#define DUK_TVAL_SET_DOUBLE(v,d)            DUK_DBLUNION_SET_DOUBLE((v), (d))
++#define DUK_TVAL_SET_FASTINT(v,i)           DUK__TVAL_SET_FASTINT((v), (i))
++#define DUK_TVAL_SET_FASTINT_I32(v,i)       DUK__TVAL_SET_FASTINT_I32((v), (i))
++#define DUK_TVAL_SET_FASTINT_U32(v,i)       DUK__TVAL_SET_FASTINT_U32((v), (i))
++#define DUK_TVAL_SET_NUMBER_CHKFAST(v,d)    duk_tval_set_number_chkfast((v), (d))
++#define DUK_TVAL_SET_NUMBER(v,d)            DUK_DBLUNION_SET_DOUBLE((v), (d))
++#define DUK_TVAL_CHKFAST_INPLACE(v)  do { \
++		duk_tval *duk__tv; \
++		duk_double_t duk__d; \
++		duk__tv = (v); \
++		if (DUK_TVAL_IS_DOUBLE(duk__tv)) { \
++			duk__d = DUK_TVAL_GET_DOUBLE(duk__tv); \
++			DUK_TVAL_SET_NUMBER_CHKFAST(duk__tv, duk__d); \
++		} \
++	} while (0)
++#else
++#define DUK_TVAL_SET_NUMBER(v,d)            DUK_DBLUNION_SET_DOUBLE((v), (d))
++#define DUK_TVAL_SET_NUMBER_CHKFAST(v,d)    DUK_TVAL_SET_NUMBER((v), (d))
++#define DUK_TVAL_SET_DOUBLE(v,d)            DUK_TVAL_SET_NUMBER((v), (d))
++#define DUK_TVAL_CHKFAST_INPLACE(v)  do { } while (0)
++#endif
++
++#define DUK_TVAL_SET_LIGHTFUNC(v,fp,flags)  DUK__TVAL_SET_LIGHTFUNC((v), (fp), (flags))
++#define DUK_TVAL_SET_STRING(v,h)            DUK__TVAL_SET_TAGGEDPOINTER((v), (h), DUK_TAG_STRING)
++#define DUK_TVAL_SET_OBJECT(v,h)            DUK__TVAL_SET_TAGGEDPOINTER((v), (h), DUK_TAG_OBJECT)
++#define DUK_TVAL_SET_BUFFER(v,h)            DUK__TVAL_SET_TAGGEDPOINTER((v), (h), DUK_TAG_BUFFER)
++#define DUK_TVAL_SET_POINTER(v,p)           DUK__TVAL_SET_TAGGEDPOINTER((v), (p), DUK_TAG_POINTER)
++
++#define DUK_TVAL_SET_TVAL(v,x)              do { *(v) = *(x); } while (0)
++
++/* getters */
++#define DUK_TVAL_GET_BOOLEAN(v)             ((int) (v)->us[DUK_DBL_IDX_US1])
++#if defined(DUK_USE_FASTINT)
++#define DUK_TVAL_GET_DOUBLE(v)              ((v)->d)
++#define DUK_TVAL_GET_FASTINT(v)             DUK__TVAL_GET_FASTINT((v))
++#define DUK_TVAL_GET_FASTINT_U32(v)         DUK__TVAL_GET_FASTINT_U32((v))
++#define DUK_TVAL_GET_FASTINT_I32(v)         DUK__TVAL_GET_FASTINT_I32((v))
++#define DUK_TVAL_GET_NUMBER(v)              duk_tval_get_number_packed((v))
++#else
++#define DUK_TVAL_GET_NUMBER(v)              ((v)->d)
++#define DUK_TVAL_GET_DOUBLE(v)              ((v)->d)
++#endif
++#define DUK_TVAL_GET_LIGHTFUNC(v,out_fp,out_flags)  do { \
++		(out_flags) = (v)->ui[DUK_DBL_IDX_UI0] & 0xffffUL; \
++		(out_fp) = (duk_c_function) (v)->ui[DUK_DBL_IDX_UI1]; \
++	} while (0)
++#define DUK_TVAL_GET_LIGHTFUNC_FUNCPTR(v)   ((duk_c_function) ((v)->ui[DUK_DBL_IDX_UI1]))
++#define DUK_TVAL_GET_LIGHTFUNC_FLAGS(v)     (((int) (v)->ui[DUK_DBL_IDX_UI0]) & 0xffffUL)
++#define DUK_TVAL_GET_STRING(v)              ((duk_hstring *) (v)->vp[DUK_DBL_IDX_VP1])
++#define DUK_TVAL_GET_OBJECT(v)              ((duk_hobject *) (v)->vp[DUK_DBL_IDX_VP1])
++#define DUK_TVAL_GET_BUFFER(v)              ((duk_hbuffer *) (v)->vp[DUK_DBL_IDX_VP1])
++#define DUK_TVAL_GET_POINTER(v)             ((void *) (v)->vp[DUK_DBL_IDX_VP1])
++#define DUK_TVAL_GET_HEAPHDR(v)             ((duk_heaphdr *) (v)->vp[DUK_DBL_IDX_VP1])
++
++/* decoding */
++#define DUK_TVAL_GET_TAG(v)                 ((duk_small_uint_t) (v)->us[DUK_DBL_IDX_US0])
++
++#define DUK_TVAL_IS_UNDEFINED(v)            (DUK_TVAL_GET_TAG((v)) == DUK_TAG_UNDEFINED)
++#define DUK_TVAL_IS_UNDEFINED_ACTUAL(v)     ((v)->ui[DUK_DBL_IDX_UI0] == DUK_XTAG_UNDEFINED_ACTUAL)
++#define DUK_TVAL_IS_UNDEFINED_UNUSED(v)     ((v)->ui[DUK_DBL_IDX_UI0] == DUK_XTAG_UNDEFINED_UNUSED)
++#define DUK_TVAL_IS_NULL(v)                 (DUK_TVAL_GET_TAG((v)) == DUK_TAG_NULL)
++#define DUK_TVAL_IS_BOOLEAN(v)              (DUK_TVAL_GET_TAG((v)) == DUK_TAG_BOOLEAN)
++#define DUK_TVAL_IS_BOOLEAN_TRUE(v)         ((v)->ui[DUK_DBL_IDX_UI0] == DUK_XTAG_BOOLEAN_TRUE)
++#define DUK_TVAL_IS_BOOLEAN_FALSE(v)        ((v)->ui[DUK_DBL_IDX_UI0] == DUK_XTAG_BOOLEAN_FALSE)
++#define DUK_TVAL_IS_LIGHTFUNC(v)            (DUK_TVAL_GET_TAG((v)) == DUK_TAG_LIGHTFUNC)
++#define DUK_TVAL_IS_STRING(v)               (DUK_TVAL_GET_TAG((v)) == DUK_TAG_STRING)
++#define DUK_TVAL_IS_OBJECT(v)               (DUK_TVAL_GET_TAG((v)) == DUK_TAG_OBJECT)
++#define DUK_TVAL_IS_BUFFER(v)               (DUK_TVAL_GET_TAG((v)) == DUK_TAG_BUFFER)
++#define DUK_TVAL_IS_POINTER(v)              (DUK_TVAL_GET_TAG((v)) == DUK_TAG_POINTER)
++#if defined(DUK_USE_FASTINT)
++/* 0xfff0 is -Infinity */
++#define DUK_TVAL_IS_DOUBLE(v)               (DUK_TVAL_GET_TAG((v)) <= 0xfff0UL)
++#define DUK_TVAL_IS_FASTINT(v)              (DUK_TVAL_GET_TAG((v)) == DUK_TAG_FASTINT)
++#define DUK_TVAL_IS_NUMBER(v)               (DUK_TVAL_GET_TAG((v)) <= 0xfff1UL)
++#else
++#define DUK_TVAL_IS_NUMBER(v)               (DUK_TVAL_GET_TAG((v)) <= 0xfff0UL)
++#define DUK_TVAL_IS_DOUBLE(v)               DUK_TVAL_IS_NUMBER((v))
++#endif
++
++#define DUK_TVAL_IS_HEAP_ALLOCATED(v)       (DUK_TVAL_GET_TAG((v)) >= DUK_TAG_STRING)
++
++#if defined(DUK_USE_FASTINT)
++/* Inlining is only effective in a single file build. */
++DUK_INTERNAL_DECL DUK_ALWAYS_INLINE duk_double_t duk_tval_get_number_packed(duk_tval *tv);
++#endif
++
++#else  /* DUK_USE_PACKED_TVAL */
++/* ======================================================================== */
++
++/*
++ *  Portable 12-byte representation
++ */
++
++/* Note: not initializing all bytes is normally not an issue: Duktape won't
++ * read or use the uninitialized bytes so valgrind won't issue warnings.
++ * In some special cases a harmless valgrind warning may be issued though.
++ * For example, the DumpHeap debugger command writes out a compiled function's
++ * 'data' area as is, including any uninitialized bytes, which causes a
++ * valgrind warning.
++ */
++
++typedef struct duk_tval_struct duk_tval;
++
++struct duk_tval_struct {
++	duk_small_uint_t t;
++	duk_small_uint_t v_extra;
++	union {
++		duk_double_t d;
++		duk_small_int_t i;
++#if defined(DUK_USE_FASTINT)
++		duk_int64_t fi;  /* if present, forces 16-byte duk_tval */
++#endif
++		void *voidptr;
++		duk_hstring *hstring;
++		duk_hobject *hobject;
++		duk_hcompiledfunction *hcompiledfunction;
++		duk_hnativefunction *hnativefunction;
++		duk_hthread *hthread;
++		duk_hbuffer *hbuffer;
++		duk_heaphdr *heaphdr;
++		duk_c_function lightfunc;
++	} v;
++};
++
++#define DUK__TAG_NUMBER               0  /* not exposed */
++#if defined(DUK_USE_FASTINT)
++#define DUK_TAG_FASTINT               1
++#endif
++#define DUK_TAG_UNDEFINED             2
++#define DUK_TAG_NULL                  3
++#define DUK_TAG_BOOLEAN               4
++#define DUK_TAG_POINTER               5
++#define DUK_TAG_LIGHTFUNC             6
++#define DUK_TAG_STRING                7
++#define DUK_TAG_OBJECT                8
++#define DUK_TAG_BUFFER                9
++
++/* DUK__TAG_NUMBER is intentionally first, as it is the default clause in code
++ * to support the 8-byte representation.  Further, it is a non-heap-allocated
++ * type so it should come before DUK_TAG_STRING.  Finally, it should not break
++ * the tag value ranges covered by case-clauses in a switch-case.
++ */
++
++/* setters */
++#define DUK_TVAL_SET_UNDEFINED_ACTUAL(tv)  do { \
++		(tv)->t = DUK_TAG_UNDEFINED; \
++		(tv)->v.i = 0; \
++	} while (0)
++
++#define DUK_TVAL_SET_UNDEFINED_UNUSED(tv)  do { \
++		(tv)->t = DUK_TAG_UNDEFINED; \
++		(tv)->v.i = 1; \
++	} while (0)
++
++#define DUK_TVAL_SET_NULL(tv)  do { \
++		(tv)->t = DUK_TAG_NULL; \
++	} while (0)
++
++#define DUK_TVAL_SET_BOOLEAN(tv,val)  do { \
++		(tv)->t = DUK_TAG_BOOLEAN; \
++		(tv)->v.i = (val); \
++	} while (0)
++
++#if defined(DUK_USE_FASTINT)
++#define DUK_TVAL_SET_DOUBLE(tv,val)  do { \
++		(tv)->t = DUK__TAG_NUMBER; \
++		(tv)->v.d = (val); \
++	} while (0)
++#define DUK_TVAL_SET_FASTINT(tv,val)  do { \
++		(tv)->t = DUK_TAG_FASTINT; \
++		(tv)->v.fi = (val); \
++	} while (0)
++#define DUK_TVAL_SET_FASTINT_U32(tv,val)  do { \
++		(tv)->t = DUK_TAG_FASTINT; \
++		(tv)->v.fi = (duk_int64_t) (val); \
++	} while (0)
++#define DUK_TVAL_SET_FASTINT_I32(tv,val)  do { \
++		(tv)->t = DUK_TAG_FASTINT; \
++		(tv)->v.fi = (duk_int64_t) (val); \
++	} while (0)
++#define DUK_TVAL_SET_NUMBER_CHKFAST(tv,d) \
++	duk_tval_set_number_chkfast((tv), (d))
++#define DUK_TVAL_SET_NUMBER(tv,val) \
++	DUK_TVAL_SET_DOUBLE((tv), (val))
++#define DUK_TVAL_CHKFAST_INPLACE(v)  do { \
++		duk_tval *duk__tv; \
++		duk_double_t duk__d; \
++		duk__tv = (v); \
++		if (DUK_TVAL_IS_DOUBLE(duk__tv)) { \
++			duk__d = DUK_TVAL_GET_DOUBLE(duk__tv); \
++			DUK_TVAL_SET_NUMBER_CHKFAST(duk__tv, duk__d); \
++		} \
++	} while (0)
++#else
++#define DUK_TVAL_SET_NUMBER(tv,val)  do { \
++		(tv)->t = DUK__TAG_NUMBER; \
++		(tv)->v.d = (val); \
++	} while (0)
++#define DUK_TVAL_SET_NUMBER_CHKFAST(v,d) \
++	DUK_TVAL_SET_NUMBER((tv), (d))
++#define DUK_TVAL_SET_DOUBLE(v,d) \
++	DUK_TVAL_SET_NUMBER((tv), (d))
++#define DUK_TVAL_CHKFAST_INPLACE(v)  do { } while (0)
++#endif  /* DUK_USE_FASTINT */
++
++#define DUK_TVAL_SET_POINTER(tv,hptr)  do { \
++		(tv)->t = DUK_TAG_POINTER; \
++		(tv)->v.voidptr = (hptr); \
++	} while (0)
++
++#define DUK_TVAL_SET_LIGHTFUNC(tv,fp,flags)  do { \
++		(tv)->t = DUK_TAG_LIGHTFUNC; \
++		(tv)->v_extra = (flags); \
++		(tv)->v.lightfunc = (duk_c_function) (fp); \
++	} while (0)
++
++#define DUK_TVAL_SET_STRING(tv,hptr)  do { \
++		(tv)->t = DUK_TAG_STRING; \
++		(tv)->v.hstring = (hptr); \
++	} while (0)
++
++#define DUK_TVAL_SET_OBJECT(tv,hptr)  do { \
++		(tv)->t = DUK_TAG_OBJECT; \
++		(tv)->v.hobject = (hptr); \
++	} while (0)
++
++#define DUK_TVAL_SET_BUFFER(tv,hptr)  do { \
++		(tv)->t = DUK_TAG_BUFFER; \
++		(tv)->v.hbuffer = (hptr); \
++	} while (0)
++
++#define DUK_TVAL_SET_NAN(tv)  do { \
++		/* in non-packed representation we don't care about which NaN is used */ \
++		(tv)->t = DUK__TAG_NUMBER; \
++		(tv)->v.d = DUK_DOUBLE_NAN; \
++	} while (0)
++
++#define DUK_TVAL_SET_TVAL(v,x)             do { *(v) = *(x); } while (0)
++
++/* getters */
++#define DUK_TVAL_GET_BOOLEAN(tv)           ((tv)->v.i)
++#if defined(DUK_USE_FASTINT)
++#define DUK_TVAL_GET_DOUBLE(tv)            ((tv)->v.d)
++#define DUK_TVAL_GET_FASTINT(tv)           ((tv)->v.fi)
++#define DUK_TVAL_GET_FASTINT_U32(tv)       ((duk_uint32_t) ((tv)->v.fi))
++#define DUK_TVAL_GET_FASTINT_I32(tv)       ((duk_int32_t) ((tv)->v.fi))
++#if 0
++#define DUK_TVAL_GET_NUMBER(tv)            (DUK_TVAL_IS_FASTINT((tv)) ? \
++                                               (duk_double_t) DUK_TVAL_GET_FASTINT((tv)) : \
++                                               DUK_TVAL_GET_DOUBLE((tv)))
++#define DUK_TVAL_GET_NUMBER(tv)            duk_tval_get_number_unpacked((tv))
++#else
++/* This seems reasonable overall. */
++#define DUK_TVAL_GET_NUMBER(tv)            (DUK_TVAL_IS_FASTINT((tv)) ? \
++                                               duk_tval_get_number_unpacked_fastint((tv)) : \
++                                               DUK_TVAL_GET_DOUBLE((tv)))
++#endif
++#else
++#define DUK_TVAL_GET_NUMBER(tv)            ((tv)->v.d)
++#define DUK_TVAL_GET_DOUBLE(tv)            ((tv)->v.d)
++#endif  /* DUK_USE_FASTINT */
++#define DUK_TVAL_GET_POINTER(tv)           ((tv)->v.voidptr)
++#define DUK_TVAL_GET_LIGHTFUNC(tv,out_fp,out_flags)  do { \
++		(out_flags) = (duk_uint32_t) (tv)->v_extra; \
++		(out_fp) = (tv)->v.lightfunc; \
++	} while (0)
++#define DUK_TVAL_GET_LIGHTFUNC_FUNCPTR(tv) ((tv)->v.lightfunc)
++#define DUK_TVAL_GET_LIGHTFUNC_FLAGS(tv)   ((duk_uint32_t) ((tv)->v_extra))
++#define DUK_TVAL_GET_STRING(tv)            ((tv)->v.hstring)
++#define DUK_TVAL_GET_OBJECT(tv)            ((tv)->v.hobject)
++#define DUK_TVAL_GET_BUFFER(tv)            ((tv)->v.hbuffer)
++#define DUK_TVAL_GET_HEAPHDR(tv)           ((tv)->v.heaphdr)
++
++/* decoding */
++#define DUK_TVAL_GET_TAG(tv)               ((tv)->t)
++#define DUK_TVAL_IS_UNDEFINED(tv)          ((tv)->t == DUK_TAG_UNDEFINED)
++#define DUK_TVAL_IS_UNDEFINED_ACTUAL(tv)   (((tv)->t == DUK_TAG_UNDEFINED) && ((tv)->v.i == 0))
++#define DUK_TVAL_IS_UNDEFINED_UNUSED(tv)   (((tv)->t == DUK_TAG_UNDEFINED) && ((tv)->v.i != 0))
++#define DUK_TVAL_IS_NULL(tv)               ((tv)->t == DUK_TAG_NULL)
++#define DUK_TVAL_IS_BOOLEAN(tv)            ((tv)->t == DUK_TAG_BOOLEAN)
++#define DUK_TVAL_IS_BOOLEAN_TRUE(tv)       (((tv)->t == DUK_TAG_BOOLEAN) && ((tv)->v.i != 0))
++#define DUK_TVAL_IS_BOOLEAN_FALSE(tv)      (((tv)->t == DUK_TAG_BOOLEAN) && ((tv)->v.i == 0))
++#if defined(DUK_USE_FASTINT)
++#define DUK_TVAL_IS_DOUBLE(tv)             ((tv)->t == DUK__TAG_NUMBER)
++#define DUK_TVAL_IS_FASTINT(tv)            ((tv)->t == DUK_TAG_FASTINT)
++#define DUK_TVAL_IS_NUMBER(tv)             ((tv)->t == DUK__TAG_NUMBER || \
++                                            (tv)->t == DUK_TAG_FASTINT)
++#else
++#define DUK_TVAL_IS_NUMBER(tv)             ((tv)->t == DUK__TAG_NUMBER)
++#define DUK_TVAL_IS_DOUBLE(v)              DUK_TVAL_IS_NUMBER((v))
++#endif  /* DUK_USE_FASTINT */
++#define DUK_TVAL_IS_POINTER(tv)            ((tv)->t == DUK_TAG_POINTER)
++#define DUK_TVAL_IS_LIGHTFUNC(tv)          ((tv)->t == DUK_TAG_LIGHTFUNC)
++#define DUK_TVAL_IS_STRING(tv)             ((tv)->t == DUK_TAG_STRING)
++#define DUK_TVAL_IS_OBJECT(tv)             ((tv)->t == DUK_TAG_OBJECT)
++#define DUK_TVAL_IS_BUFFER(tv)             ((tv)->t == DUK_TAG_BUFFER)
++
++#define DUK_TVAL_IS_HEAP_ALLOCATED(tv)     ((tv)->t >= DUK_TAG_STRING)
++
++#if defined(DUK_USE_FASTINT)
++/* Inlining is only effective in a single file build. */
++#if 0
++DUK_INTERNAL_DECL DUK_ALWAYS_INLINE duk_double_t duk_tval_get_number_unpacked(duk_tval *tv);
++#endif
++DUK_INTERNAL_DECL DUK_ALWAYS_INLINE duk_double_t duk_tval_get_number_unpacked_fastint(duk_tval *tv);
++#endif
++
++#endif  /* DUK_USE_PACKED_TVAL */
++
++/*
++ *  Convenience (independent of representation)
++ */
++
++#define DUK_TVAL_SET_BOOLEAN_TRUE(v)        DUK_TVAL_SET_BOOLEAN(v, 1)
++#define DUK_TVAL_SET_BOOLEAN_FALSE(v)       DUK_TVAL_SET_BOOLEAN(v, 0)
++
++/* Lightfunc flags packing and unpacking. */
++/* Sign extend: 0x0000##00 -> 0x##000000 -> sign extend to 0xssssss## */
++#define DUK_LFUNC_FLAGS_GET_MAGIC(lf_flags) \
++	((((duk_int32_t) (lf_flags)) << 16) >> 24)
++#define DUK_LFUNC_FLAGS_GET_LENGTH(lf_flags) \
++	(((lf_flags) >> 4) & 0x0f)
++#define DUK_LFUNC_FLAGS_GET_NARGS(lf_flags) \
++	((lf_flags) & 0x0f)
++#define DUK_LFUNC_FLAGS_PACK(magic,length,nargs) \
++	(((magic) & 0xff) << 8) | ((length) << 4) | (nargs)
++
++#define DUK_LFUNC_NARGS_VARARGS             0x0f   /* varargs marker */
++#define DUK_LFUNC_NARGS_MIN                 0x00
++#define DUK_LFUNC_NARGS_MAX                 0x0e   /* max, excl. varargs marker */
++#define DUK_LFUNC_LENGTH_MIN                0x00
++#define DUK_LFUNC_LENGTH_MAX                0x0f
++#define DUK_LFUNC_MAGIC_MIN                 (-0x80)
++#define DUK_LFUNC_MAGIC_MAX                 0x7f
++
++/* fastint constants etc */
++#if defined(DUK_USE_FASTINT)
++#define DUK_FASTINT_MIN           (-0x800000000000LL)
++#define DUK_FASTINT_MAX           0x7fffffffffffLL
++#define DUK_FASTINT_BITS          48
++
++DUK_INTERNAL_DECL void duk_tval_set_number_chkfast(duk_tval *tv, duk_double_t x);
++#endif
++
++#endif  /* DUK_TVAL_H_INCLUDED */
++#line 1 "duk_heaphdr.h"
++/*
++ *  Heap header definition and assorted macros, including ref counting.
++ *  Access all fields through the accessor macros.
++ */
++
++#ifndef DUK_HEAPHDR_H_INCLUDED
++#define DUK_HEAPHDR_H_INCLUDED
++
++/*
++ *  Common heap header
++ *
++ *  All heap objects share the same flags and refcount fields.  Objects other
++ *  than strings also need to have a single or double linked list pointers
++ *  for insertion into the "heap allocated" list.  Strings are held in the
++ *  heap-wide string table so they don't need link pointers.
++ *
++ *  Technically, 'h_refcount' must be wide enough to guarantee that it cannot
++ *  wrap (otherwise objects might be freed incorrectly after wrapping).  This
++ *  means essentially that the refcount field must be as wide as data pointers.
++ *  On 64-bit platforms this means that the refcount needs to be 64 bits even
++ *  if an 'int' is 32 bits.  This is a bit unfortunate, and compromising on
++ *  this might be reasonable in the future.
++ *
++ *  Heap header size on 32-bit platforms: 8 bytes without reference counting,
++ *  16 bytes with reference counting.
++ */
++
++struct duk_heaphdr {
++	duk_uint32_t h_flags;
++
++#if defined(DUK_USE_REFERENCE_COUNTING)
++#if defined(DUK_USE_REFCOUNT16)
++	duk_uint16_t h_refcount16;
++#else
++	duk_size_t h_refcount;
++#endif
++#endif
++
++#if defined(DUK_USE_HEAPPTR16)
++	duk_uint16_t h_next16;
++#else
++	duk_heaphdr *h_next;
++#endif
++
++#if defined(DUK_USE_DOUBLE_LINKED_HEAP)
++	/* refcounting requires direct heap frees, which in turn requires a dual linked heap */
++#if defined(DUK_USE_HEAPPTR16)
++	duk_uint16_t h_prev16;
++#else
++	duk_heaphdr *h_prev;
++#endif
++#endif
++
++	/* When DUK_USE_HEAPPTR16 (and DUK_USE_REFCOUNT16) is in use, the
++	 * struct won't align nicely to 4 bytes.  This 16-bit extra field
++	 * is added to make the alignment clean; the field can be used by
++	 * heap objects when 16-bit packing is used.  This field is now
++	 * conditional to DUK_USE_HEAPPTR16 only, but it is intended to be
++	 * used with DUK_USE_REFCOUNT16 and DUK_USE_DOUBLE_LINKED_HEAP;
++	 * this only matter to low memory environments anyway.
++	 */
++#if defined(DUK_USE_HEAPPTR16)
++	duk_uint16_t h_extra16;
++#endif
++};
++
++struct duk_heaphdr_string {
++	/* 16 bits would be enough for shared heaphdr flags and duk_hstring
++	 * flags.  The initial parts of duk_heaphdr_string and duk_heaphdr
++	 * must match so changing the flags field size here would be quite
++	 * awkward.  However, to minimize struct size, we can pack at least
++	 * 16 bits of duk_hstring data into the flags field.
++	 */
++	duk_uint32_t h_flags;
++
++#if defined(DUK_USE_REFERENCE_COUNTING)
++#if defined(DUK_USE_REFCOUNT16)
++	duk_uint16_t h_refcount16;
++#else
++	duk_size_t h_refcount;
++#endif
++#endif
++};
++
++#define DUK_HEAPHDR_FLAGS_TYPE_MASK      0x00000003UL
++#define DUK_HEAPHDR_FLAGS_FLAG_MASK      (~DUK_HEAPHDR_FLAGS_TYPE_MASK)
++
++                                             /* 2 bits for heap type */
++#define DUK_HEAPHDR_FLAGS_HEAP_START     2   /* 4 heap flags */
++#define DUK_HEAPHDR_FLAGS_USER_START     6   /* 26 user flags */
++
++#define DUK_HEAPHDR_HEAP_FLAG_NUMBER(n)  (DUK_HEAPHDR_FLAGS_HEAP_START + (n))
++#define DUK_HEAPHDR_USER_FLAG_NUMBER(n)  (DUK_HEAPHDR_FLAGS_USER_START + (n))
++#define DUK_HEAPHDR_HEAP_FLAG(n)         (1UL << (DUK_HEAPHDR_FLAGS_HEAP_START + (n)))
++#define DUK_HEAPHDR_USER_FLAG(n)         (1UL << (DUK_HEAPHDR_FLAGS_USER_START + (n)))
++
++#define DUK_HEAPHDR_FLAG_REACHABLE       DUK_HEAPHDR_HEAP_FLAG(0)  /* mark-and-sweep: reachable */
++#define DUK_HEAPHDR_FLAG_TEMPROOT        DUK_HEAPHDR_HEAP_FLAG(1)  /* mark-and-sweep: children not processed */
++#define DUK_HEAPHDR_FLAG_FINALIZABLE     DUK_HEAPHDR_HEAP_FLAG(2)  /* mark-and-sweep: finalizable (on current pass) */
++#define DUK_HEAPHDR_FLAG_FINALIZED       DUK_HEAPHDR_HEAP_FLAG(3)  /* mark-and-sweep: finalized (on previous pass) */
++
++#define DUK_HTYPE_MIN                    1
++#define DUK_HTYPE_STRING                 1
++#define DUK_HTYPE_OBJECT                 2
++#define DUK_HTYPE_BUFFER                 3
++#define DUK_HTYPE_MAX                    3
++
++#if defined(DUK_USE_HEAPPTR16)
++#define DUK_HEAPHDR_GET_NEXT(heap,h) \
++	((duk_heaphdr *) DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (h)->h_next16))
++#define DUK_HEAPHDR_SET_NEXT(heap,h,val)   do { \
++		(h)->h_next16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) val); \
++	} while (0)
++#else
++#define DUK_HEAPHDR_GET_NEXT(heap,h)  ((h)->h_next)
++#define DUK_HEAPHDR_SET_NEXT(heap,h,val)   do { \
++		(h)->h_next = (val); \
++	} while (0)
++#endif
++
++#if defined(DUK_USE_DOUBLE_LINKED_HEAP)
++#if defined(DUK_USE_HEAPPTR16)
++#define DUK_HEAPHDR_GET_PREV(heap,h) \
++	((duk_heaphdr *) DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, (h)->h_prev16))
++#define DUK_HEAPHDR_SET_PREV(heap,h,val)   do { \
++		(h)->h_prev16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) (val)); \
++	} while (0)
++#else
++#define DUK_HEAPHDR_GET_PREV(heap,h)       ((h)->h_prev)
++#define DUK_HEAPHDR_SET_PREV(heap,h,val)   do { \
++		(h)->h_prev = (val); \
++	} while (0)
++#endif
++#endif
++
++#if defined(DUK_USE_REFERENCE_COUNTING)
++#if defined(DUK_USE_REFCOUNT16)
++#define DUK_HEAPHDR_GET_REFCOUNT(h)   ((h)->h_refcount16)
++#define DUK_HEAPHDR_SET_REFCOUNT(h,val)  do { \
++		(h)->h_refcount16 = (val); \
++	} while (0)
++#define DUK_HEAPHDR_PREINC_REFCOUNT(h)  (++(h)->h_refcount16)  /* result: updated refcount */
++#define DUK_HEAPHDR_PREDEC_REFCOUNT(h)  (--(h)->h_refcount16)  /* result: updated refcount */
++#else
++#define DUK_HEAPHDR_GET_REFCOUNT(h)   ((h)->h_refcount)
++#define DUK_HEAPHDR_SET_REFCOUNT(h,val)  do { \
++		(h)->h_refcount = (val); \
++	} while (0)
++#define DUK_HEAPHDR_PREINC_REFCOUNT(h)  (++(h)->h_refcount)  /* result: updated refcount */
++#define DUK_HEAPHDR_PREDEC_REFCOUNT(h)  (--(h)->h_refcount)  /* result: updated refcount */
++#endif
++#else
++/* refcount macros not defined without refcounting, caller must #ifdef now */
++#endif  /* DUK_USE_REFERENCE_COUNTING */
++
++/*
++ *  Note: type is treated as a field separate from flags, so some masking is
++ *  involved in the macros below.
++ */
++
++#define DUK_HEAPHDR_GET_FLAGS_RAW(h)  ((h)->h_flags)
++
++#define DUK_HEAPHDR_GET_FLAGS(h)      ((h)->h_flags & DUK_HEAPHDR_FLAGS_FLAG_MASK)
++#define DUK_HEAPHDR_SET_FLAGS(h,val)  do { \
++		(h)->h_flags = ((h)->h_flags & ~(DUK_HEAPHDR_FLAGS_FLAG_MASK)) | (val); \
++	} while (0)
++
++#define DUK_HEAPHDR_GET_TYPE(h)       ((h)->h_flags & DUK_HEAPHDR_FLAGS_TYPE_MASK)
++#define DUK_HEAPHDR_SET_TYPE(h,val)   do { \
++		(h)->h_flags = ((h)->h_flags & ~(DUK_HEAPHDR_FLAGS_TYPE_MASK)) | (val); \
++	} while (0)
++
++#define DUK_HEAPHDR_HTYPE_VALID(h)    ( \
++	DUK_HEAPHDR_GET_TYPE((h)) >= DUK_HTYPE_MIN && \
++	DUK_HEAPHDR_GET_TYPE((h)) <= DUK_HTYPE_MAX \
++	)
++
++#define DUK_HEAPHDR_SET_TYPE_AND_FLAGS(h,tval,fval)  do { \
++		(h)->h_flags = ((tval) & DUK_HEAPHDR_FLAGS_TYPE_MASK) | \
++		               ((fval) & DUK_HEAPHDR_FLAGS_FLAG_MASK); \
++	} while (0)
++
++#define DUK_HEAPHDR_SET_FLAG_BITS(h,bits)  do { \
++		DUK_ASSERT(((bits) & ~(DUK_HEAPHDR_FLAGS_FLAG_MASK)) == 0); \
++		(h)->h_flags |= (bits); \
++	} while (0)
++
++#define DUK_HEAPHDR_CLEAR_FLAG_BITS(h,bits)  do { \
++		DUK_ASSERT(((bits) & ~(DUK_HEAPHDR_FLAGS_FLAG_MASK)) == 0); \
++		(h)->h_flags &= ~((bits)); \
++	} while (0)
++
++#define DUK_HEAPHDR_CHECK_FLAG_BITS(h,bits)  (((h)->h_flags & (bits)) != 0)
++
++#define DUK_HEAPHDR_SET_REACHABLE(h)      DUK_HEAPHDR_SET_FLAG_BITS((h),DUK_HEAPHDR_FLAG_REACHABLE)
++#define DUK_HEAPHDR_CLEAR_REACHABLE(h)    DUK_HEAPHDR_CLEAR_FLAG_BITS((h),DUK_HEAPHDR_FLAG_REACHABLE)
++#define DUK_HEAPHDR_HAS_REACHABLE(h)      DUK_HEAPHDR_CHECK_FLAG_BITS((h),DUK_HEAPHDR_FLAG_REACHABLE)
++
++#define DUK_HEAPHDR_SET_TEMPROOT(h)       DUK_HEAPHDR_SET_FLAG_BITS((h),DUK_HEAPHDR_FLAG_TEMPROOT)
++#define DUK_HEAPHDR_CLEAR_TEMPROOT(h)     DUK_HEAPHDR_CLEAR_FLAG_BITS((h),DUK_HEAPHDR_FLAG_TEMPROOT)
++#define DUK_HEAPHDR_HAS_TEMPROOT(h)       DUK_HEAPHDR_CHECK_FLAG_BITS((h),DUK_HEAPHDR_FLAG_TEMPROOT)
++
++#define DUK_HEAPHDR_SET_FINALIZABLE(h)    DUK_HEAPHDR_SET_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZABLE)
++#define DUK_HEAPHDR_CLEAR_FINALIZABLE(h)  DUK_HEAPHDR_CLEAR_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZABLE)
++#define DUK_HEAPHDR_HAS_FINALIZABLE(h)    DUK_HEAPHDR_CHECK_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZABLE)
++
++#define DUK_HEAPHDR_SET_FINALIZED(h)      DUK_HEAPHDR_SET_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZED)
++#define DUK_HEAPHDR_CLEAR_FINALIZED(h)    DUK_HEAPHDR_CLEAR_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZED)
++#define DUK_HEAPHDR_HAS_FINALIZED(h)      DUK_HEAPHDR_CHECK_FLAG_BITS((h),DUK_HEAPHDR_FLAG_FINALIZED)
++
++/* get or set a range of flags; m=first bit number, n=number of bits */
++#define DUK_HEAPHDR_GET_FLAG_RANGE(h,m,n)  (((h)->h_flags >> (m)) & ((1UL << (n)) - 1UL))
++
++#define DUK_HEAPHDR_SET_FLAG_RANGE(h,m,n,v)  do { \
++		(h)->h_flags = \
++			((h)->h_flags & (~(((1 << (n)) - 1) << (m)))) \
++			| ((v) << (m)); \
++	} while (0)
++
++/* init pointer fields to null */
++#if defined(DUK_USE_DOUBLE_LINKED_HEAP)
++#define DUK_HEAPHDR_INIT_NULLS(h)       do { \
++		DUK_HEAPHDR_SET_NEXT((h), (void *) NULL); \
++		DUK_HEAPHDR_SET_PREV((h), (void *) NULL); \
++	} while (0)
++#else
++#define DUK_HEAPHDR_INIT_NULLS(h)       do { \
++		DUK_HEAPHDR_SET_NEXT((h), (void *) NULL); \
++	} while (0)
++#endif
++
++#define DUK_HEAPHDR_STRING_INIT_NULLS(h)  /* currently nop */
++
++/*
++ *  Reference counting helper macros.  The macros take a thread argument
++ *  and must thus always be executed in a specific thread context.  The
++ *  thread argument is needed for features like finalization.  Currently
++ *  it is not required for INCREF, but it is included just in case.
++ *
++ *  Note that 'raw' macros such as DUK_HEAPHDR_GET_REFCOUNT() are not
++ *  defined without DUK_USE_REFERENCE_COUNTING, so caller must #ifdef
++ *  around them.
++ */
++
++#if defined(DUK_USE_REFERENCE_COUNTING)
++
++/* Fast variants, inline refcount operations except for refzero handling.
++ * Can be used explicitly when speed is always more important than size.
++ * For a good compiler and a single file build, these are basically the
++ * same as a forced inline.
++ */
++#define DUK_TVAL_INCREF_FAST(thr,tv) do { \
++		duk_tval *duk__tv = (tv); \
++		DUK_ASSERT(duk__tv != NULL); \
++		if (DUK_TVAL_IS_HEAP_ALLOCATED(duk__tv)) { \
++			duk_heaphdr *duk__h = DUK_TVAL_GET_HEAPHDR(duk__tv); \
++			DUK_ASSERT(duk__h != NULL); \
++			DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(duk__h)); \
++			DUK_HEAPHDR_PREINC_REFCOUNT(duk__h); \
++		} \
++	} while (0)
++#define DUK_TVAL_DECREF_FAST(thr,tv) do { \
++		duk_tval *duk__tv = (tv); \
++		DUK_ASSERT(duk__tv != NULL); \
++		if (DUK_TVAL_IS_HEAP_ALLOCATED(duk__tv)) { \
++			duk_heaphdr *duk__h = DUK_TVAL_GET_HEAPHDR(duk__tv); \
++			DUK_ASSERT(duk__h != NULL); \
++			DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(duk__h)); \
++			DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(duk__h) > 0); \
++			if (DUK_HEAPHDR_PREDEC_REFCOUNT(duk__h) == 0) { \
++				duk_heaphdr_refzero((thr), duk__h); \
++			} \
++		} \
++	} while (0)
++#define DUK_HEAPHDR_INCREF_FAST(thr,h) do { \
++		duk_heaphdr *duk__h = (duk_heaphdr *) (h); \
++		DUK_ASSERT(duk__h != NULL); \
++		DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(duk__h)); \
++		DUK_HEAPHDR_PREINC_REFCOUNT(duk__h); \
++	} while (0)
++#define DUK_HEAPHDR_DECREF_FAST(thr,h) do { \
++		duk_heaphdr *duk__h = (duk_heaphdr *) (h); \
++		DUK_ASSERT(duk__h != NULL); \
++		DUK_ASSERT(DUK_HEAPHDR_HTYPE_VALID(duk__h)); \
++		DUK_ASSERT(DUK_HEAPHDR_GET_REFCOUNT(duk__h) > 0); \
++		if (DUK_HEAPHDR_PREDEC_REFCOUNT(duk__h) == 0) { \
++			duk_heaphdr_refzero((thr), duk__h); \
++		} \
++	} while (0)
++
++/* Slow variants, call to a helper to reduce code size.
++ * Can be used explicitly when size is always more important than speed.
++ */
++#define DUK_TVAL_INCREF_SLOW(thr,tv) do { \
++		duk_tval_incref((tv)); \
++	} while (0)
++#define DUK_TVAL_DECREF_SLOW(thr,tv) do { \
++		duk_tval_decref((thr), (tv)); \
++	} while (0)
++#define DUK_HEAPHDR_INCREF_SLOW(thr,h) do { \
++		duk_heaphdr_incref((duk_heaphdr *) (h)); \
++	} while (0)
++#define DUK_HEAPHDR_DECREF_SLOW(thr,h) do { \
++		duk_heaphdr_decref((thr), (duk_heaphdr *) (h)); \
++	} while (0)
++
++/* Default variants.  Selection depends on speed/size preference.
++ * Concretely: with gcc 4.8.1 -Os x64 the difference in final binary
++ * is about +1kB for _FAST variants.
++ */
++#if defined(DUK_USE_FAST_REFCOUNT_DEFAULT)
++#define DUK_TVAL_INCREF(thr,tv)                DUK_TVAL_INCREF_FAST((thr),(tv))
++#define DUK_TVAL_DECREF(thr,tv)                DUK_TVAL_DECREF_FAST((thr),(tv))
++#define DUK_HEAPHDR_INCREF(thr,h)              DUK_HEAPHDR_INCREF_FAST((thr),(h))
++#define DUK_HEAPHDR_DECREF(thr,h)              DUK_HEAPHDR_DECREF_FAST((thr),(h))
++#else
++#define DUK_TVAL_INCREF(thr,tv)                DUK_TVAL_INCREF_SLOW((thr),(tv))
++#define DUK_TVAL_DECREF(thr,tv)                DUK_TVAL_DECREF_SLOW((thr),(tv))
++#define DUK_HEAPHDR_INCREF(thr,h)              DUK_HEAPHDR_INCREF_SLOW((thr),(h))
++#define DUK_HEAPHDR_DECREF(thr,h)              DUK_HEAPHDR_DECREF_SLOW((thr),(h))
++#endif
++
++/* Casting convenience. */
++#define DUK_HSTRING_INCREF(thr,h)              DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) (h))
++#define DUK_HSTRING_DECREF(thr,h)              DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) (h))
++#define DUK_HOBJECT_INCREF(thr,h)              DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) (h))
++#define DUK_HOBJECT_DECREF(thr,h)              DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) (h))
++#define DUK_HBUFFER_INCREF(thr,h)              DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) (h))
++#define DUK_HBUFFER_DECREF(thr,h)              DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) (h))
++#define DUK_HCOMPILEDFUNCTION_INCREF(thr,h)    DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj)
++#define DUK_HCOMPILEDFUNCTION_DECREF(thr,h)    DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) &(h)->obj)
++#define DUK_HNATIVEFUNCTION_INCREF(thr,h)      DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj)
++#define DUK_HNATIVEFUNCTION_DECREF(thr,h)      DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) &(h)->obj)
++#define DUK_HTHREAD_INCREF(thr,h)              DUK_HEAPHDR_INCREF((thr),(duk_heaphdr *) &(h)->obj)
++#define DUK_HTHREAD_DECREF(thr,h)              DUK_HEAPHDR_DECREF((thr),(duk_heaphdr *) &(h)->obj)
++
++/* Convenience for some situations; the above macros don't allow NULLs
++ * for performance reasons.
++ */
++#define DUK_HOBJECT_INCREF_ALLOWNULL(thr,h) do { \
++		if ((h) != NULL) { \
++			DUK_HEAPHDR_INCREF((thr), (duk_heaphdr *) (h)); \
++		} \
++	} while (0)
++#define DUK_HOBJECT_DECREF_ALLOWNULL(thr,h) do { \
++		if ((h) != NULL) { \
++			DUK_HEAPHDR_DECREF((thr), (duk_heaphdr *) (h)); \
++		} \
++	} while (0)
++
++#else  /* DUK_USE_REFERENCE_COUNTING */
++
++#define DUK_TVAL_INCREF_FAST(thr,v)            do {} while (0) /* nop */
++#define DUK_TVAL_DECREF_FAST(thr,v)            do {} while (0) /* nop */
++#define DUK_TVAL_INCREF_SLOW(thr,v)            do {} while (0) /* nop */
++#define DUK_TVAL_DECREF_SLOW(thr,v)            do {} while (0) /* nop */
++#define DUK_TVAL_INCREF(thr,v)                 do {} while (0) /* nop */
++#define DUK_TVAL_DECREF(thr,v)                 do {} while (0) /* nop */
++#define DUK_HEAPHDR_INCREF_FAST(thr,h)         do {} while (0) /* nop */
++#define DUK_HEAPHDR_DECREF_FAST(thr,h)         do {} while (0) /* nop */
++#define DUK_HEAPHDR_INCREF_SLOW(thr,h)         do {} while (0) /* nop */
++#define DUK_HEAPHDR_DECREF_SLOW(thr,h)         do {} while (0) /* nop */
++#define DUK_HEAPHDR_INCREF(thr,h)              do {} while (0) /* nop */
++#define DUK_HEAPHDR_DECREF(thr,h)              do {} while (0) /* nop */
++#define DUK_HSTRING_INCREF(thr,h)              do {} while (0) /* nop */
++#define DUK_HSTRING_DECREF(thr,h)              do {} while (0) /* nop */
++#define DUK_HOBJECT_INCREF(thr,h)              do {} while (0) /* nop */
++#define DUK_HOBJECT_DECREF(thr,h)              do {} while (0) /* nop */
++#define DUK_HBUFFER_INCREF(thr,h)              do {} while (0) /* nop */
++#define DUK_HBUFFER_DECREF(thr,h)              do {} while (0) /* nop */
++#define DUK_HCOMPILEDFUNCTION_INCREF(thr,h)    do {} while (0) /* nop */
++#define DUK_HCOMPILEDFUNCTION_DECREF(thr,h)    do {} while (0) /* nop */
++#define DUK_HNATIVEFUNCTION_INCREF(thr,h)      do {} while (0) /* nop */
++#define DUK_HNATIVEFUNCTION_DECREF(thr,h)      do {} while (0) /* nop */
++#define DUK_HTHREAD_INCREF(thr,h)              do {} while (0) /* nop */
++#define DUK_HTHREAD_DECREF(thr,h)              do {} while (0) /* nop */
++#define DUK_HOBJECT_INCREF_ALLOWNULL(thr,h)    do {} while (0) /* nop */
++#define DUK_HOBJECT_DECREF_ALLOWNULL(thr,h)    do {} while (0) /* nop */
++
++#endif  /* DUK_USE_REFERENCE_COUNTING */
++
++#endif  /* DUK_HEAPHDR_H_INCLUDED */
++#line 1 "duk_api_internal.h"
++/*
++ *  Internal API calls which have (stack and other) semantics similar
++ *  to the public API.
++ */
++
++#ifndef DUK_API_INTERNAL_H_INCLUDED
++#define DUK_API_INTERNAL_H_INCLUDED
++
++/* duk_push_sprintf constants */
++#define DUK_PUSH_SPRINTF_INITIAL_SIZE  256L
++#define DUK_PUSH_SPRINTF_SANITY_LIMIT  (1L * 1024L * 1024L * 1024L)
++
++/* Flag ORed to err_code to indicate __FILE__ / __LINE__ is not
++ * blamed as source of error for error fileName / lineNumber.
++ */
++#define DUK_ERRCODE_FLAG_NOBLAME_FILELINE  (1L << 24)
++
++/* Valstack resize flags */
++#define DUK_VSRESIZE_FLAG_SHRINK           (1 << 0)
++#define DUK_VSRESIZE_FLAG_COMPACT          (1 << 1)
++#define DUK_VSRESIZE_FLAG_THROW            (1 << 2)
++
++/* Current convention is to use duk_size_t for value stack sizes and global indices,
++ * and duk_idx_t for local frame indices.
++ */
++DUK_INTERNAL_DECL
++duk_bool_t duk_valstack_resize_raw(duk_context *ctx,
++                                   duk_size_t min_new_size,
++                                   duk_small_uint_t flags);
++
++DUK_INTERNAL_DECL duk_tval *duk_get_tval(duk_context *ctx, duk_idx_t index);
++DUK_INTERNAL_DECL duk_tval *duk_require_tval(duk_context *ctx, duk_idx_t index);
++DUK_INTERNAL_DECL void duk_push_tval(duk_context *ctx, duk_tval *tv);
++
++/* Push the current 'this' binding; throw TypeError if binding is not object
++ * coercible (CheckObjectCoercible).
++ */
++DUK_INTERNAL_DECL void duk_push_this_check_object_coercible(duk_context *ctx);
++
++/* duk_push_this() + CheckObjectCoercible() + duk_to_object() */
++DUK_INTERNAL_DECL duk_hobject *duk_push_this_coercible_to_object(duk_context *ctx);
++
++/* duk_push_this() + CheckObjectCoercible() + duk_to_string() */
++DUK_INTERNAL_DECL duk_hstring *duk_push_this_coercible_to_string(duk_context *ctx);
++
++/* duk_push_(u)int() is guaranteed to support at least (un)signed 32-bit range */
++#define duk_push_u32(ctx,val) \
++	duk_push_uint((ctx), (duk_uint_t) (val))
++#define duk_push_i32(ctx,val) \
++	duk_push_int((ctx), (duk_int_t) (val))
++
++/* sometimes stack and array indices need to go on the stack */
++#define duk_push_idx(ctx,val) \
++	duk_push_int((ctx), (duk_int_t) (val))
++#define duk_push_uarridx(ctx,val) \
++	duk_push_uint((ctx), (duk_uint_t) (val))
++#define duk_push_size_t(ctx,val) \
++	duk_push_uint((ctx), (duk_uint_t) (val))  /* XXX: assumed to fit for now */
++
++/* internal helper for looking up a tagged type */
++#define  DUK_GETTAGGED_FLAG_ALLOW_NULL  (1L << 24)
++#define  DUK_GETTAGGED_FLAG_CHECK_CLASS (1L << 25)
++#define  DUK_GETTAGGED_CLASS_SHIFT      16
++
++DUK_INTERNAL_DECL duk_heaphdr *duk_get_tagged_heaphdr_raw(duk_context *ctx, duk_idx_t index, duk_uint_t flags_and_tag);
++
++DUK_INTERNAL_DECL duk_hstring *duk_get_hstring(duk_context *ctx, duk_idx_t index);
++DUK_INTERNAL_DECL duk_hobject *duk_get_hobject(duk_context *ctx, duk_idx_t index);
++DUK_INTERNAL_DECL duk_hbuffer *duk_get_hbuffer(duk_context *ctx, duk_idx_t index);
++DUK_INTERNAL_DECL duk_hthread *duk_get_hthread(duk_context *ctx, duk_idx_t index);
++DUK_INTERNAL_DECL duk_hcompiledfunction *duk_get_hcompiledfunction(duk_context *ctx, duk_idx_t index);
++DUK_INTERNAL_DECL duk_hnativefunction *duk_get_hnativefunction(duk_context *ctx, duk_idx_t index);
++
++#define duk_get_hobject_with_class(ctx,index,classnum) \
++	((duk_hobject *) duk_get_tagged_heaphdr_raw((ctx), (index), \
++		DUK_TAG_OBJECT | DUK_GETTAGGED_FLAG_ALLOW_NULL | \
++		DUK_GETTAGGED_FLAG_CHECK_CLASS | ((classnum) << DUK_GETTAGGED_CLASS_SHIFT)))
++
++#if 0  /* This would be pointless: unexpected type and lightfunc would both return NULL */
++DUK_INTERNAL_DECL duk_hobject *duk_get_hobject_or_lfunc(duk_context *ctx, duk_idx_t index);
++#endif
++DUK_INTERNAL_DECL duk_hobject *duk_get_hobject_or_lfunc_coerce(duk_context *ctx, duk_idx_t index);
++
++#if 0  /*unused*/
++DUK_INTERNAL_DECL void *duk_get_voidptr(duk_context *ctx, duk_idx_t index);
++#endif
++
++DUK_INTERNAL_DECL duk_hstring *duk_to_hstring(duk_context *ctx, duk_idx_t index);
++DUK_INTERNAL_DECL duk_int_t duk_to_int_clamped_raw(duk_context *ctx, duk_idx_t index, duk_int_t minval, duk_int_t maxval, duk_bool_t *out_clamped);  /* out_clamped=NULL, RangeError if outside range */
++DUK_INTERNAL_DECL duk_int_t duk_to_int_clamped(duk_context *ctx, duk_idx_t index, duk_int_t minval, duk_int_t maxval);
++DUK_INTERNAL_DECL duk_int_t duk_to_int_check_range(duk_context *ctx, duk_idx_t index, duk_int_t minval, duk_int_t maxval);
++
++DUK_INTERNAL_DECL duk_hstring *duk_require_hstring(duk_context *ctx, duk_idx_t index);
++DUK_INTERNAL_DECL duk_hobject *duk_require_hobject(duk_context *ctx, duk_idx_t index);
++DUK_INTERNAL_DECL duk_hbuffer *duk_require_hbuffer(duk_context *ctx, duk_idx_t index);
++DUK_INTERNAL_DECL duk_hthread *duk_require_hthread(duk_context *ctx, duk_idx_t index);
++#if 0  /*unused */
++DUK_INTERNAL_DECL duk_hcompiledfunction *duk_require_hcompiledfunction(duk_context *ctx, duk_idx_t index);
++#endif
++DUK_INTERNAL_DECL duk_hnativefunction *duk_require_hnativefunction(duk_context *ctx, duk_idx_t index);
++
++#define duk_require_hobject_with_class(ctx,index,classnum) \
++	((duk_hobject *) duk_get_tagged_heaphdr_raw((ctx), (index), \
++		DUK_TAG_OBJECT | \
++		DUK_GETTAGGED_FLAG_CHECK_CLASS | ((classnum) << DUK_GETTAGGED_CLASS_SHIFT)))
++
++DUK_INTERNAL_DECL duk_hobject *duk_require_hobject_or_lfunc(duk_context *ctx, duk_idx_t index);
++DUK_INTERNAL_DECL duk_hobject *duk_require_hobject_or_lfunc_coerce(duk_context *ctx, duk_idx_t index);
++
++#if defined(DUK_USE_DEBUGGER_SUPPORT)
++DUK_INTERNAL_DECL void duk_push_unused(duk_context *ctx);
++#endif
++DUK_INTERNAL_DECL void duk_push_hstring(duk_context *ctx, duk_hstring *h);
++DUK_INTERNAL_DECL void duk_push_hstring_stridx(duk_context *ctx, duk_small_int_t stridx);
++DUK_INTERNAL_DECL void duk_push_hobject(duk_context *ctx, duk_hobject *h);
++DUK_INTERNAL_DECL void duk_push_hbuffer(duk_context *ctx, duk_hbuffer *h);
++#define duk_push_hthread(ctx,h) \
++	duk_push_hobject((ctx), (duk_hobject *) (h))
++#define duk_push_hcompiledfunction(ctx,h) \
++	duk_push_hobject((ctx), (duk_hobject *) (h))
++#define duk_push_hnativefunction(ctx,h) \
++	duk_push_hobject((ctx), (duk_hobject *) (h))
++DUK_INTERNAL_DECL void duk_push_hobject_bidx(duk_context *ctx, duk_small_int_t builtin_idx);
++DUK_INTERNAL_DECL duk_idx_t duk_push_object_helper(duk_context *ctx, duk_uint_t hobject_flags_and_class, duk_small_int_t prototype_bidx);
++DUK_INTERNAL_DECL duk_idx_t duk_push_object_helper_proto(duk_context *ctx, duk_uint_t hobject_flags_and_class, duk_hobject *proto);
++DUK_INTERNAL_DECL duk_idx_t duk_push_object_internal(duk_context *ctx);
++DUK_INTERNAL_DECL duk_idx_t duk_push_compiledfunction(duk_context *ctx);
++DUK_INTERNAL_DECL void duk_push_c_function_noexotic(duk_context *ctx, duk_c_function func, duk_int_t nargs);
++DUK_INTERNAL_DECL void duk_push_c_function_noconstruct_noexotic(duk_context *ctx, duk_c_function func, duk_int_t nargs);
++
++DUK_INTERNAL_DECL void duk_push_string_funcptr(duk_context *ctx, duk_uint8_t *ptr, duk_size_t sz);
++DUK_INTERNAL_DECL void duk_push_lightfunc_name(duk_context *ctx, duk_tval *tv);
++DUK_INTERNAL_DECL void duk_push_lightfunc_tostring(duk_context *ctx, duk_tval *tv);
++
++DUK_INTERNAL_DECL duk_bool_t duk_get_prop_stridx(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx);     /* [] -> [val] */
++DUK_INTERNAL_DECL duk_bool_t duk_put_prop_stridx(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx);     /* [val] -> [] */
++DUK_INTERNAL_DECL duk_bool_t duk_del_prop_stridx(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx);     /* [] -> [] */
++DUK_INTERNAL_DECL duk_bool_t duk_has_prop_stridx(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx);     /* [] -> [] */
++
++DUK_INTERNAL_DECL duk_bool_t duk_get_prop_stridx_boolean(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx, duk_bool_t *out_has_prop);  /* [] -> [] */
++
++DUK_INTERNAL_DECL void duk_xdef_prop(duk_context *ctx, duk_idx_t obj_index, duk_small_uint_t desc_flags);  /* [key val] -> [] */
++DUK_INTERNAL_DECL void duk_xdef_prop_index(duk_context *ctx, duk_idx_t obj_index, duk_uarridx_t arr_index, duk_small_uint_t desc_flags);  /* [val] -> [] */
++DUK_INTERNAL_DECL void duk_xdef_prop_stridx(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx, duk_small_uint_t desc_flags);  /* [val] -> [] */
++DUK_INTERNAL_DECL void duk_xdef_prop_stridx_builtin(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx, duk_small_int_t builtin_idx, duk_small_uint_t desc_flags);  /* [] -> [] */
++DUK_INTERNAL_DECL void duk_xdef_prop_stridx_thrower(duk_context *ctx, duk_idx_t obj_index, duk_small_int_t stridx, duk_small_uint_t desc_flags);  /* [] -> [] */
++
++/* These are macros for now, but could be separate functions to reduce code
++ * footprint (check call site count before refactoring).
++ */
++#define duk_xdef_prop_wec(ctx,obj_index) \
++	duk_xdef_prop((ctx), (obj_index), DUK_PROPDESC_FLAGS_WEC)
++#define duk_xdef_prop_index_wec(ctx,obj_index,arr_index) \
++	duk_xdef_prop_index((ctx), (obj_index), (arr_index), DUK_PROPDESC_FLAGS_WEC)
++#define duk_xdef_prop_stridx_wec(ctx,obj_index,stridx) \
++	duk_xdef_prop_stridx((ctx), (obj_index), (stridx), DUK_PROPDESC_FLAGS_WEC)
++
++/* Set object 'length'. */
++DUK_INTERNAL_DECL void duk_set_length(duk_context *ctx, duk_idx_t index, duk_size_t length);
++
++#endif  /* DUK_API_INTERNAL_H_INCLUDED */
++#line 1 "duk_hstring.h"
++/*
++ *  Heap string representation.
++ *
++ *  Strings are byte sequences ordinarily stored in extended UTF-8 format,
++ *  allowing values larger than the official UTF-8 range (used internally)
++ *  and also allowing UTF-8 encoding of surrogate pairs (CESU-8 format).
++ *  Strings may also be invalid UTF-8 altogether which is the case e.g. with
++ *  strings used as internal property names and raw buffers converted to
++ *  strings.  In such cases the 'clen' field contains an inaccurate value.
++ *
++ *  Ecmascript requires support for 32-bit long strings.  However, since each
++ *  16-bit codepoint can take 3 bytes in CESU-8, this representation can only
++ *  support about 1.4G codepoint long strings in extreme cases.  This is not
++ *  really a practical issue.
++ */
++
++#ifndef DUK_HSTRING_H_INCLUDED
++#define DUK_HSTRING_H_INCLUDED
++
++/* Impose a maximum string length for now.  Restricted artificially to
++ * ensure adding a heap header length won't overflow size_t.  The limit
++ * should be synchronized with DUK_HBUFFER_MAX_BYTELEN.
++ *
++ * E5.1 makes provisions to support strings longer than 4G characters.
++ * This limit should be eliminated on 64-bit platforms (and increased
++ * closer to maximum support on 32-bit platforms).
++ */
++
++#if defined(DUK_USE_STRLEN16)
++#define DUK_HSTRING_MAX_BYTELEN                     (0x0000ffffUL)
++#else
++#define DUK_HSTRING_MAX_BYTELEN                     (0x7fffffffUL)
++#endif
++
++/* XXX: could add flags for "is valid CESU-8" (Ecmascript compatible strings),
++ * "is valid UTF-8", "is valid extended UTF-8" (internal strings are not,
++ * regexp bytecode is), and "contains non-BMP characters".  These are not
++ * needed right now.
++ */
++
++#define DUK_HSTRING_FLAG_ARRIDX                     DUK_HEAPHDR_USER_FLAG(0)  /* string is a valid array index */
++#define DUK_HSTRING_FLAG_INTERNAL                   DUK_HEAPHDR_USER_FLAG(1)  /* string is internal */
++#define DUK_HSTRING_FLAG_RESERVED_WORD              DUK_HEAPHDR_USER_FLAG(2)  /* string is a reserved word (non-strict) */
++#define DUK_HSTRING_FLAG_STRICT_RESERVED_WORD       DUK_HEAPHDR_USER_FLAG(3)  /* string is a reserved word (strict) */
++#define DUK_HSTRING_FLAG_EVAL_OR_ARGUMENTS          DUK_HEAPHDR_USER_FLAG(4)  /* string is 'eval' or 'arguments' */
++#define DUK_HSTRING_FLAG_EXTDATA                    DUK_HEAPHDR_USER_FLAG(5)  /* string data is external (duk_hstring_external) */
++
++#define DUK_HSTRING_HAS_ARRIDX(x)                   DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ARRIDX)
++#define DUK_HSTRING_HAS_INTERNAL(x)                 DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_INTERNAL)
++#define DUK_HSTRING_HAS_RESERVED_WORD(x)            DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_RESERVED_WORD)
++#define DUK_HSTRING_HAS_STRICT_RESERVED_WORD(x)     DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_STRICT_RESERVED_WORD)
++#define DUK_HSTRING_HAS_EVAL_OR_ARGUMENTS(x)        DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EVAL_OR_ARGUMENTS)
++#define DUK_HSTRING_HAS_EXTDATA(x)                  DUK_HEAPHDR_CHECK_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EXTDATA)
++
++#define DUK_HSTRING_SET_ARRIDX(x)                   DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ARRIDX)
++#define DUK_HSTRING_SET_INTERNAL(x)                 DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_INTERNAL)
++#define DUK_HSTRING_SET_RESERVED_WORD(x)            DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_RESERVED_WORD)
++#define DUK_HSTRING_SET_STRICT_RESERVED_WORD(x)     DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_STRICT_RESERVED_WORD)
++#define DUK_HSTRING_SET_EVAL_OR_ARGUMENTS(x)        DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EVAL_OR_ARGUMENTS)
++#define DUK_HSTRING_SET_EXTDATA(x)                  DUK_HEAPHDR_SET_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EXTDATA)
++
++#define DUK_HSTRING_CLEAR_ARRIDX(x)                 DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_ARRIDX)
++#define DUK_HSTRING_CLEAR_INTERNAL(x)               DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_INTERNAL)
++#define DUK_HSTRING_CLEAR_RESERVED_WORD(x)          DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_RESERVED_WORD)
++#define DUK_HSTRING_CLEAR_STRICT_RESERVED_WORD(x)   DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_STRICT_RESERVED_WORD)
++#define DUK_HSTRING_CLEAR_EVAL_OR_ARGUMENTS(x)      DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EVAL_OR_ARGUMENTS)
++#define DUK_HSTRING_CLEAR_EXTDATA(x)                DUK_HEAPHDR_CLEAR_FLAG_BITS(&(x)->hdr, DUK_HSTRING_FLAG_EXTDATA)
++
++#define DUK_HSTRING_IS_ASCII(x)                     (DUK_HSTRING_GET_BYTELEN((x)) == DUK_HSTRING_GET_CHARLEN((x)))
++#define DUK_HSTRING_IS_EMPTY(x)                     (DUK_HSTRING_GET_BYTELEN((x)) == 0)
++
++#if defined(DUK_USE_STRHASH16)
++#define DUK_HSTRING_GET_HASH(x)                     ((x)->hdr.h_flags >> 16)
++#define DUK_HSTRING_SET_HASH(x,v) do { \
++		(x)->hdr.h_flags = ((x)->hdr.h_flags & 0x0000ffffUL) | ((v) << 16); \
++	} while (0)
++#else
++#define DUK_HSTRING_GET_HASH(x)                     ((x)->hash)
++#define DUK_HSTRING_SET_HASH(x,v) do { \
++		(x)->hash = (v); \
++	} while (0)
++#endif
++
++#if defined(DUK_USE_STRLEN16)
++#define DUK_HSTRING_GET_BYTELEN(x)                  ((x)->blen16)
++#define DUK_HSTRING_SET_BYTELEN(x,v) do { \
++		(x)->blen16 = (v); \
++	} while (0)
++#define DUK_HSTRING_GET_CHARLEN(x)                  ((x)->clen16)
++#define DUK_HSTRING_SET_CHARLEN(x,v) do { \
++		(x)->clen16 = (v); \
++	} while (0)
++#else
++#define DUK_HSTRING_GET_BYTELEN(x)                  ((x)->blen)
++#define DUK_HSTRING_SET_BYTELEN(x,v) do { \
++		(x)->blen = (v); \
++	} while (0)
++#define DUK_HSTRING_GET_CHARLEN(x)                  ((x)->clen)
++#define DUK_HSTRING_SET_CHARLEN(x,v) do { \
++		(x)->clen = (v); \
++	} while (0)
++#endif
++
++#if defined(DUK_USE_HSTRING_EXTDATA)
++#define DUK_HSTRING_GET_EXTDATA(x) \
++	((x)->extdata)
++#define DUK_HSTRING_GET_DATA(x) \
++	(DUK_HSTRING_HAS_EXTDATA((x)) ? \
++		DUK_HSTRING_GET_EXTDATA((duk_hstring_external *) (x)) : ((const duk_uint8_t *) ((x) + 1)))
++#else
++#define DUK_HSTRING_GET_DATA(x) \
++	((const duk_uint8_t *) ((x) + 1))
++#endif
++
++#define DUK_HSTRING_GET_DATA_END(x) \
++	(DUK_HSTRING_GET_DATA((x)) + (x)->blen)
++
++/* marker value; in E5 2^32-1 is not a valid array index (2^32-2 is highest valid) */
++#define DUK_HSTRING_NO_ARRAY_INDEX  (0xffffffffUL)
++
++/* get array index related to string (or return DUK_HSTRING_NO_ARRAY_INDEX);
++ * avoids helper call if string has no array index value.
++ */
++#define DUK_HSTRING_GET_ARRIDX_FAST(h)  \
++	(DUK_HSTRING_HAS_ARRIDX((h)) ? duk_js_to_arrayindex_string_helper((h)) : DUK_HSTRING_NO_ARRAY_INDEX)
++
++/* slower but more compact variant */
++#define DUK_HSTRING_GET_ARRIDX_SLOW(h)  \
++	(duk_js_to_arrayindex_string_helper((h)))
++
++/*
++ *  Misc
++ */
++
++struct duk_hstring {
++	/* Smaller heaphdr than for other objects, because strings are held
++	 * in string intern table which requires no link pointers.  Much of
++	 * the 32-bit flags field is unused by flags, so we can stuff a 16-bit
++	 * field in there.
++	 */
++	duk_heaphdr_string hdr;
++
++	/* Note: we could try to stuff a partial hash (e.g. 16 bits) into the
++	 * shared heap header.  Good hashing needs more hash bits though.
++	 */
++
++	/* string hash */
++#if defined(DUK_USE_STRHASH16)
++	/* If 16-bit hash is in use, stuff it into duk_heaphdr_string flags. */
++#else
++	duk_uint32_t hash;
++#endif
++
++	/* length in bytes (not counting NUL term) */
++#if defined(DUK_USE_STRLEN16)
++	duk_uint16_t blen16;
++#else
++	duk_uint32_t blen;
++#endif
++
++	/* length in codepoints (must be E5 compatible) */
++#if defined(DUK_USE_STRLEN16)
++	duk_uint16_t clen16;
++#else
++	duk_uint32_t clen;
++#endif
++
++	/*
++	 *  String value of 'blen+1' bytes follows (+1 for NUL termination
++	 *  convenience for C API).  No alignment needs to be guaranteed
++	 *  for strings, but fields above should guarantee alignment-by-4
++	 *  (but not alignment-by-8).
++	 */
++};
++
++/* The external string struct is defined even when the feature is inactive. */
++struct duk_hstring_external {
++	duk_hstring str;
++
++	/*
++	 *  For an external string, the NUL-terminated string data is stored
++	 *  externally.  The user must guarantee that data behind this pointer
++	 *  doesn't change while it's used.
++	 */
++
++	const duk_uint8_t *extdata;
++};
++
++/*
++ *  Prototypes
++ */
++
++DUK_INTERNAL_DECL duk_ucodepoint_t duk_hstring_char_code_at_raw(duk_hthread *thr, duk_hstring *h, duk_uint_t pos);
++
++#endif  /* DUK_HSTRING_H_INCLUDED */
++#line 1 "duk_hobject.h"
++/*
++ *  Heap object representation.
++ *
++ *  Heap objects are used for Ecmascript objects, arrays, and functions,
++ *  but also for internal control like declarative and object environment
++ *  records.  Compiled functions, native functions, and threads are also
++ *  objects but with an extended C struct.
++ *
++ *  Objects provide the required Ecmascript semantics and exotic behaviors
++ *  especially for property access.
++ *
++ *  Properties are stored in three conceptual parts:
++ *
++ *    1. A linear 'entry part' contains ordered key-value-attributes triples
++ *       and is the main method of string properties.
++ *
++ *    2. An optional linear 'array part' is used for array objects to store a
++ *       (dense) range of [0,N[ array indexed entries with default attributes
++ *       (writable, enumerable, configurable).  If the array part would become
++ *       sparse or non-default attributes are required, the array part is
++ *       abandoned and moved to the 'entry part'.
++ *
++ *    3. An optional 'hash part' is used to optimize lookups of the entry
++ *       part; it is used only for objects with sufficiently many properties
++ *       and can be abandoned without loss of information.
++ *
++ *  These three conceptual parts are stored in a single memory allocated area.
++ *  This minimizes memory allocation overhead but also means that all three
++ *  parts are resized together, and makes property access a bit complicated.
++ */
++
++#ifndef DUK_HOBJECT_H_INCLUDED
++#define DUK_HOBJECT_H_INCLUDED
++
++/* there are currently 26 flag bits available */
++#define DUK_HOBJECT_FLAG_EXTENSIBLE            DUK_HEAPHDR_USER_FLAG(0)   /* object is extensible */
++#define DUK_HOBJECT_FLAG_CONSTRUCTABLE         DUK_HEAPHDR_USER_FLAG(1)   /* object is constructable */
++#define DUK_HOBJECT_FLAG_BOUND                 DUK_HEAPHDR_USER_FLAG(2)   /* object established using Function.prototype.bind() */
++#define DUK_HOBJECT_FLAG_COMPILEDFUNCTION      DUK_HEAPHDR_USER_FLAG(4)   /* object is a compiled function (duk_hcompiledfunction) */
++#define DUK_HOBJECT_FLAG_NATIVEFUNCTION        DUK_HEAPHDR_USER_FLAG(5)   /* object is a native function (duk_hnativefunction) */
++#define DUK_HOBJECT_FLAG_THREAD                DUK_HEAPHDR_USER_FLAG(6)   /* object is a thread (duk_hthread) */
++#define DUK_HOBJECT_FLAG_ARRAY_PART            DUK_HEAPHDR_USER_FLAG(7)   /* object has an array part (a_size may still be 0) */
++#define DUK_HOBJECT_FLAG_STRICT                DUK_HEAPHDR_USER_FLAG(8)   /* function: function object is strict */
++#define DUK_HOBJECT_FLAG_NOTAIL                DUK_HEAPHDR_USER_FLAG(9)   /* function: function must not be tailcalled */
++#define DUK_HOBJECT_FLAG_NEWENV                DUK_HEAPHDR_USER_FLAG(10)  /* function: create new environment when called (see duk_hcompiledfunction) */
++#define DUK_HOBJECT_FLAG_NAMEBINDING           DUK_HEAPHDR_USER_FLAG(11)  /* function: create binding for func name (function templates only, used for named function expressions) */
++#define DUK_HOBJECT_FLAG_CREATEARGS            DUK_HEAPHDR_USER_FLAG(12)  /* function: create an arguments object on function call */
++#define DUK_HOBJECT_FLAG_ENVRECCLOSED          DUK_HEAPHDR_USER_FLAG(13)  /* envrec: (declarative) record is closed */
++#define DUK_HOBJECT_FLAG_EXOTIC_ARRAY          DUK_HEAPHDR_USER_FLAG(14)  /* 'Array' object, array length and index exotic behavior */
++#define DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ      DUK_HEAPHDR_USER_FLAG(15)  /* 'String' object, array index exotic behavior */
++#define DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS      DUK_HEAPHDR_USER_FLAG(16)  /* 'Arguments' object and has arguments exotic behavior (non-strict callee) */
++#define DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC        DUK_HEAPHDR_USER_FLAG(17)  /* Duktape/C (nativefunction) object, exotic 'length' */
++#define DUK_HOBJECT_FLAG_EXOTIC_BUFFEROBJ      DUK_HEAPHDR_USER_FLAG(18)  /* 'Buffer' object, array index exotic behavior, virtual 'length' */
++#define DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ       DUK_HEAPHDR_USER_FLAG(19)  /* 'Proxy' object */
++/* bit 20 unused */
++
++#define DUK_HOBJECT_FLAG_CLASS_BASE            DUK_HEAPHDR_USER_FLAG_NUMBER(21)
++#define DUK_HOBJECT_FLAG_CLASS_BITS            5
++
++#define DUK_HOBJECT_GET_CLASS_NUMBER(h)        \
++	DUK_HEAPHDR_GET_FLAG_RANGE(&(h)->hdr, DUK_HOBJECT_FLAG_CLASS_BASE, DUK_HOBJECT_FLAG_CLASS_BITS)
++#define DUK_HOBJECT_SET_CLASS_NUMBER(h,v)      \
++	DUK_HEAPHDR_SET_FLAG_RANGE(&(h)->hdr, DUK_HOBJECT_FLAG_CLASS_BASE, DUK_HOBJECT_FLAG_CLASS_BITS, (v))
++
++/* Macro for creating flag initializer from a class number.
++ * Unsigned type cast is needed to avoid warnings about coercing
++ * a signed integer to an unsigned one; the largest class values
++ * have the highest bit (bit 31) set which causes this.
++ */
++#define DUK_HOBJECT_CLASS_AS_FLAGS(v)          (((duk_uint_t) (v)) << DUK_HOBJECT_FLAG_CLASS_BASE)
++
++/* E5 Section 8.6.2 + custom classes */
++#define DUK_HOBJECT_CLASS_UNUSED               0
++#define DUK_HOBJECT_CLASS_ARGUMENTS            1
++#define DUK_HOBJECT_CLASS_ARRAY                2
++#define DUK_HOBJECT_CLASS_BOOLEAN              3
++#define DUK_HOBJECT_CLASS_DATE                 4
++#define DUK_HOBJECT_CLASS_ERROR                5
++#define DUK_HOBJECT_CLASS_FUNCTION             6
++#define DUK_HOBJECT_CLASS_JSON                 7
++#define DUK_HOBJECT_CLASS_MATH                 8
++#define DUK_HOBJECT_CLASS_NUMBER               9
++#define DUK_HOBJECT_CLASS_OBJECT               10
++#define DUK_HOBJECT_CLASS_REGEXP               11
++#define DUK_HOBJECT_CLASS_STRING               12
++#define DUK_HOBJECT_CLASS_GLOBAL               13
++#define DUK_HOBJECT_CLASS_OBJENV               14  /* custom */
++#define DUK_HOBJECT_CLASS_DECENV               15  /* custom */
++#define DUK_HOBJECT_CLASS_BUFFER               16  /* custom */
++#define DUK_HOBJECT_CLASS_POINTER              17  /* custom */
++#define DUK_HOBJECT_CLASS_THREAD               18  /* custom */
++
++#define DUK_HOBJECT_IS_OBJENV(h)               (DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_OBJENV)
++#define DUK_HOBJECT_IS_DECENV(h)               (DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_DECENV)
++#define DUK_HOBJECT_IS_ENV(h)                  (DUK_HOBJECT_IS_OBJENV((h)) || DUK_HOBJECT_IS_DECENV((h)))
++#define DUK_HOBJECT_IS_ARRAY(h)                (DUK_HOBJECT_GET_CLASS_NUMBER((h)) == DUK_HOBJECT_CLASS_ARRAY)
++#define DUK_HOBJECT_IS_COMPILEDFUNCTION(h)     DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPILEDFUNCTION)
++#define DUK_HOBJECT_IS_NATIVEFUNCTION(h)       DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATIVEFUNCTION)
++#define DUK_HOBJECT_IS_THREAD(h)               DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_THREAD)
++
++#define DUK_HOBJECT_IS_NONBOUND_FUNCTION(h)    DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, \
++                                                        DUK_HOBJECT_FLAG_COMPILEDFUNCTION | \
++                                                        DUK_HOBJECT_FLAG_NATIVEFUNCTION)
++
++#define DUK_HOBJECT_IS_FUNCTION(h)             DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, \
++                                                        DUK_HOBJECT_FLAG_BOUND | \
++                                                        DUK_HOBJECT_FLAG_COMPILEDFUNCTION | \
++                                                        DUK_HOBJECT_FLAG_NATIVEFUNCTION)
++
++#define DUK_HOBJECT_IS_CALLABLE(h)             DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, \
++                                                        DUK_HOBJECT_FLAG_BOUND | \
++                                                        DUK_HOBJECT_FLAG_COMPILEDFUNCTION | \
++                                                        DUK_HOBJECT_FLAG_NATIVEFUNCTION)
++
++/* object has any exotic behavior(s) */
++#define DUK_HOBJECT_EXOTIC_BEHAVIOR_FLAGS      (DUK_HOBJECT_FLAG_EXOTIC_ARRAY | \
++                                                DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS | \
++                                                DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ | \
++                                                DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC | \
++                                                DUK_HOBJECT_FLAG_EXOTIC_BUFFEROBJ | \
++                                                DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ)
++
++#define DUK_HOBJECT_HAS_EXOTIC_BEHAVIOR(h)     DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_EXOTIC_BEHAVIOR_FLAGS)
++
++#define DUK_HOBJECT_HAS_EXTENSIBLE(h)          DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXTENSIBLE)
++#define DUK_HOBJECT_HAS_CONSTRUCTABLE(h)       DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CONSTRUCTABLE)
++#define DUK_HOBJECT_HAS_BOUND(h)               DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BOUND)
++#define DUK_HOBJECT_HAS_COMPILEDFUNCTION(h)    DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPILEDFUNCTION)
++#define DUK_HOBJECT_HAS_NATIVEFUNCTION(h)      DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATIVEFUNCTION)
++#define DUK_HOBJECT_HAS_THREAD(h)              DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_THREAD)
++#define DUK_HOBJECT_HAS_ARRAY_PART(h)          DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_ARRAY_PART)
++#define DUK_HOBJECT_HAS_STRICT(h)              DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_STRICT)
++#define DUK_HOBJECT_HAS_NOTAIL(h)              DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NOTAIL)
++#define DUK_HOBJECT_HAS_NEWENV(h)              DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NEWENV)
++#define DUK_HOBJECT_HAS_NAMEBINDING(h)         DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NAMEBINDING)
++#define DUK_HOBJECT_HAS_CREATEARGS(h)          DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CREATEARGS)
++#define DUK_HOBJECT_HAS_ENVRECCLOSED(h)        DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_ENVRECCLOSED)
++#define DUK_HOBJECT_HAS_EXOTIC_ARRAY(h)        DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARRAY)
++#define DUK_HOBJECT_HAS_EXOTIC_STRINGOBJ(h)    DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ)
++#define DUK_HOBJECT_HAS_EXOTIC_ARGUMENTS(h)    DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS)
++#define DUK_HOBJECT_HAS_EXOTIC_DUKFUNC(h)      DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC)
++#define DUK_HOBJECT_HAS_EXOTIC_BUFFEROBJ(h)    DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_BUFFEROBJ)
++#define DUK_HOBJECT_HAS_EXOTIC_PROXYOBJ(h)     DUK_HEAPHDR_CHECK_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ)
++
++#define DUK_HOBJECT_SET_EXTENSIBLE(h)          DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXTENSIBLE)
++#define DUK_HOBJECT_SET_CONSTRUCTABLE(h)       DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CONSTRUCTABLE)
++#define DUK_HOBJECT_SET_BOUND(h)               DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BOUND)
++#define DUK_HOBJECT_SET_COMPILEDFUNCTION(h)    DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPILEDFUNCTION)
++#define DUK_HOBJECT_SET_NATIVEFUNCTION(h)      DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATIVEFUNCTION)
++#define DUK_HOBJECT_SET_THREAD(h)              DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_THREAD)
++#define DUK_HOBJECT_SET_ARRAY_PART(h)          DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_ARRAY_PART)
++#define DUK_HOBJECT_SET_STRICT(h)              DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_STRICT)
++#define DUK_HOBJECT_SET_NOTAIL(h)              DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NOTAIL)
++#define DUK_HOBJECT_SET_NEWENV(h)              DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NEWENV)
++#define DUK_HOBJECT_SET_NAMEBINDING(h)         DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NAMEBINDING)
++#define DUK_HOBJECT_SET_CREATEARGS(h)          DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CREATEARGS)
++#define DUK_HOBJECT_SET_ENVRECCLOSED(h)        DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_ENVRECCLOSED)
++#define DUK_HOBJECT_SET_EXOTIC_ARRAY(h)        DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARRAY)
++#define DUK_HOBJECT_SET_EXOTIC_STRINGOBJ(h)    DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ)
++#define DUK_HOBJECT_SET_EXOTIC_ARGUMENTS(h)    DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS)
++#define DUK_HOBJECT_SET_EXOTIC_DUKFUNC(h)      DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC)
++#define DUK_HOBJECT_SET_EXOTIC_BUFFEROBJ(h)    DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_BUFFEROBJ)
++#define DUK_HOBJECT_SET_EXOTIC_PROXYOBJ(h)     DUK_HEAPHDR_SET_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ)
++
++#define DUK_HOBJECT_CLEAR_EXTENSIBLE(h)        DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXTENSIBLE)
++#define DUK_HOBJECT_CLEAR_CONSTRUCTABLE(h)     DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CONSTRUCTABLE)
++#define DUK_HOBJECT_CLEAR_BOUND(h)             DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_BOUND)
++#define DUK_HOBJECT_CLEAR_COMPILEDFUNCTION(h)  DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_COMPILEDFUNCTION)
++#define DUK_HOBJECT_CLEAR_NATIVEFUNCTION(h)    DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NATIVEFUNCTION)
++#define DUK_HOBJECT_CLEAR_THREAD(h)            DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_THREAD)
++#define DUK_HOBJECT_CLEAR_ARRAY_PART(h)        DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_ARRAY_PART)
++#define DUK_HOBJECT_CLEAR_STRICT(h)            DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_STRICT)
++#define DUK_HOBJECT_CLEAR_NOTAIL(h)            DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NOTAIL)
++#define DUK_HOBJECT_CLEAR_NEWENV(h)            DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NEWENV)
++#define DUK_HOBJECT_CLEAR_NAMEBINDING(h)       DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_NAMEBINDING)
++#define DUK_HOBJECT_CLEAR_CREATEARGS(h)        DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_CREATEARGS)
++#define DUK_HOBJECT_CLEAR_ENVRECCLOSED(h)      DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_ENVRECCLOSED)
++#define DUK_HOBJECT_CLEAR_EXOTIC_ARRAY(h)      DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARRAY)
++#define DUK_HOBJECT_CLEAR_EXOTIC_STRINGOBJ(h)  DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_STRINGOBJ)
++#define DUK_HOBJECT_CLEAR_EXOTIC_ARGUMENTS(h)  DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_ARGUMENTS)
++#define DUK_HOBJECT_CLEAR_EXOTIC_DUKFUNC(h)    DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_DUKFUNC)
++#define DUK_HOBJECT_CLEAR_EXOTIC_BUFFEROBJ(h)  DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_BUFFEROBJ)
++#define DUK_HOBJECT_CLEAR_EXOTIC_PROXYOBJ(h)   DUK_HEAPHDR_CLEAR_FLAG_BITS(&(h)->hdr, DUK_HOBJECT_FLAG_EXOTIC_PROXYOBJ)
++
++/* flags used for property attributes in duk_propdesc and packed flags */
++#define DUK_PROPDESC_FLAG_WRITABLE              (1 << 0)    /* E5 Section 8.6.1 */
++#define DUK_PROPDESC_FLAG_ENUMERABLE            (1 << 1)    /* E5 Section 8.6.1 */
++#define DUK_PROPDESC_FLAG_CONFIGURABLE          (1 << 2)    /* E5 Section 8.6.1 */
++#define DUK_PROPDESC_FLAG_ACCESSOR              (1 << 3)    /* accessor */
++#define DUK_PROPDESC_FLAG_VIRTUAL               (1 << 4)    /* property is virtual: used in duk_propdesc, never stored
++                                                             * (used by e.g. buffer virtual properties)
++                                                             */
++#define DUK_PROPDESC_FLAGS_MASK                 (DUK_PROPDESC_FLAG_WRITABLE | \
++                                                 DUK_PROPDESC_FLAG_ENUMERABLE | \
++                                                 DUK_PROPDESC_FLAG_CONFIGURABLE | \
++                                                 DUK_PROPDESC_FLAG_ACCESSOR)
++
++/* additional flags which are passed in the same flags argument as property
++ * flags but are not stored in object properties.
++ */
++#define DUK_PROPDESC_FLAG_NO_OVERWRITE          (1 << 4)    /* internal define property: skip write silently if exists */
++
++/* convenience */
++#define DUK_PROPDESC_FLAGS_NONE                 0
++#define DUK_PROPDESC_FLAGS_W                    (DUK_PROPDESC_FLAG_WRITABLE)
++#define DUK_PROPDESC_FLAGS_E                    (DUK_PROPDESC_FLAG_ENUMERABLE)
++#define DUK_PROPDESC_FLAGS_C                    (DUK_PROPDESC_FLAG_CONFIGURABLE)
++#define DUK_PROPDESC_FLAGS_WE                   (DUK_PROPDESC_FLAG_WRITABLE | DUK_PROPDESC_FLAG_ENUMERABLE)
++#define DUK_PROPDESC_FLAGS_WC                   (DUK_PROPDESC_FLAG_WRITABLE | DUK_PROPDESC_FLAG_CONFIGURABLE)
++#define DUK_PROPDESC_FLAGS_EC                   (DUK_PROPDESC_FLAG_ENUMERABLE | DUK_PROPDESC_FLAG_CONFIGURABLE)
++#define DUK_PROPDESC_FLAGS_WEC                  (DUK_PROPDESC_FLAG_WRITABLE | \
++                                                 DUK_PROPDESC_FLAG_ENUMERABLE | \
++                                                 DUK_PROPDESC_FLAG_CONFIGURABLE)
++
++/*
++ *  Macros to access the 'props' allocation.
++ */
++
++#if defined(DUK_USE_HEAPPTR16)
++#define DUK_HOBJECT_GET_PROPS(heap,h) \
++	((duk_uint8_t *) DUK_USE_HEAPPTR_DEC16((heap)->heap_udata, ((duk_heaphdr *) (h))->h_extra16))
++#define DUK_HOBJECT_SET_PROPS(heap,h,x) do { \
++		((duk_heaphdr *) (h))->h_extra16 = DUK_USE_HEAPPTR_ENC16((heap)->heap_udata, (void *) (x)); \
++	} while (0)
++#else
++#define DUK_HOBJECT_GET_PROPS(heap,h) \
++	((h)->props)
++#define DUK_HOBJECT_SET_PROPS(heap,h,x) do { \
++		(h)->props = (x); \
++	} while (0)
++#endif
++
++#if defined(DUK_USE_HOBJECT_LAYOUT_1)
++/* LAYOUT 1 */
++#define DUK_HOBJECT_E_GET_KEY_BASE(heap,h) \
++	((duk_hstring **) ( \
++		DUK_HOBJECT_GET_PROPS((heap), (h)) \
++	))
++#define DUK_HOBJECT_E_GET_VALUE_BASE(heap,h) \
++	((duk_propvalue *) ( \
++		DUK_HOBJECT_GET_PROPS((heap), (h)) + \
++			DUK_HOBJECT_GET_ESIZE((h)) * sizeof(duk_hstring *) \
++	))
++#define DUK_HOBJECT_E_GET_FLAGS_BASE(heap,h) \
++	((duk_uint8_t *) ( \
++		DUK_HOBJECT_GET_PROPS((heap), (h)) + DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_hstring *) + sizeof(duk_propvalue)) \
++	))
++#define DUK_HOBJECT_A_GET_BASE(heap,h) \
++	((duk_tval *) ( \
++		DUK_HOBJECT_GET_PROPS((heap), (h)) + \
++			DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_hstring *) + sizeof(duk_propvalue) + sizeof(duk_uint8_t)) \
++	))
++#define DUK_HOBJECT_H_GET_BASE(heap,h) \
++	((duk_uint32_t *) ( \
++		DUK_HOBJECT_GET_PROPS((heap), (h)) + \
++			DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_hstring *) + sizeof(duk_propvalue) + sizeof(duk_uint8_t)) + \
++			DUK_HOBJECT_GET_ASIZE((h)) * sizeof(duk_tval) \
++	))
++#define DUK_HOBJECT_P_COMPUTE_SIZE(n_ent,n_arr,n_hash) \
++	( \
++		(n_ent) * (sizeof(duk_hstring *) + sizeof(duk_propvalue) + sizeof(duk_uint8_t)) + \
++		(n_arr) * sizeof(duk_tval) + \
++		(n_hash) * sizeof(duk_uint32_t) \
++	)
++#define DUK_HOBJECT_P_SET_REALLOC_PTRS(p_base,set_e_k,set_e_pv,set_e_f,set_a,set_h,n_ent,n_arr,n_hash)  do { \
++		(set_e_k) = (duk_hstring **) (p_base); \
++		(set_e_pv) = (duk_propvalue *) ((set_e_k) + (n_ent)); \
++		(set_e_f) = (duk_uint8_t *) ((set_e_pv) + (n_ent)); \
++		(set_a) = (duk_tval *) ((set_e_f) + (n_ent)); \
++		(set_h) = (duk_uint32_t *) ((set_a) + (n_arr)); \
++	} while (0)
++#elif defined(DUK_USE_HOBJECT_LAYOUT_2)
++/* LAYOUT 2 */
++#if defined(DUK_USE_ALIGN_4)
++#define DUK_HOBJECT_E_FLAG_PADDING(e_sz) ((4 - (e_sz)) & 0x03)
++#elif defined(DUK_USE_ALIGN_8)
++#define DUK_HOBJECT_E_FLAG_PADDING(e_sz) ((8 - (e_sz)) & 0x07)
++#else
++#define DUK_HOBJECT_E_FLAG_PADDING(e_sz) 0
++#endif
++#define DUK_HOBJECT_E_GET_KEY_BASE(heap,h) \
++	((duk_hstring **) ( \
++		DUK_HOBJECT_GET_PROPS((heap), (h)) + \
++			DUK_HOBJECT_GET_ESIZE((h)) * sizeof(duk_propvalue) \
++	))
++#define DUK_HOBJECT_E_GET_VALUE_BASE(heap,h) \
++	((duk_propvalue *) ( \
++		DUK_HOBJECT_GET_PROPS((heap), (h)) \
++	))
++#define DUK_HOBJECT_E_GET_FLAGS_BASE(heap,h) \
++	((duk_uint8_t *) ( \
++		DUK_HOBJECT_GET_PROPS((heap), (h)) + DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_hstring *) + sizeof(duk_propvalue)) \
++	))
++#define DUK_HOBJECT_A_GET_BASE(heap,h) \
++	((duk_tval *) ( \
++		DUK_HOBJECT_GET_PROPS((heap), (h)) + \
++			DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_hstring *) + sizeof(duk_propvalue) + sizeof(duk_uint8_t)) + \
++			DUK_HOBJECT_E_FLAG_PADDING(DUK_HOBJECT_GET_ESIZE((h))) \
++	))
++#define DUK_HOBJECT_H_GET_BASE(heap,h) \
++	((duk_uint32_t *) ( \
++		DUK_HOBJECT_GET_PROPS((heap), (h)) + \
++			DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_hstring *) + sizeof(duk_propvalue) + sizeof(duk_uint8_t)) + \
++			DUK_HOBJECT_E_FLAG_PADDING(DUK_HOBJECT_GET_ESIZE((h))) + \
++			DUK_HOBJECT_GET_ASIZE((h)) * sizeof(duk_tval) \
++	))
++#define DUK_HOBJECT_P_COMPUTE_SIZE(n_ent,n_arr,n_hash) \
++	( \
++		(n_ent) * (sizeof(duk_hstring *) + sizeof(duk_propvalue) + sizeof(duk_uint8_t)) + \
++		DUK_HOBJECT_E_FLAG_PADDING((n_ent)) + \
++		(n_arr) * sizeof(duk_tval) + \
++		(n_hash) * sizeof(duk_uint32_t) \
++	)
++#define DUK_HOBJECT_P_SET_REALLOC_PTRS(p_base,set_e_k,set_e_pv,set_e_f,set_a,set_h,n_ent,n_arr,n_hash)  do { \
++		(set_e_pv) = (duk_propvalue *) (p_base); \
++		(set_e_k) = (duk_hstring **) ((set_e_pv) + (n_ent)); \
++		(set_e_f) = (duk_uint8_t *) ((set_e_k) + (n_ent)); \
++		(set_a) = (duk_tval *) (((duk_uint8_t *) (set_e_f)) + \
++		                        sizeof(duk_uint8_t) * (n_ent) + \
++		                        DUK_HOBJECT_E_FLAG_PADDING((n_ent))); \
++		(set_h) = (duk_uint32_t *) ((set_a) + (n_arr)); \
++	} while (0)
++#elif defined(DUK_USE_HOBJECT_LAYOUT_3)
++/* LAYOUT 3 */
++#define DUK_HOBJECT_E_GET_KEY_BASE(heap,h) \
++	((duk_hstring **) ( \
++		DUK_HOBJECT_GET_PROPS((heap), (h)) + \
++			DUK_HOBJECT_GET_ESIZE((h)) * sizeof(duk_propvalue) + \
++			DUK_HOBJECT_GET_ASIZE((h)) * sizeof(duk_tval) \
++	))
++#define DUK_HOBJECT_E_GET_VALUE_BASE(heap,h) \
++	((duk_propvalue *) ( \
++		DUK_HOBJECT_GET_PROPS((heap), (h)) \
++	))
++#define DUK_HOBJECT_E_GET_FLAGS_BASE(heap,h) \
++	((duk_uint8_t *) ( \
++		DUK_HOBJECT_GET_PROPS((heap), (h)) + \
++			DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_propvalue) + sizeof(duk_hstring *)) + \
++			DUK_HOBJECT_GET_ASIZE((h)) * sizeof(duk_tval) + \
++			DUK_HOBJECT_GET_HSIZE((h)) * sizeof(duk_uint32_t) \
++	))
++#define DUK_HOBJECT_A_GET_BASE(heap,h) \
++	((duk_tval *) ( \
++		DUK_HOBJECT_GET_PROPS((heap), (h)) + \
++			DUK_HOBJECT_GET_ESIZE((h)) * sizeof(duk_propvalue) \
++	))
++#define DUK_HOBJECT_H_GET_BASE(heap,h) \
++	((duk_uint32_t *) ( \
++		DUK_HOBJECT_GET_PROPS((heap), (h)) + \
++			DUK_HOBJECT_GET_ESIZE((h)) * (sizeof(duk_propvalue) + sizeof(duk_hstring *)) + \
++			DUK_HOBJECT_GET_ASIZE((h)) * sizeof(duk_tval) \
++	))
++#define DUK_HOBJECT_P_COMPUTE_SIZE(n_ent,n_arr,n_hash) \
++	( \
++		(n_ent) * (sizeof(duk_propvalue) + sizeof(duk_hstring *) + sizeof(duk_uint8_t)) + \
++		(n_arr) * sizeof(duk_tval) + \
++		(n_hash) * sizeof(duk_uint32_t) \
++	)
++#define DUK_HOBJECT_P_SET_REALLOC_PTRS(p_base,set_e_k,set_e_pv,set_e_f,set_a,set_h,n_ent,n_arr,n_hash)  do { \
++		(set_e_pv) = (duk_propvalue *) (p_base); \
++		(set_a) = (duk_tval *) ((set_e_pv) + (n_ent)); \
++		(set_e_k) = (duk_hstring **) ((set_a) + (n_arr)); \
++		(set_h) = (duk_uint32_t *) ((set_e_k) + (n_ent)); \
++		(set_e_f) = (duk_uint8_t *) ((set_h) + (n_hash)); \
++	} while (0)
++#else
++#error invalid hobject layout defines
++#endif  /* hobject property layout */
++
++#define DUK_HOBJECT_E_ALLOC_SIZE(h) \
++	DUK_HOBJECT_P_COMPUTE_SIZE(DUK_HOBJECT_GET_ESIZE((h)), DUK_HOBJECT_GET_ASIZE((h)), DUK_HOBJECT_GET_HSIZE((h)))
++
++#define DUK_HOBJECT_E_GET_KEY(heap,h,i)              (DUK_HOBJECT_E_GET_KEY_BASE((heap), (h))[(i)])
++#define DUK_HOBJECT_E_GET_KEY_PTR(heap,h,i)          (&DUK_HOBJECT_E_GET_KEY_BASE((heap), (h))[(i)])
++#define DUK_HOBJECT_E_GET_VALUE(heap,h,i)            (DUK_HOBJECT_E_GET_VALUE_BASE((heap), (h))[(i)])
++#define DUK_HOBJECT_E_GET_VALUE_PTR(heap,h,i)        (&DUK_HOBJECT_E_GET_VALUE_BASE((heap), (h))[(i)])
++#define DUK_HOBJECT_E_GET_VALUE_TVAL(heap,h,i)       (DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).v)
++#define DUK_HOBJECT_E_GET_VALUE_TVAL_PTR(heap,h,i)   (&DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).v)
++#define DUK_HOBJECT_E_GET_VALUE_GETTER(heap,h,i)     (DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).a.get)
++#define DUK_HOBJECT_E_GET_VALUE_GETTER_PTR(heap,h,i) (&DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).a.get)
++#define DUK_HOBJECT_E_GET_VALUE_SETTER(heap,h,i)     (DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).a.set)
++#define DUK_HOBJECT_E_GET_VALUE_SETTER_PTR(heap,h,i) (&DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).a.set)
++#define DUK_HOBJECT_E_GET_FLAGS(heap,h,i)            (DUK_HOBJECT_E_GET_FLAGS_BASE((heap), (h))[(i)])
++#define DUK_HOBJECT_E_GET_FLAGS_PTR(heap,h,i)        (&DUK_HOBJECT_E_GET_FLAGS_BASE((heap), (h))[(i)])
++#define DUK_HOBJECT_A_GET_VALUE(heap,h,i)            (DUK_HOBJECT_A_GET_BASE((heap), (h))[(i)])
++#define DUK_HOBJECT_A_GET_VALUE_PTR(heap,h,i)        (&DUK_HOBJECT_A_GET_BASE((heap), (h))[(i)])
++#define DUK_HOBJECT_H_GET_INDEX(heap,h,i)            (DUK_HOBJECT_H_GET_BASE((heap), (h))[(i)])
++#define DUK_HOBJECT_H_GET_INDEX_PTR(heap,h,i)        (&DUK_HOBJECT_H_GET_BASE((heap), (h))[(i)])
++
++#define DUK_HOBJECT_E_SET_KEY(heap,h,i,k)  do { \
++		DUK_HOBJECT_E_GET_KEY((heap), (h), (i)) = (k); \
++	} while (0)
++#define DUK_HOBJECT_E_SET_VALUE(heap,h,i,v)  do { \
++		DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)) = (v); \
++	} while (0)
++#define DUK_HOBJECT_E_SET_VALUE_TVAL(heap,h,i,v)  do { \
++		DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).v = (v); \
++	} while (0)
++#define DUK_HOBJECT_E_SET_VALUE_GETTER(heap,h,i,v)  do { \
++		DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).a.get = (v); \
++	} while (0)
++#define DUK_HOBJECT_E_SET_VALUE_SETTER(heap,h,i,v)  do { \
++		DUK_HOBJECT_E_GET_VALUE((heap), (h), (i)).a.set = (v); \
++	} while (0)
++#define DUK_HOBJECT_E_SET_FLAGS(heap,h,i,f)  do { \
++		DUK_HOBJECT_E_GET_FLAGS((heap), (h), (i)) = (f); \
++	} while (0)
++#define DUK_HOBJECT_A_SET_VALUE(heap,h,i,v)  do { \
++		DUK_HOBJECT_A_GET_VALUE((heap), (h), (i)) = (v); \
++	} while (0)
++#define DUK_HOBJECT_A_SET_VALUE_TVAL(heap,h,i,v) \
++	DUK_HOBJECT_A_SET_VALUE((heap), (h), (i), (v))  /* alias for above */
++#define DUK_HOBJECT_H_SET_INDEX(heap,h,i,v)  do { \
++		DUK_HOBJECT_H_GET_INDEX((heap), (h), (i)) = (v); \
++	} while (0)
++
++#define DUK_HOBJECT_E_SET_FLAG_BITS(heap,h,i,mask)  do { \
++		DUK_HOBJECT_E_GET_FLAGS_BASE((heap), (h))[(i)] |= (mask); \
++	} while (0)
++
++#define DUK_HOBJECT_E_CLEAR_FLAG_BITS(heap,h,i,mask)  do { \
++		DUK_HOBJECT_E_GET_FLAGS_BASE((heap), (h))[(i)] &= ~(mask); \
++	} while (0)
++
++#define DUK_HOBJECT_E_SLOT_IS_WRITABLE(heap,h,i)     ((DUK_HOBJECT_E_GET_FLAGS((heap), (h), (i)) & DUK_PROPDESC_FLAG_WRITABLE) != 0)
++#define DUK_HOBJECT_E_SLOT_IS_ENUMERABLE(heap,h,i)   ((DUK_HOBJECT_E_GET_FLAGS((heap), (h), (i)) & DUK_PROPDESC_FLAG_ENUMERABLE) != 0)
++#define DUK_HOBJECT_E_SLOT_IS_CONFIGURABLE(heap,h,i) ((DUK_HOBJECT_E_GET_FLAGS((heap), (h), (i)) & DUK_PROPDESC_FLAG_CONFIGURABLE) != 0)
++#define DUK_HOBJECT_E_SLOT_IS_ACCESSOR(heap,h,i)     ((DUK_HOBJECT_E_GET_FLAGS((heap), (h), (i)) & DUK_PROPDESC_FLAG_ACCESSOR) != 0)
++
++#define DUK_HOBJECT_E_SLOT_SET_WRITABLE(heap,h,i)        DUK_HOBJECT_E_SET_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_WRITABLE)
++#define DUK_HOBJECT_E_SLOT_SET_ENUMERABLE(heap,h,i)      DUK_HOBJECT_E_SET_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_ENUMERABLE)
++#define DUK_HOBJECT_E_SLOT_SET_CONFIGURABLE(heap,h,i)    DUK_HOBJECT_E_SET_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_CONFIGURABLE)
++#define DUK_HOBJECT_E_SLOT_SET_ACCESSOR(heap,h,i)        DUK_HOBJECT_E_SET_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_ACCESSOR)
++
++#define DUK_HOBJECT_E_SLOT_CLEAR_WRITABLE(heap,h,i)      DUK_HOBJECT_E_CLEAR_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_WRITABLE)
++#define DUK_HOBJECT_E_SLOT_CLEAR_ENUMERABLE(heap,h,i)    DUK_HOBJECT_E_CLEAR_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_ENUMERABLE)
++#define DUK_HOBJECT_E_SLOT_CLEAR_CONFIGURABLE(heap,h,i)  DUK_HOBJECT_E_CLEAR_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_CONFIGURABLE)
++#define DUK_HOBJECT_E_SLOT_CLEAR_ACCESSOR(heap,h,i)      DUK_HOBJECT_E_CLEAR_FLAG_BITS((heap), (h), (i),DUK_PROPDESC_FLAG_ACCESSOR)
++
++#define DUK_PROPDESC_IS_WRITABLE(p)             (((p)->flags & DUK_PROPDESC_FLAG_WRITABLE) != 0)
++#define DUK_PROPDESC_IS_ENUMERABLE(p)           (((p)->flags & DUK_PROPDESC_FLAG_ENUMERABLE) != 0)
++#define DUK_PROPDESC_IS_CONFIGURABLE(p)         (((p)->flags & DUK_PROPDESC_FLAG_CONFIGURABLE) != 0)
++#define DUK_PROPDESC_IS_ACCESSOR(p)             (((p)->flags & DUK_PROPDESC_FLAG_ACCESSOR) != 0)
++
++#define DUK_HOBJECT_HASHIDX_UNUSED              0xffffffffUL
++#define DUK_HOBJECT_HASHIDX_DELETED             0xfffffffeUL
++
++/*
++ *  Macros for accessing size fields
++ */
++
++#if defined(DUK_USE_OBJSIZES16)
++#define DUK_HOBJECT_GET_ESIZE(h) ((h)->e_size16)
++#define DUK_HOBJECT_SET_ESIZE(h,v) do { (h)->e_size16 = (v); } while (0)
++#define DUK_HOBJECT_GET_ENEXT(h) ((h)->e_next16)
++#define DUK_HOBJECT_SET_ENEXT(h,v) do { (h)->e_next16 = (v); } while (0)
++#define DUK_HOBJECT_POSTINC_ENEXT(h) ((h)->e_next16++)
++#define DUK_HOBJECT_GET_ASIZE(h) ((h)->a_size16)
++#define DUK_HOBJECT_SET_ASIZE(h,v) do { (h)->a_size16 = (v); } while (0)
++#if defined(DUK_USE_HOBJECT_HASH_PART)
++#define DUK_HOBJECT_GET_HSIZE(h) ((h)->h_size16)
++#define DUK_HOBJECT_SET_HSIZE(h,v) do { (h)->h_size16 = (v); } while (0)
++#else
++#define DUK_HOBJECT_GET_HSIZE(h) 0
++#define DUK_HOBJECT_SET_HSIZE(h,v) do { DUK_ASSERT((v) == 0); } while (0)
++#endif
++#else
++#define DUK_HOBJECT_GET_ESIZE(h) ((h)->e_size)
++#define DUK_HOBJECT_SET_ESIZE(h,v) do { (h)->e_size = (v); } while (0)
++#define DUK_HOBJECT_GET_ENEXT(h) ((h)->e_next)
++#define DUK_HOBJECT_SET_ENEXT(h,v) do { (h)->e_next = (v); } while (0)
++#define DUK_HOBJECT_POSTINC_ENEXT(h) ((h)->e_next++)
++#define DUK_HOBJECT_GET_ASIZE(h) ((h)->a_size)
++#define DUK_HOBJECT_SET_ASIZE(h,v) do { (h)->a_size = (v); } while (0)
++#if defined(DUK_USE_HOBJECT_HASH_PART)
++#define DUK_HOBJECT_GET_HSIZE(h) ((h)->h_size)
++#define DUK_HOBJECT_SET_HSIZE(h,v) do { (h)->h_size = (v); } while (0)
++#else
++#define DUK_HOBJECT_GET_HSIZE(h) 0
++#define DUK_HOBJECT_SET_HSIZE(h,v) do { DUK_ASSERT((v) == 0); } while (0)
++#endif
++#endif
++
++/*
++ *  Misc
++ */
++
++/* Maximum prototype traversal depth.  Sanity limit which handles e.g.
++ * prototype loops (even complex ones like 1->2->3->4->2->3->4->2->3->4).
++ */
++#define DUK_HOBJECT_PROTOTYPE_CHAIN_SANITY      10000L
++
++/* Maximum traversal depth for "bound function" chains. */
++#define DUK_HOBJECT_BOUND_CHAIN_SANITY          10000L
++
++/*
++ *  Ecmascript [[Class]]
++ */
++
++/* range check not necessary because all 4-bit values are mapped */
++#define DUK_HOBJECT_CLASS_NUMBER_TO_STRIDX(n)  duk_class_number_to_stridx[(n)]
++
++#define DUK_HOBJECT_GET_CLASS_STRING(heap,h)          \